sass 3.2.19 → 3.3.0.alpha.1

data/lib/sass/script/lexer.rb

@@ -69,7 +69,8 @@ module Sass
 
       TOKEN_NAMES = Sass::Util.map_hash(OPERATORS_REVERSE) {|k, v| [k, v.inspect]}.merge({
           :const => "variable (e.g. $foo)",
-          :ident => "identifier (e.g. middle)"
+          :ident => "identifier (e.g. middle)",
+          :bool => "boolean (e.g. true, false)",
         })
 
       # A list of operator strings ordered with longer names first
@@ -89,6 +90,8 @@ module Sass
         :ident => /(#{IDENT})(\()?/,
         :number => /(-)?(?:(\d*\.\d+)|(\d+))([a-zA-Z%]+)?/,
         :color => HEXCOLOR,
+        :bool => /(true|false)\b/,
+        :null => /null\b/,
         :ident_op => %r{(#{Regexp.union(*IDENT_OP_NAMES.map{|s| Regexp.new(Regexp.escape(s) + "(?!#{NMCHAR}|\Z)")})})},
         :op => %r{(#{Regexp.union(*OP_NAMES)})},
       }
@@ -107,28 +110,18 @@ module Sass
       # while the boolean represents whether or not the string
       # is following an interpolated segment.
       STRING_REGULAR_EXPRESSIONS = {
-        :double => {
-          false => string_re('"', '"'),
-          true => string_re('', '"')
-        },
-        :single => {
-          false => string_re("'", "'"),
-          true => string_re('', "'")
-        },
-        :uri => {
-          false => /url\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
-          true => /(#{URLCHAR}*?)(#{W}\)|#\{)/
-        },
+        [:double, false] => string_re('"', '"'),
+        [:single, false] => string_re("'", "'"),
+        [:double, true] => string_re('', '"'),
+        [:single, true] => string_re('', "'"),
+        [:uri, false] => /url\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
+        [:uri, 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}\)|#\{)/
-        }
+        [:url_prefix, false] => /url-prefix\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
+        [:url_prefix, true] => /(#{URLCHAR}*?)(#{W}\)|#\{)/,
+        [:domain, false] => /domain\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
+        [:domain, true] => /(#{URLCHAR}*?)(#{W}\)|#\{)/,
       }
 
       # @param str [String, StringScanner] The source text to lex
@@ -242,9 +235,9 @@ module Sass
           return string(interp_type, true)
         end
 
-        variable || string(:double, false) || string(:single, false) || number || color ||
-          string(:uri, false) || raw(UNICODERANGE) || special_fun || special_val || ident_op ||
-          ident || op
+        variable || string(:double, false) || string(:single, false) || number ||
+          color || bool || null || string(:uri, false) || raw(UNICODERANGE) ||
+          special_fun || special_val || ident_op || ident || op
       end
 
       def variable
@@ -252,6 +245,8 @@ module Sass
       end
 
       def _variable(rx)
+        line = @line
+        offset = @offset
         return unless scan(rx)
 
         [:const, @scanner[2]]
@@ -263,7 +258,7 @@ module Sass
       end
 
       def string(re, open)
-        return unless scan(STRING_REGULAR_EXPRESSIONS[re][open])
+        return unless scan(STRING_REGULAR_EXPRESSIONS[[re, open]])
         if @scanner[2] == '#{' #'
           @scanner.pos -= 2 # Don't actually consume the #{
           @interpolation_stack << re
@@ -294,6 +289,16 @@ MESSAGE
         [:color, Script::Color.new(value)]
       end
 
+      def bool
+        return unless s = scan(REGULAR_EXPRESSIONS[:bool])
+        [:bool, Script::Bool.new(s == 'true')]
+      end
+
+      def null
+        return unless scan(REGULAR_EXPRESSIONS[:null])
+        [:null, Script::Null.new]
+      end
+
       def special_fun
         return unless str1 = scan(/((-[\w-]+-)?(calc|element)|expression|progid:[a-z\.]*)\(/i)
         str2, _ = Sass::Shared.balance(@scanner, ?(, ?), 1)

data/lib/sass/script/list.rb

@@ -49,8 +49,7 @@ module Sass::Script
       return "()" if value.empty?
       precedence = Sass::Script::Parser.precedence_of(separator)
       value.reject {|e| e.is_a?(Null)}.map do |v|
-        if v.is_a?(List) && Sass::Script::Parser.precedence_of(v.separator) <= precedence ||
-            separator == :space && v.is_a?(UnaryOperation) && (v.operator == :minus || v.operator == :plus)
+        if v.is_a?(List) && Sass::Script::Parser.precedence_of(v.separator) <= precedence
           "(#{v.to_sass(opts)})"
         else
           v.to_sass(opts)

data/lib/sass/script/literal.rb

@@ -90,6 +90,24 @@ MSG
       Sass::Script::Bool.new(!to_bool)
     end
 
+    # The SassScript default operation (e.g. `$a $b`, `"foo" "bar"`).
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Script::String] A string containing both literals
+    #   separated by a space
+    def space(other)
+      Sass::Script::String.new("#{self.to_s} #{other.to_s}")
+    end
+
+    # The SassScript `,` operation (e.g. `$a, $b`, `"foo", "bar"`).
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Script::String] A string containing both literals
+    #   separated by `", "`
+    def comma(other)
+      Sass::Script::String.new("#{self.to_s},#{' ' unless options[:style] == :compressed}#{other.to_s}")
+    end
+
     # The SassScript `=` operation
     # (used for proprietary MS syntax like `alpha(opacity=20)`).
     #

data/lib/sass/script/null.rb

@@ -22,10 +22,7 @@ module Sass::Script
     def to_s(opts = {})
       ''
     end
-
-    def to_sass(opts = {})
-      'null'
-    end
+    alias_method :to_sass, :to_s
 
     # Returns a string representing a null value.
     #

data/lib/sass/script/operation.rb

@@ -35,6 +35,7 @@ module Sass::Script
 
     # @see Node#to_sass
     def to_sass(opts = {})
+      pred = Sass::Script::Parser.precedence_of(@operator)
       o1 = operand_to_sass @operand1, :left, opts
       o2 = operand_to_sass @operand2, :right, opts
       sep =

data/lib/sass/script/parser.rb

@@ -203,7 +203,7 @@ module Sass
         # sub is the name of the production beneath it,
         # and ops is a list of operators for this precedence level
         def production(name, sub, *ops)
-          class_eval <<RUBY, __FILE__, __LINE__ + 1
+          class_eval <<RUBY
             def #{name}
               interp = try_ops_after_interp(#{ops.inspect}, #{name.inspect}) and return interp
               return unless e = #{sub}
@@ -223,7 +223,7 @@ RUBY
         end
 
         def unary(op, sub)
-          class_eval <<RUBY, __FILE__, __LINE__ + 1
+          class_eval <<RUBY
             def unary_#{op}
               return #{sub} unless tok = try_tok(:#{op})
               interp = try_op_before_interp(tok) and return interp
@@ -242,17 +242,18 @@ RUBY
       def lexer_class; Lexer; end
 
       def expr
+        interp = try_ops_after_interp([:comma], :expr) and return interp
         line = @lexer.line
         return unless e = interpolation
-        list = node(List.new([e], :comma), line)
+        arr = [e]
         while tok = try_tok(:comma)
-          if interp = try_op_before_interp(tok, list)
+          if interp = try_op_before_interp(tok, e)
             return interp unless other_interp = try_ops_after_interp([:comma], :expr, interp)
             return other_interp
           end
-          list.value << assert_expr(:interpolation)
+          arr << assert_expr(:interpolation)
         end
-        list.value.size == 1 ? list.value.first : list
+        arr.size == 1 ? arr.first : node(List.new(arr, :comma), line)
       end
 
       production :equals, :interpolation, :single_eq
@@ -321,16 +322,9 @@ RUBY
 
         name = @lexer.next
         if color = Color::COLOR_NAMES[name.value.downcase]
-          node(Color.new(color))
-        elsif name.value == "true"
-          node(Script::Bool.new(true))
-        elsif name.value == "false"
-          node(Script::Bool.new(false))
-        elsif name.value == "null"
-          node(Script::Null.new)
-        else
-          node(Script::String.new(name.value, :identifier))
+          return node(Color.new(color))
         end
+        node(Script::String.new(name.value, :identifier))
       end
 
       def funcall
@@ -352,6 +346,8 @@ RUBY
         splat = nil
         must_have_default = false
         loop do
+          line = @lexer.line
+          offset = @lexer.offset + 1
           c = assert_tok(:const)
           var = Script::Variable.new(c.value)
           if try_tok(:colon)
@@ -371,41 +367,38 @@ RUBY
       end
 
       def fn_arglist
-        arglist(:equals, "function argument")
+        arglist(:fn_arglist, :equals)
       end
 
       def mixin_arglist
-        arglist(:interpolation, "mixin argument")
+        arglist(:mixin_arglist, :interpolation)
       end
 
-      def arglist(subexpr, description)
+      def arglist(type, subexpr)
         return unless e = send(subexpr)
+        if @lexer.peek && @lexer.peek.type == :colon
+          name = e
+          @lexer.expected!("comma") unless name.is_a?(Variable)
+          assert_tok(:colon)
+          keywords = {name.underscored_name => assert_expr(subexpr, EXPR_NAMES[type])}
+        end
 
-        args = []
-        keywords = {}
-        loop do
-          if @lexer.peek && @lexer.peek.type == :colon
-            name = e
-            @lexer.expected!("comma") unless name.is_a?(Variable)
-            assert_tok(:colon)
-            value = assert_expr(subexpr, description)
-
-            if keywords[name.underscored_name]
-              raise SyntaxError.new("Keyword argument \"#{name.to_sass}\" passed more than once")
-            end
-
-            keywords[name.underscored_name] = value
-          else
-            if !keywords.empty?
-              raise SyntaxError.new("Positional arguments must come before keyword arguments.")
-            end
+        unless try_tok(:comma)
+          return [], keywords if keywords
+          return [], {}, e if try_tok(:splat)
+          return [e], {}
+        end
 
-            return args, keywords, e if try_tok(:splat)
-            args << e
+        other_args, other_keywords, splat = assert_expr(type)
+        if keywords
+          if !other_args.empty? || splat
+            raise SyntaxError.new("Positional arguments must come before keyword arguments.")
+          elsif other_keywords[name.underscored_name]
+            raise SyntaxError.new("Keyword argument \"#{name.to_sass}\" passed more than once")
           end
-
-          return args, keywords unless try_tok(:comma)
-          e = assert_expr(subexpr, description)
+          return other_args, keywords.merge(other_keywords), splat
+        else
+          return [e, *other_args], other_keywords, splat
         end
       end
 
@@ -460,7 +453,7 @@ RUBY
       end
 
       def literal
-        (t = try_tok(:color)) && (return t.value)
+        (t = try_tok(:color, :bool, :null)) && (return t.value)
       end
 
       # It would be possible to have unified #assert and #try methods,

data/lib/sass/script/string.rb

@@ -33,7 +33,7 @@ module Sass::Script
     # @see Node#to_s
     def to_s(opts = {})
       if @type == :identifier
-        return @value.gsub(/\n\s*/, " ")
+        return @value.tr("\n", " ")
       end
 
       return "\"#{value.gsub('"', "\\\"")}\"" if opts[:quote] == %q{"}

data/lib/sass/script/unary_operation.rb

@@ -4,14 +4,9 @@ module Sass::Script
   #
   # Currently only `-`, `/`, and `not` are unary operators.
   class UnaryOperation < Node
-    # @return [Symbol] The operation to perform
-    attr_reader :operator
-
-    # @return [Script::Node] The parse-tree node for the object of the operator
-    attr_reader :operand
-
-    # @param operand [Script::Node] See \{#operand}
-    # @param operator [Symbol] See \{#operator}
+    # @param operand [Script::Node] The parse-tree node
+    #   for the object of the operator
+    # @param operator [Symbol] The operator to perform
     def initialize(operand, operator)
       @operand = operand
       @operator = operator

data/lib/sass/scss/parser.rb

@@ -52,18 +52,6 @@ module Sass
         ql
       end
 
-      # Parses a supports query condition.
-      #
-      # @return [Sass::Supports::Condition] The parsed condition
-      # @raise [Sass::SyntaxError] if there's a syntax error in the condition,
-      #   or if it doesn't take up the entire input string.
-      def parse_supports_condition
-        init_scanner!
-        condition = supports_condition
-        expected("supports condition") unless @scanner.eos?
-        condition
-      end
-
       private
 
       include Sass::SCSS::RX
@@ -120,6 +108,7 @@ module Sass
           value = [text.sub(/^\s*\/\//, '/*').gsub(/^\s*\/\//, ' *') + ' */']
         else
           value = Sass::Engine.parse_interp(text, line, @scanner.pos - text.size, :filename => @filename)
+          value[0].slice!(2) if loud # get rid of the "!"
           value.unshift(@scanner.
             string[0...@scanner.pos].
             reverse[/.*?\*\/(.*?)($|\Z)/, 1].
@@ -311,20 +300,16 @@ module Sass
 
         loop do
           values << expr!(:import_arg)
-          break if use_css_import?
-          break unless tok(/,/)
-          ss
+          break if use_css_import? || !tok(/,\s*/)
         end
 
         return values
       end
 
       def import_arg
-        line = @line
         return unless (str = tok(STRING)) || (uri = tok?(/url\(/i))
         if uri
           str = sass_script(:parse_string)
-          ss
           media = media_query_list
           ss
           return node(Tree::CssImportNode.new(str, media.to_a))
@@ -334,19 +319,17 @@ module Sass
         ss
 
         media = media_query_list
-        if path =~ /^(https?:)?\/\// || media || use_css_import?
-          node = Sass::Tree::CssImportNode.new(str, media.to_a)
-        else
-          node = Sass::Tree::ImportNode.new(path.strip)
+        if path =~ /^http:\/\// || media || use_css_import?
+          return node(Sass::Tree::CssImportNode.new(str, media.to_a))
         end
-        node.line = line
-        node
+
+        node(Sass::Tree::ImportNode.new(path.strip))
       end
 
       def use_css_import?; false; end
 
       def media_directive
-        block(node(Sass::Tree::MediaNode.new(expr!(:media_query_list).to_a)), :directive)
+        block(node(Sass::Tree::MediaNode.new(media_query_list.to_a)), :directive)
       end
 
       # http://www.w3.org/TR/css3-mediaqueries/#syntax
@@ -691,7 +674,7 @@ module Sass
             expected('"{"') if res.length == 1 && res[0].is_a?(Selector::Universal)
             throw_error {expected('"{"')}
           rescue Sass::SyntaxError => e
-            e.message << "\n\n\"#{sel}\" may only be used at the beginning of a compound selector."
+            e.message << "\n\n\"#{sel}\" may only be used at the beginning of a selector."
             raise e
           end
         end
@@ -723,7 +706,7 @@ module Sass
       end
 
       def element_name
-        ns, name = Sass::Util.destructure(qualified_name(:allow_star_name))
+        ns, name = qualified_name(:allow_star_name)
         return unless ns || name
 
         if name == '*'
@@ -814,7 +797,7 @@ module Sass
         # could start a pseudo expression like "n+1", or it could start a
         # selector like "n|m". In order to handle this, we must regrettably
         # backtrack.
-        expr, sel = nil, nil
+        expr, sel = nil
         pseudo_err = catch_error do
           expr = pseudo_expr
           next if tok?(/[,)]/)
@@ -954,10 +937,10 @@ MESSAGE
       end
 
       def _interp_string(type)
-        return unless start = tok(Sass::Script::Lexer::STRING_REGULAR_EXPRESSIONS[type][false])
+        return unless start = tok(Sass::Script::Lexer::STRING_REGULAR_EXPRESSIONS[[type, false]])
         res = [start]
 
-        mid_re = Sass::Script::Lexer::STRING_REGULAR_EXPRESSIONS[type][true]
+        mid_re = Sass::Script::Lexer::STRING_REGULAR_EXPRESSIONS[[type, true]]
         # @scanner[2].empty? means we've started an interpolated section
         while @scanner[2] == '#{'
           @scanner.pos -= 2 # Don't consume the #{
@@ -998,7 +981,7 @@ MESSAGE
         line = @line
         @strs.push ""
         throw_error {yield} && @strs.last
-      rescue Sass::SyntaxError
+      rescue Sass::SyntaxError => e
         @scanner.pos = pos
         @line = line
         nil
@@ -1038,7 +1021,6 @@ MESSAGE
 
       EXPR_NAMES = {
         :media_query => "media query (e.g. print, screen, print and screen)",
-        :media_query_list => "media query (e.g. print, screen, print and screen)",
         :media_expr => "media expression (e.g. (min-device-width: 800px))",
         :pseudo_arg => "expression (e.g. fr, 2n+1)",
         :interp_ident => "identifier",
@@ -1046,7 +1028,6 @@ MESSAGE
         :qualified_name => "identifier",
         :expr => "expression (e.g. 1px, bold)",
         :_selector => "selector",
-        :selector_comma_sequence => "selector",
         :simple_selector_sequence => "selector",
         :import_arg => "file to import (string or url())",
         :moz_document_function => "matching function (e.g. url-prefix(), domain())",
@@ -1113,7 +1094,7 @@ MESSAGE
       end
 
       def rethrow(err)
-        if @throw_error
+        if @throw_err
           throw :_sass_parser_error, err
         else
           @scanner = Sass::Util::MultibyteStringScanner.new(@scanner.string)