Making the 'url' css function take more dynamic arguments.

document.hpp

@@ -164,6 +164,7 @@ namespace Sass {
     Node parse_string();
     Node parse_value_schema();
     Node parse_identifier_schema();
+    Node parse_url_schema();
     Node parse_if_directive(Node surrounding_ruleset, Node::Type inside_of = Node::none);
     Node parse_for_directive(Node surrounding_ruleset, Node::Type inside_of = Node::none);
     Node parse_each_directive(Node surrounding_ruleset, Node::Type inside_of = Node::none);

document_parser.cpp

@@ -858,20 +858,19 @@ namespace Sass {
       Node result(context.new_Node(Node::uri, path, line, 1));
       if (lex< variable >()) {
         result << context.new_Node(Node::variable, path, line, lexed);
-        if (!lex< exactly<')'> >()) throw_syntax_error("URI is missing ')'");
         result.should_eval() = true;
       }
       else if (lex< string_constant >()) {
         result << parse_string();
-        if (!lex< exactly<')'> >()) throw_syntax_error("URI is missing ')'");
         result.should_eval() = true;
       }
-      // else if (lex< value_schema >()) {
-      //   cerr << lexed.to_string() << endl;
-      //   result << Document::make_from_token(context, lexed, path, line).parse_value_schema();
-      //   if (!lex< exactly<')'> >()) throw_syntax_error("URI is missing ')'");
-      //   result.should_eval() = true;
-      // }
+      else if (lex< url_schema >()) {
+        result << Document::make_from_token(context, lexed, path, line).parse_url_schema();
+        result.should_eval() = true;
+      }
+      else if (lex< url_value >()) {
+        result << context.new_Node(Node::identifier, path, line, lexed);
+      }
       else {
         const char* value = position;
         const char* rparen = find_first< exactly<')'> >(position);
@@ -881,8 +880,8 @@ namespace Sass {
         // lex< string_constant >();
         result << content_node;
         position = rparen;
-        lex< exactly<')'> >();
       }
+      if (!lex< exactly<')'> >()) throw_syntax_error("URI is missing ')'");
       return result;
     }
 
@@ -1021,6 +1020,35 @@ namespace Sass {
     return schema;
   }
 
+  Node Document::parse_url_schema()
+  {    
+    Node schema(context.new_Node(Node::value_schema, path, line, 1));
+    
+    while (position < end) {
+      if (position[0] == '/') {
+        lexed = Token::make(position, position+1);
+        schema << context.new_Node(Node::identifier, path, line, lexed);
+        ++position;
+      }
+      else if (lex< interpolant >()) {
+        Token insides(Token::make(lexed.begin + 2, lexed.end - 1));
+        Node interp_node(Document::make_from_token(context, insides, path, line).parse_list());
+        schema << interp_node;
+      }
+      else if (lex< sequence< identifier, exactly<':'> > >()) {
+        schema << context.new_Node(Node::identifier, path, line, lexed);
+      }
+      else if (lex< filename >()) {
+        schema << context.new_Node(Node::identifier, path, line, lexed);
+      }
+      else {
+        throw_syntax_error("error parsing interpolated url");
+      }
+    }
+    schema.should_eval() = true;
+    return schema;
+  }
+
   Node Document::parse_identifier_schema()
   {
     lex< sequence< optional< exactly<'*'> >, identifier_schema > >();

prelexer.cpp

 #include <cctype>
 #include "prelexer.hpp"
+#include <iostream>
 
 namespace Sass {
   namespace Prelexer {
-    
+    using std::cerr; using std::endl;
     // Matches zero characters (always succeeds without consuming input).
     const char* epsilon(char *src) {
       return src;
@@ -94,6 +95,15 @@ namespace Sass {
                                  interpolant,
                                  zero_plus< alternatives< identifier, percentage, dimension, hex, number, string_constant > > > >(src);
     }
+    const char* filename_schema(const char* src) {
+      return one_plus< sequence< zero_plus< alternatives< identifier, number, exactly<'.'>, exactly<'/'> > >,
+                                 interpolant,
+                                 zero_plus< alternatives< identifier, number, exactly<'.'>, exactly<'/'> > > > >(src);
+    }
+
+    const char* filename(const char* src) {
+      return one_plus< alternatives< identifier, number, exactly<'.'> > >(src);
+    }
     
     // Match CSS '@' keywords.
     const char* at_keyword(const char* src) {
@@ -279,11 +289,14 @@ namespace Sass {
                        optional<spaces>,
                        exactly<')'> >(src);
     }
-    const char* url(const char* src) {
+    const char* url_value(const char* src) {
+      return sequence< optional< sequence< identifier, exactly<':'> > >, // optional protocol
+                       one_plus< sequence< zero_plus< exactly<'/'> >, filename > >, // one or more folders and/or trailing filename
+                       optional< exactly<'/'> > >(src);
+    }
+    const char* url_schema(const char* src) {
       return sequence< optional< sequence< identifier, exactly<':'> > >, // optional protocol
-                       optional< exactly<':'> >, // extra slash
-                       one_plus< sequence< exactly<'/'>, value_schema > >, // one or more folders and/or trailing filename
-                       optional< exactly<'/'> > >(src); // optional trailing slash
+                       filename_schema >(src); // optional trailing slash
     }
     // Match SCSS image-url function
     extern const char image_url_kwd[] = "image-url(";

prelexer.hpp

@@ -305,6 +305,10 @@ namespace Sass {
     // Match interpolant schemas
     const char* identifier_schema(const char* src);
     const char* value_schema(const char* src);
+    const char* filename(const char* src);
+    const char* filename_schema(const char* src);
+    const char* url_schema(const char* src);
+    const char* url_value(const char* src);
     // Match CSS '@' keywords.
     const char* at_keyword(const char* src);
     const char* import(const char* src);