sassc 1.9.0 → 1.10.0

data/ext/libsass/src/parser.hpp

@@ -133,6 +133,8 @@ namespace Sass {
     const char* lex(bool lazy = true, bool force = false)
     {
 
+      if (*position == 0) return 0;
+
       // position considered before lexed token
       // we can skip whitespace or comments for
       // lazy developers (but we need control)
@@ -298,12 +300,22 @@ namespace Sass {
     Supports_Condition* parse_supports_declaration();
     Supports_Condition* parse_supports_condition_in_parens();
     At_Root_Block* parse_at_root_block();
-    At_Root_Expression* parse_at_root_expression();
-    At_Rule* parse_at_rule();
+    At_Root_Query* parse_at_root_query();
+    String_Schema* parse_almost_any_value();
+    Directive* parse_special_directive();
+    Directive* parse_prefixed_directive();
+    Directive* parse_directive();
     Warning* parse_warning();
     Error* parse_error();
     Debug* parse_debug();
 
+    // be more like ruby sass
+    Expression* lex_almost_any_value_token();
+    Expression* lex_almost_any_value_chars();
+    Expression* lex_interp_string();
+    Expression* lex_interp_uri();
+    Expression* lex_interpolation();
+
     // these will throw errors
     Token lex_variable();
     Token lex_identifier();
@@ -319,6 +331,34 @@ namespace Sass {
 
     void throw_syntax_error(std::string message, size_t ln = 0);
     void throw_read_error(std::string message, size_t ln = 0);
+
+
+    template <Prelexer::prelexer open, Prelexer::prelexer close>
+    Expression* lex_interp()
+    {
+      if (lex < open >(false)) {
+        String_Schema* schema = SASS_MEMORY_NEW(ctx.mem, String_Schema, pstate);
+        // std::cerr << "LEX [[" << std::string(lexed) << "]]\n";
+        *schema << SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, lexed);
+        if (position[0] == '#' && position[1] == '{') {
+          Expression* itpl = lex_interpolation();
+          if (itpl) *schema << itpl;
+          while (lex < close >(false)) {
+            // std::cerr << "LEX [[" << std::string(lexed) << "]]\n";
+            *schema << SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, lexed);
+            if (position[0] == '#' && position[1] == '{') {
+              Expression* itpl = lex_interpolation();
+              if (itpl) *schema << itpl;
+            } else {
+              return schema;
+            }
+          }
+        } else {
+          return SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, lexed);
+        }
+      }
+      return 0;
+    }
   };
 
   size_t check_bom_chars(const char* src, const char *end, const unsigned char* bom, size_t len);

data/ext/libsass/src/prelexer.cpp

