fixes #75; import with url() should have importPath

Author: shellscape

.gitignore

@@ -1,3 +1,5 @@
+s.js
+
 /.vscode
 # Logs
 logs
@@ -31,4 +33,4 @@ node_modules
 .node_repl_history
 .idea
 DS_Store
-dist
+dist

lib/less-parser.js

@@ -133,7 +133,7 @@ export default class LessParser extends Parser {
   }
 
   import (token) {
-        /* eslint complexity: 0 */
+    /* eslint complexity: 0 */
     let last = false,
       open = false,
       end = { line: 0, column: 0 };
@@ -170,15 +170,28 @@ export default class LessParser extends Parser {
         if (directives.length) {
           node.raws.between = tokn[1];
         }
+        else if (node.urlFunc) {
+          node.raws.beforeUrl = tokn[1];
+        }
         else if (node.importPath) {
-          node.raws.after = tokn[1];
+          if (node.urlFunc) {
+            node.raws.afterUrl = tokn[1];
+          }
+          else {
+            node.raws.after = tokn[1];
+          }
         }
         else {
           node.raws.afterName = tokn[1];
         }
       }
+      else if (tokn[0] === 'word' && tokn[1] === 'url') {
+        node.urlFunc = true;
+      }
       else {
-        node.importPath = tokn[1];
+        if (tokn[0] !== '(' && tokn[0] !== ')') {
+          node.importPath = tokn[1];
+        }
       }
 
       if (this.pos === this.tokens.length) {

lib/less-stringifier.js

@@ -8,10 +8,14 @@ export default class LessStringifier extends Stringifier {
   import (node) {
     this.builder(`@${ node.name }`);
     this.builder((node.raws.afterName || '') +
-                     (node.directives || '') +
-                     (node.raws.between || '') +
-                     (node.importPath || '') +
-                     (node.raws.after || ''));
+                 (node.directives || '') +
+                 (node.raws.between || '') +
+                 (node.urlFunc ? 'url(' : '') +
+                 (node.raws.beforeUrl || '') +
+                 (node.importPath || '') +
+                 (node.raws.afterUrl || '') +
+                 (node.urlFunc ? ')' : '') +
+                 (node.raws.after || ''));
 
     if (node.raws.semicolon) {
       this.builder(';');

test/parser/import.spec.js

@@ -7,51 +7,68 @@ import lessSyntax from '../../lib/less-syntax';
 import postcss from 'postcss';
 
 describe('Parser', () => {
+  describe('Import', () => {
+    it('should parse @imports as Import', (done) => {
+      const lessText = '@import "foo.less";';
 
-  it('should parse @imports as Import', (done) => {
-    const lessText = '@import "foo.less";';
+      postcss()
+              .process(lessText, { syntax: lessSyntax })
+              .then((result) => {
+                expect(result).to.be.not.null;
+                expect(result.css).to.equal(lessText);
+                expect(result.root.first).to.be.an.instanceof(Import);
+                expect(result.root.first.importPath).to.equal('"foo.less"');
 
-    postcss()
-            .process(lessText, { syntax: lessSyntax })
-            .then((result) => {
-              expect(result).to.be.not.null;
-              expect(result.css).to.equal(lessText);
-              expect(result.root.first).to.be.an.instanceof(Import);
-              expect(result.root.first.importPath).to.equal('"foo.less"');
+                done();
+              }).catch(done);
+    });
 
-              done();
-            }).catch(done);
-  });
+    it('should parse @imports with a url function as Import', (done) => {
+      const lessText = '@import url("foo.less");';
 
-  it('should parse @imports as Import, no space', (done) => {
-    const lessText = '@import"foo.less";';
+      postcss()
+              .process(lessText, { syntax: lessSyntax })
+              .then((result) => {
+                expect(result).to.be.not.null;
+                expect(result.css).to.equal(lessText);
+                expect(result.root.first).to.be.an.instanceof(Import);
+                expect(result.root.first.importPath).to.equal('"foo.less"');
+                expect(result.root.first.urlFunc).to.equal(true);
 
-    postcss()
-            .process(lessText, { syntax: lessSyntax })
-            .then((result) => {
-              expect(result).to.be.not.null;
-              expect(result.css).to.equal(lessText);
-              expect(result.root.first).to.be.an.instanceof(Import);
-              expect(result.root.first.importPath).to.equal('"foo.less"');
-              expect(result.root.first.raws.afterName).to.be.undefined;
+                done();
+              }).catch(done);
+    });
 
-              done();
-            }).catch(done);
-  });
+    it('should parse @imports as Import, no space', (done) => {
+      const lessText = '@import"foo.less";';
+
+      postcss()
+              .process(lessText, { syntax: lessSyntax })
+              .then((result) => {
+                expect(result).to.be.not.null;
+                expect(result.css).to.equal(lessText);
+                expect(result.root.first).to.be.an.instanceof(Import);
+                expect(result.root.first.importPath).to.equal('"foo.less"');
+                expect(result.root.first.raws.afterName).to.be.undefined;
+
+                done();
+              }).catch(done);
+    });
 
-  it('should parse @imports with directives', (done) => {
-    const lessText = '@import (inline) "foo.less";';
+    it('should parse @imports with directives', (done) => {
+      const lessText = '@import (inline) "foo.less";';
 
-    postcss()
-            .process(lessText, { syntax: lessSyntax })
-            .then((result) => {
-              expect(result).to.be.not.null;
-              expect(result.css).to.equal(lessText);
-              expect(result.root.first).to.be.an.instanceof(Import);
-              expect(result.root.first.directives).to.equal('(inline)');
-              expect(result.root.first.importPath).to.equal('"foo.less"');
+      postcss()
+              .process(lessText, { syntax: lessSyntax })
+              .then((result) => {
+                expect(result).to.be.not.null;
+                expect(result.css).to.equal(lessText);
+                expect(result.root.first).to.be.an.instanceof(Import);
+                expect(result.root.first.directives).to.equal('(inline)');
+                expect(result.root.first.importPath).to.equal('"foo.less"');
 
-              done();
-            }).catch(done);
+                done();
+              }).catch(done);
+    });
   });
 });