Tests for new code in Attribute.

Author: chriseppstein

src/__tests__/attributes.js

@@ -1,5 +1,9 @@
+import process from "process";
+import Attribute from '../selectors/attribute';
 import {test} from './util/helpers';
 
+process.throwDeprecation = true;
+
 test('attribute selector', '[href]', (t, tree) => {
     t.deepEqual(tree.nodes[0].nodes[0].attribute, 'href');
     t.deepEqual(tree.nodes[0].nodes[0].type, 'attribute');
@@ -393,8 +397,51 @@ test('non standard modifiers', '[href="foo" y]', (t, tree) => {
     t.deepEqual(tree.toString(), '[href="foo" y]');
 });
 
-// This is a test case that fails in prettier. Not sure how to support it because I don't know that the range of allowed syntax is.
-// And even then, I'm not sure it makes sense.
-// test.skip('[nonstandard] function as attribute value', "[id=func('foo')]", (t, tree) => {
-//     t.deepEqual(tree.toString(), '[href="foo" y]');
-// });
+test('deprecated constructor', '', (t) => {
+    t.throws(
+        () => {
+            return new Attribute({value: '"foo"', attribute: "data-bar"});
+        },
+        "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now."
+    );
+});
+
+test('deprecated get of raws.unquoted ', '', (t) => {
+    t.throws(
+        () => {
+            let attr = new Attribute({value: 'foo', quoteMark: '"', attribute: "data-bar"});
+            return attr.raws.unquoted;
+        },
+        "attr.raws.unquoted is deprecated. Call attr.value instead."
+    );
+});
+
+test('deprecated set of raws.unquoted ', '', (t) => {
+    t.throws(
+        () => {
+            let attr = new Attribute({value: 'foo', quoteMark: '"', attribute: "data-bar"});
+            attr.raws.unquoted = 'fooooo';
+        },
+        "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now."
+    );
+});
+
+test('smart quotes', '[data-foo=bar]', (t, tree) => {
+    let attr = tree.nodes[0].nodes[0];
+    attr.setValue('changed', {quoteMark: '"'});
+    t.deepEqual(attr.toString(), '[data-foo="changed"]');
+    attr.setValue('changed again', {quoteMark: "'", preferCurrentQuoteMark: true});
+    t.deepEqual(attr.toString(), '[data-foo="changed again"]');
+    attr.setValue('smart-ident', {smart: true});
+    t.deepEqual(attr.toString(), '[data-foo=smart-ident]');
+    attr.setValue('smart quoted', {smart: true});
+    t.deepEqual(attr.toString(), '[data-foo=smart\\ quoted]');
+    attr.setValue('smart quoted three spaces', {smart: true});
+    t.deepEqual(attr.toString(), '[data-foo="smart quoted three spaces"]');
+    attr.setValue('smart quoted three spaces', {smart: true, quoteMark: "'"});
+    t.deepEqual(attr.toString(), "[data-foo='smart quoted three spaces']");
+    attr.setValue("smart with 'single quotes'", {smart: true});
+    t.deepEqual(attr.toString(), "[data-foo=\"smart with 'single quotes'\"]");
+    attr.setValue('smart with "double quotes"', {smart: true});
+    t.deepEqual(attr.toString(), "[data-foo='smart with \"double quotes\"']");
+});

src/__tests__/util/helpers.js

@@ -6,21 +6,16 @@ export const parse = (input, transform) => {
     return parser(transform).processSync(input);
 };
 
-export function test (spec, input, callback, only = false, disabled = false) {
+export function test (spec, input, callback, only = false, disabled = false, serial = false) {
     let tester = only ? ava.only : ava;
-    if (disabled) {
-        tester = ava.skip;
-    }
-    if (only) {
-        let e = new Error();
-        console.error(e);
-    }
+    tester = disabled ? tester.skip : tester;
+    tester = serial ? tester.serial : tester;
 
     if (callback) {
         tester(`${spec} (tree)`, t => {
             let tree = parser().astSync(input);
             let debug = util.inspect(tree, false, null);
-            callback.call(this, t, tree, debug);
+            return callback.call(this, t, tree, debug);
         });
     }
 
@@ -32,6 +27,7 @@ export function test (spec, input, callback, only = false, disabled = false) {
 
 test.only = (spec, input, callback) => test(spec, input, callback, true);
 test.skip = (spec, input, callback) => test(spec, input, callback, false, true);
+test.serial = (spec, input, callback) => test(spec, input, callback, false, false, true);
 
 export const throws = (spec, input, validator) => {
     ava(`${spec} (throws)`, t => {

src/selectors/attribute.js

@@ -113,7 +113,8 @@ export default class Attribute extends Namespace {
      */
     setValue (value, options = {}) {
         this._value = value;
-        this.quoteMark = this._determineQuoteMark(options);
+        this._quoteMark = this._determineQuoteMark(options);
+        this._syncRawValue();
     }
 
     /**
@@ -137,7 +138,17 @@ export default class Attribute extends Namespace {
             if (escaped === v) {
                 return Attribute.NO_QUOTE;
             } else {
-                return this.preferredQuoteMark(options);
+                let pref = this.preferredQuoteMark(options);
+                if (pref === Attribute.NO_QUOTE) {
+                    // pick a quote mark that isn't none and see if it's smaller
+                    let quote = this.quoteMark || options.quoteMark || Attribute.DOUBLE_QUOTE;
+                    let opts = CSSESC_QUOTE_OPTIONS[quote];
+                    let quoteValue = cssesc(v, opts);
+                    if (quoteValue.length < escaped.length) {
+                        return quote;
+                    }
+                }
+                return pref;
             }
         } else if (numDoubleQuotes === numSingleQuotes) {
             return this.preferredQuoteMark(options);
@@ -199,13 +210,17 @@ export default class Attribute extends Namespace {
             return;
         }
         if (this._quoteMark !== quoteMark) {
-            let rawValue = cssesc(this._value, CSSESC_QUOTE_OPTIONS[quoteMark]);
-            if (rawValue === this._value) {
-                delete this.raws.value;
-            } else {
-                this.raws.value = rawValue;
-            }
             this._quoteMark = quoteMark;
+            this._syncRawValue();
+        }
+    }
+
+    _syncRawValue () {
+        let rawValue = cssesc(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]);
+        if (rawValue === this._value) {
+            delete this.raws.value;
+        } else {
+            this.raws.value = rawValue;
         }
     }