@@ -16,6 +16,248 @@ namespace Sass {
   namespace Prelexer {
 
 
+    /*
+
+        def string_re(open, close)
+          /#{open}((?:\\.|\#(?!\{)|[^#{close}\\#])*)(#{close}|#\{)/m
+        end
+      end
+
+      # A hash of regular expressions that are used for tokenizing strings.
+      #
+      # The key is a `[Symbol, Boolean]` pair.
+      # The symbol represents which style of quotation to use,
+      # while the boolean represents whether or not the string
+      # is following an interpolated segment.
+      STRING_REGULAR_EXPRESSIONS = {
+        :double => {
+          /#{open}((?:\\.|\#(?!\{)|[^#{close}\\#])*)(#{close}|#\{)/m
+          false => string_re('"', '"'),
+          true => string_re('', '"')
+        },
+        :single => {
+          false => string_re("'", "'"),
+          true => string_re('', "'")
+        },
+        :uri => {
+          false => /url\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
+          true => /(#{URLCHAR}*?)(#{W}\)|#\{)/
+        },
+        # Defined in https://developer.mozilla.org/en/CSS/@-moz-document as a
+        # non-standard version of http://www.w3.org/TR/css3-conditional/
+        :url_prefix => {
+          false => /url-prefix\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
+          true => /(#{URLCHAR}*?)(#{W}\)|#\{)/
+        },
+        :domain => {
+          false => /domain\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
+          true => /(#{URLCHAR}*?)(#{W}\)|#\{)/
+        }
+      }
+    */
+
+    /*
+      /#{open}
+        (
+          \\.
+          |
+          \# (?!\{)
+          |
+          [^#{close}\\#]
+        )*
+        (#{close}|#\{)
+      /m
+      false => string_re('"', '"'),
+      true => string_re('', '"')
+    */
+    extern const char string_double_negates[] = "\"\\#";
+    const char* re_string_double_close(const char* src)
+    {
+      return sequence <
+        // valid chars
+        zero_plus <
+          alternatives <
+            // escaped char
+            sequence <
+              exactly <'\\'>,
+              any_char
+            >,
+            // non interpolate hash
+            sequence <
+              exactly <'#'>,
+              negate <
+                exactly <'{'>
+              >
+            >,
+            // other valid chars
+            neg_class_char <
+              string_double_negates
+            >
+          >
+        >,
+        // quoted string closer
+        // or interpolate opening
+        alternatives <
+          exactly <'"'>,
+          lookahead < exactly< hash_lbrace > >
+        >
+      >(src);
+    }
+
+    const char* re_string_double_open(const char* src)
+    {
+      return sequence <
+        // quoted string opener
+        exactly <'"'>,
+        // valid chars
+        zero_plus <
+          alternatives <
+            // escaped char
+            sequence <
+              exactly <'\\'>,
+              any_char
+            >,
+            // non interpolate hash
+            sequence <
+              exactly <'#'>,
+              negate <
+                exactly <'{'>
+              >
+            >,
+            // other valid chars
+            neg_class_char <
+              string_double_negates
+            >
+          >
+        >,
+        // quoted string closer
+        // or interpolate opening
+        alternatives <
+          exactly <'"'>,
+          lookahead < exactly< hash_lbrace > >
+        >
+      >(src);
+    }
+
+    extern const char string_single_negates[] = "'\\#";
+    const char* re_string_single_close(const char* src)
+    {
+      return sequence <
+        // valid chars
+        zero_plus <
+          alternatives <
+            // escaped char
+            sequence <
+              exactly <'\\'>,
+              any_char
+            >,
+            // non interpolate hash
+            sequence <
+              exactly <'#'>,
+              negate <
+                exactly <'{'>
+              >
+            >,
+            // other valid chars
+            neg_class_char <
+              string_single_negates
+            >
+          >
+        >,
+        // quoted string closer
+        // or interpolate opening
+        alternatives <
+          exactly <'\''>,
+          lookahead < exactly< hash_lbrace > >
+        >
+      >(src);
+    }
+
+    const char* re_string_single_open(const char* src)
+    {
+      return sequence <
+        // quoted string opener
+        exactly <'\''>,
+        // valid chars
+        zero_plus <
+          alternatives <
+            // escaped char
+            sequence <
+              exactly <'\\'>,
+              any_char
+            >,
+            // non interpolate hash
+            sequence <
+              exactly <'#'>,
+              negate <
+                exactly <'{'>
+              >
+            >,
+            // other valid chars
+            neg_class_char <
+              string_single_negates
+            >
+          >
+        >,
+        // quoted string closer
+        // or interpolate opening
+        alternatives <
+          exactly <'\''>,
+          lookahead < exactly< hash_lbrace > >
+        >
+      >(src);
+    }
+
+    /*
+      :uri => {
+        false => /url\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
+        true => /(#{URLCHAR}*?)(#{W}\)|#\{)/
+      },
+    */
+    const char* re_string_uri_close(const char* src)
+    {
+      return sequence <
+        non_greedy<
+          alternatives<
+            class_char< real_uri_chars >,
+            uri_character,
+            NONASCII,
+            ESCAPE
+          >,
+          alternatives<
+            sequence < optional < W >, exactly <')'> >,
+            lookahead < exactly< hash_lbrace > >
+          >
+        >,
+        optional <
+          sequence < optional < W >, exactly <')'> >
+        >
+      >(src);
+    }
+
+    const char* re_string_uri_open(const char* src)
+    {
+      return sequence <
+        exactly <'u'>,
+        exactly <'r'>,
+        exactly <'l'>,
+        exactly <'('>,
+        W,
+        non_greedy<
+          alternatives<
+            class_char< real_uri_chars >,
+            uri_character,
+            NONASCII,
+            ESCAPE
+          >,
+          alternatives<
+            sequence < W, exactly <')'> >,
+            exactly< hash_lbrace >
+          >
+        >
+      >(src);
+    }
+
     // Match a line comment (/.*?(?=\n|\r\n?|\Z)/.
     const char* line_comment(const char* src)
     {
@@ -370,6 +612,133 @@ namespace Sass {
       return sequence<exactly<'@'>, identifier>(src);
     }
 
+    /*
+        tok(%r{
+          (
+            \\.
+          |
+            (?!url\()
+            [^"'/\#!;\{\}] # "
+          |
+            /(?![\*\/])
+          |
+            \#(?!\{)
+          |
+            !(?![a-z]) # TODO: never consume "!" when issue 1126 is fixed.
+          )+
+        }xi) || tok(COMMENT) || tok(SINGLE_LINE_COMMENT) || interp_string || interp_uri ||
+                interpolation(:warn_for_color)
+    */
+    const char* re_almost_any_value_token(const char* src) {
+
+      return alternatives <
+        one_plus <
+          alternatives <
+            sequence <
+              exactly <'\\'>,
+              any_char
+            >,
+            sequence <
+              negate <
+                sequence <
+                  exactly < url_kwd >,
+                  exactly <'('>
+                >
+              >,
+              neg_class_char <
+                almost_any_value_class
+              >
+            >,
+            sequence <
+              exactly <'/'>,
+              negate <
+                alternatives <
+                  exactly <'/'>,
+                  exactly <'*'>
+                >
+              >
+            >,
+            sequence <
+              exactly <'\\'>,
+              exactly <'#'>,
+              negate <
+                exactly <'{'>
+              >
+            >,
+            sequence <
+              exactly <'!'>,
+              negate <
+                alpha
+              >
+            >
+          >
+        >,
+        block_comment,
+        line_comment,
+        interpolant,
+        space,
+        sequence <
+          exactly<'u'>,
+          exactly<'r'>,
+          exactly<'l'>,
+          exactly<'('>,
+          zero_plus <
+            alternatives <
+              class_char< real_uri_chars >,
+              uri_character,
+              NONASCII,
+              ESCAPE
+            >
+          >,
+          // false => /url\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
+          // true => /(#{URLCHAR}*?)(#{W}\)|#\{)/
+          exactly<')'>
+        >
+      >(src);
+    }
+
+    /*
+      DIRECTIVES = Set[:mixin, :include, :function, :return, :debug, :warn, :for,
+        :each, :while, :if, :else, :extend, :import, :media, :charset, :content,
+        :_moz_document, :at_root, :error]
+    */
+    const char* re_special_directive(const char* src) {
+      return alternatives <
+        word < mixin_kwd >,
+        word < include_kwd >,
+        word < function_kwd >,
+        word < return_kwd >,
+        word < debug_kwd >,
+        word < warn_kwd >,
+        word < for_kwd >,
+        word < each_kwd >,
+        word < while_kwd >,
+        word < if_kwd >,
+        word < else_kwd >,
+        word < extend_kwd >,
+        word < import_kwd >,
+        word < media_kwd >,
+        word < charset_kwd >,
+        word < content_kwd >,
+        // exactly < moz_document_kwd >,
+        word < at_root_kwd >,
+        word < error_kwd >
+      >(src);
+    }
+
+    const char* re_prefixed_directive(const char* src) {
+      return sequence <
+        optional <
+          sequence <
+            exactly <'-'>,
+            one_plus < alnum >,
+            exactly <'-'>
+          >
+        >,
+        exactly < supports_kwd >
+      >(src);
+    }
+
     const char* re_reference_combinator(const char* src) {
       return sequence <
         optional <
@@ -508,7 +877,7 @@ namespace Sass {
       return one_plus< alternatives< alnum,
                                      exactly<'-'>,
                                      exactly<'_'>,
-                                     exactly<'\\'> > >(src);
+                                     escape_seq > >(src);
     }
 
     const char* kwd_warn(const char* src) {
@@ -586,7 +955,7 @@ namespace Sass {
     }
 
     const char* hyphens_and_identifier(const char* src) {
-      return sequence< zero_plus< exactly< '-' > >, identifier >(src);
+      return sequence< zero_plus< exactly< '-' > >, identifier_alnums >(src);
     }
     const char* hyphens_and_name(const char* src) {
       return sequence< zero_plus< exactly< '-' > >, name >(src);
@@ -596,11 +965,11 @@ namespace Sass {
     }
     // Match CSS id names.
     const char* id_name(const char* src) {
-      return sequence<exactly<'#'>, name>(src);
+      return sequence<exactly<'#'>, identifier_alnums >(src);
     }
     // Match CSS class names.
     const char* class_name(const char* src) {
-      return sequence<exactly<'.'>, identifier>(src);
+      return sequence<exactly<'.'>, identifier >(src);
     }
     // Attribute name in an attribute selector.
     const char* attribute_name(const char* src) {
@@ -609,7 +978,7 @@ namespace Sass {
     }
     // match placeholder selectors
     const char* placeholder(const char* src) {
-      return sequence<exactly<'%'>, identifier>(src);
+      return sequence<exactly<'%'>, identifier_alnums >(src);
     }
     // Match CSS numeric constants.
 
@@ -825,6 +1194,22 @@ namespace Sass {
       return sequence<exactly<'$'>, identifier>(src);
     }
 
+    // parse `calc`, `-a-calc` and `--b-c-calc`
+    // but do not parse `foocalc` or `foo-calc`
+    const char* calc_fn_call(const char* src) {
+      return sequence <
+        optional < sequence <
+          hyphens,
+          one_plus < sequence <
+            strict_identifier,
+            hyphens
+          > >
+        > >,
+        exactly < calc_fn_kwd >,
+        word_boundary
+      >(src);
+    }
+
     // Match Sass boolean keywords.
     const char* kwd_true(const char* src) {
       return word<true_kwd>(src);
@@ -1167,6 +1552,83 @@ namespace Sass {
       >(src);
     }
 
+    const char* re_selector_list(const char* src) {
+      return alternatives <
+        // partial bem selector
+        sequence <
+          ampersand,
+          one_plus <
+            exactly < '-' >
+          >,
+          word_boundary,
+          optional_spaces
+        >,
+        // main selector matching
+        one_plus <
+          alternatives <
+            // consume whitespace and comments
+            spaces, block_comment, line_comment,
+            // match `/deep/` selector (pass-trough)
+            // there is no functionality for it yet
+            schema_reference_combinator,
+            // match selector ops /[*&%,\[\]]/
+            class_char < selector_lookahead_ops >,
+            // match selector combinators /[>+~]/
+            class_char < selector_combinator_ops >,
+            // match attribute compare operators
+            sequence <
+              exactly <'('>,
+              optional_spaces,
+              optional <re_selector_list>,
+              optional_spaces,
+              exactly <')'>
+            >,
+            alternatives <
+              exact_match, class_match, dash_match,
+              prefix_match, suffix_match, substring_match
+            >,
+            // main selector match
+            sequence <
+              // allow namespace prefix
+              optional < namespace_schema >,
+              // modifiers prefixes
+              alternatives <
+                sequence <
+                  exactly <'#'>,
+                  // not for interpolation
+                  negate < exactly <'{'> >
+                >,
+                // class match
+                exactly <'.'>,
+                // single or double colon
+                optional < pseudo_prefix >
+              >,
+              // accept hypens in token
+              one_plus < sequence <
+                // can start with hyphens
+                zero_plus < exactly<'-'> >,
+                // now the main token
+                alternatives <
+                  kwd_optional,
+                  exactly <'*'>,
+                  quoted_string,
+                  interpolant,
+                  identifier,
+                  variable,
+                  percentage,
+                  binomial,
+                  dimension,
+                  alnum
+                >
+              > >,
+              // can also end with hyphens
+              zero_plus < exactly<'-'> >
+            >
+          >
+        >
+      >(src);
+    }
+
     const char* type_selector(const char* src) {
       return sequence< optional<namespace_schema>, identifier>(src);
     }
@@ -1183,6 +1645,12 @@ namespace Sass {
     // lexer special_fn: these functions cannot be overloaded
     // (/((-[\w-]+-)?(calc|element)|expression|progid:[a-z\.]*)\(/i)
     const char* re_special_fun(const char* src) {
+
+      // match this first as we test prefix hyphens
+      if (const char* calc = calc_fn_call(src)) {
+        return calc;
+      }
+
       return sequence <
         optional <
           sequence <
@@ -1197,8 +1665,7 @@ namespace Sass {
           >
         >,
         alternatives <
-          exactly < calc_fn_kwd >,
-          exactly < expression_kwd >,
+          word < expression_kwd >,
           sequence <
             sequence <
               exactly < progid_kwd >,