sass 3.5.2 → 3.7.4

data/lib/sass/script/lexer.rb

@@ -190,6 +190,14 @@ module Sass
         @scanner.string[pos, 1]
       end
 
+      # Consumes and returns single raw character from the input stream.
+      #
+      # @return [String]
+      def next_char
+        unpeek!
+        scan(/./)
+      end
+
       # Returns the next token without moving the lexer forward.
       #
       # @return [Token] The next token
@@ -200,6 +208,7 @@ module Sass
       # Rewinds the underlying StringScanner
       # to before the token returned by \{#peek}.
       def unpeek!
+        raise "[BUG] Can't unpeek before a queued token!" if @next_tok
         return unless @tok
         @scanner.pos = @tok.pos
         @line = @tok.source_range.start_pos.line
@@ -243,6 +252,30 @@ module Sass
         @scanner.string[old_pos...new_pos]
       end
 
+      # Runs a block, and rewinds the state of the lexer to the beginning of the
+      # block if it returns `nil` or `false`.
+      def try
+        old_pos = @scanner.pos
+        old_line = @line
+        old_offset = @offset
+        old_interpolation_stack = @interpolation_stack.dup
+        old_prev = @prev
+        old_tok = @tok
+        old_next_tok = @next_tok
+
+        result = yield
+        return result if result
+
+        @scanner.pos = old_pos
+        @line = old_line
+        @offset = old_offset
+        @interpolation_stack = old_interpolation_stack
+        @prev = old_prev
+        @tok = old_tok
+        @next_tok = old_next_tok
+        nil
+      end
+
       private
 
       def read_token
@@ -266,10 +299,14 @@ module Sass
       end
 
       def token
-        if after_interpolation? && (interp = @interpolation_stack.pop)
-          interp_type, interp_value = interp
+        if after_interpolation?
+          interp_type, interp_value = @interpolation_stack.pop
           if interp_type == :special_fun
             return special_fun_body(interp_value)
+          elsif interp_type.nil?
+            if @scanner.string[@scanner.pos - 1] == '}' && scan(REGULAR_EXPRESSIONS[:ident])
+              return [@scanner[2] ? :funcall : :ident, Sass::Util.normalize_ident_escapes(@scanner[1], start: false)]
+            end
           else
             raise "[BUG]: Unknown interp_type #{interp_type}" unless interp_type == :string
             return string(interp_value, true)
@@ -287,13 +324,12 @@ module Sass
 
       def _variable(rx)
         return unless scan(rx)
-
-        [:const, @scanner[2]]
+        [:const, Sass::Util.normalize_ident_escapes(@scanner[2])]
       end
 
       def ident
         return unless scan(REGULAR_EXPRESSIONS[:ident])
-        [@scanner[2] ? :funcall : :ident, @scanner[1]]
+        [@scanner[2] ? :funcall : :ident, Sass::Util.normalize_ident_escapes(@scanner[1])]
       end
 
       def string(re, open)
@@ -349,7 +385,9 @@ MESSAGE
 
         value = (@scanner[1] ? @scanner[1].to_f : @scanner[2].to_i) * (minus ? -1 : 1)
         value *= 10**@scanner[3].to_i if @scanner[3]
-        script_number = Script::Value::Number.new(value, Array(@scanner[4]))
+        units = @scanner[4]
+        units = Sass::Util::normalize_ident_escapes(units) if units
+        script_number = Script::Value::Number.new(value, Array(units))
         [:number, script_number]
       end
 
@@ -368,24 +406,20 @@ MESSAGE
         # IDs in properties are used in the Basic User Interface Module
         # (http://www.w3.org/TR/css3-ui/).
         return unless scan(REGULAR_EXPRESSIONS[:id])
-        if @scanner[0] =~ /^\#[0-9a-fA-F]+$/
-          if @scanner[0].length == 4 || @scanner[0].length == 7
-            return [:color, Script::Value::Color.from_hex(@scanner[0])]
-          elsif @scanner[0].length == 5 || @scanner[0].length == 9
-            filename = @options[:filename]
-            Sass::Util.sass_warn <<MESSAGE
-DEPRECATION WARNING on line #{line}, column #{offset}#{" of #{filename}" if filename}:
-The value "#{@scanner[0]}" is currently parsed as a string, but it will be parsed as a color in
-future versions of Sass. Use "unquote('#{@scanner[0]}')" to continue parsing it as a string.
-MESSAGE
-          end
+        if @scanner[0] =~ /^\#[0-9a-fA-F]+$/ &&
+          (@scanner[0].length == 4 || @scanner[0].length == 5 ||
+           @scanner[0].length == 7 || @scanner[0].length == 9)
+          return [:color, Script::Value::Color.from_hex(@scanner[0])]
         end
-        [:ident, @scanner[0]]
+        [:ident, Sass::Util.normalize_ident_escapes(@scanner[0])]
       end
 
       def color
         return unless @scanner.match?(REGULAR_EXPRESSIONS[:color])
-        return unless @scanner[0].length == 4 || @scanner[0].length == 7
+        unless @scanner[0].length == 4 || @scanner[0].length == 5 ||
+               @scanner[0].length == 7 || @scanner[0].length == 9
+          return
+        end
         script_color = Script::Value::Color.from_hex(scan(REGULAR_EXPRESSIONS[:color]))
         [:color, script_color]
       end
@@ -393,6 +427,15 @@ MESSAGE
       def selector
         start_pos = source_position
         return unless scan(REGULAR_EXPRESSIONS[:selector])
+
+        if @scanner.peek(1) == '&'
+          filename = @options[:filename]
+          Sass::Util.sass_warn <<MESSAGE
+WARNING on line #{line}, column #{offset}#{" of #{filename}" if filename}:
+In Sass, "&&" means two copies of the parent selector. You probably want to use "and" instead.
+MESSAGE
+        end
+
         script_selector = Script::Tree::Selector.new
         script_selector.source_range = range(start_pos)
         [:selector, script_selector]

data/lib/sass/script/parser.rb

@@ -78,7 +78,7 @@ module Sass
       # Parses a SassScript expression,
       # ending it when it encounters one of the given identifier tokens.
       #
-      # @param tokens [#include?(String)] A set of strings that delimit the expression.
+      # @param tokens [#include?(String | Symbol)] A set of strings or symbols that delimit the expression.
       # @return [Script::Tree::Node] The root node of the parse tree
       # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
       def parse_until(tokens)
@@ -270,7 +270,11 @@ module Sass
               interp = try_ops_after_interp(#{ops.inspect}, #{name.inspect})
               return interp if interp
               return unless e = #{sub}
-              while tok = try_toks(#{ops.map {|o| o.inspect}.join(', ')})
+
+              while tok = peek_toks(#{ops.map {|o| o.inspect}.join(', ')})
+                return e if @stop_at && @stop_at.include?(tok.type)
+                @lexer.next
+
                 if interp = try_op_before_interp(tok, e)
                   other_interp = try_ops_after_interp(#{ops.inspect}, #{name.inspect}, interp)
                   return interp unless other_interp
@@ -323,6 +327,7 @@ RUBY
           pair = map_pair
           return map unless pair
           map.pairs << pair
+          map.source_range.end_pos = map.pairs.last.last.source_range.end_pos
         end
         map
       end
@@ -385,8 +390,11 @@ RUBY
 
       def try_ops_after_interp(ops, name, prev = nil)
         return unless @lexer.after_interpolation?
-        op = try_toks(*ops)
+        op = peek_toks(*ops)
         return unless op
+        return if @stop_at && @stop_at.include?(op.type)
+        @lexer.next
+
         interp = try_op_before_interp(op, prev, :after_interp)
         return interp if interp
 
@@ -415,7 +423,7 @@ RUBY
         while (interp = try_tok(:begin_interpolation))
           wb = @lexer.whitespace?(interp)
           char_before = @lexer.char(interp.pos - 1)
-          mid = assert_expr :expr
+          mid = without_stop_at {assert_expr :expr}
           assert_tok :end_interpolation
           wa = @lexer.whitespace?
           char_after = @lexer.char
@@ -496,7 +504,7 @@ RUBY
       unary :not, :ident
 
       def ident
-        return funcall unless @lexer.peek && @lexer.peek.type == :ident
+        return css_min_max unless @lexer.peek && @lexer.peek.type == :ident
         return if @stop_at && @stop_at.include?(@lexer.peek.value)
 
         name = @lexer.next
@@ -513,6 +521,122 @@ RUBY
         end
       end
 
+      def css_min_max
+        @lexer.try do
+          next unless tok = try_tok(:funcall)
+          next unless %w[min max].include?(tok.value.downcase)
+          next unless contents = min_max_contents
+          node(array_to_interpolation(["#{tok.value}(", *contents]),
+               tok.source_range.start_pos, source_position)
+        end || funcall
+      end
+
+      def min_max_contents(allow_comma: true)
+        result = []
+        loop do
+          if tok = try_tok(:number)
+            result << tok.value.to_s
+          elsif value = min_max_interpolation
+            result << value
+          elsif value = min_max_calc
+            result << value.value
+          elsif value = min_max_function ||
+                        min_max_parens ||
+                        nested_min_max
+            result.concat value
+          else
+            return
+          end
+
+          if try_tok(:rparen)
+            result << ")"
+            return result
+          elsif tok = try_tok(:plus) || try_tok(:minus) || try_tok(:times) || try_tok(:div)
+            result << " #{Lexer::OPERATORS_REVERSE[tok.type]} "
+          elsif allow_comma && try_tok(:comma)
+            result << ", "
+          else
+            return
+          end
+        end
+      end
+
+      def min_max_interpolation
+        without_stop_at do
+          tok = try_tok(:begin_interpolation)
+          return unless tok
+          expr = without_stop_at {assert_expr :expr}
+          assert_tok :end_interpolation
+          expr
+        end
+      end
+
+      def min_max_function
+        return unless tok = peek_tok(:funcall)
+        return unless %w[calc env var].include?(tok.value.downcase)
+        @lexer.next
+        result = [tok.value, '(', *declaration_value, ')']
+        assert_tok :rparen
+        result
+      end
+
+      def min_max_calc
+        return unless tok = peek_tok(:special_fun)
+        return unless tok.value.value.downcase.start_with?("calc(")
+        @lexer.next.value
+      end
+
+      def min_max_parens
+        return unless try_tok :lparen
+        return unless contents = min_max_contents(allow_comma: false)
+        ['(', *contents]
+      end
+
+      def nested_min_max
+        return unless tok = peek_tok(:funcall)
+        return unless %w[min max].include?(tok.value.downcase)
+        @lexer.next
+        return unless contents = min_max_contents
+        [tok.value, '(', *contents]
+      end
+
+      def declaration_value
+        result = []
+        brackets = []
+        loop do
+          result << @lexer.str do
+            until @lexer.done? ||
+                  peek_toks(:begin_interpolation,
+                            :end_interpolation,
+                            :lcurly,
+                            :lparen,
+                            :lsquare,
+                            :rparen,
+                            :rsquare)
+              @lexer.next || @lexer.next_char
+            end
+          end
+
+          if try_tok(:begin_interpolation)
+            result << assert_expr(:expr)
+            assert_tok :end_interpolation
+          elsif tok = try_toks(:lcurly, :lparen, :lsquare)
+            brackets << case tok.type
+                        when :lcurly; :end_interpolation
+                        when :lparen; :rparen
+                        when :lsquare; :rsquare
+                        end
+            result << Lexer::OPERATORS_REVERSE[tok.type]
+          elsif brackets.empty?
+            return result
+          else
+            bracket = brackets.pop
+            assert_tok bracket
+            result << Lexer::OPERATORS_REVERSE[bracket]
+          end
+        end
+      end
+
       def funcall
         tok = try_tok(:funcall)
         return raw unless tok
@@ -529,28 +653,30 @@ RUBY
           return [], nil unless try_tok(:lparen)
         end
 
-        res = []
-        splat = nil
-        must_have_default = false
-        loop do
-          break if peek_tok(:rparen)
-          c = assert_tok(:const)
-          var = node(Script::Tree::Variable.new(c.value), c.source_range)
-          if try_tok(:colon)
-            val = assert_expr(:space)
-            must_have_default = true
-          elsif try_tok(:splat)
-            splat = var
-            break
-          elsif must_have_default
-            raise SyntaxError.new(
-              "Required argument #{var.inspect} must come before any optional arguments.")
+        without_stop_at do
+          res = []
+          splat = nil
+          must_have_default = false
+          loop do
+            break if peek_tok(:rparen)
+            c = assert_tok(:const)
+            var = node(Script::Tree::Variable.new(c.value), c.source_range)
+            if try_tok(:colon)
+              val = assert_expr(:space)
+              must_have_default = true
+            elsif try_tok(:splat)
+              splat = var
+              break
+            elsif must_have_default
+              raise SyntaxError.new(
+                "Required argument #{var.inspect} must come before any optional arguments.")
+            end
+            res << [var, val]
+            break unless try_tok(:comma)
           end
-          res << [var, val]
-          break unless try_tok(:comma)
+          assert_tok(:rparen)
+          return res, splat
         end
-        assert_tok(:rparen)
-        return res, splat
       end
 
       def fn_arglist
@@ -562,36 +688,38 @@ RUBY
       end
 
       def arglist(subexpr, description)
-        args = []
-        keywords = Sass::Util::NormalizedMap.new
-        splat = nil
-        while (e = send(subexpr))
-          if @lexer.peek && @lexer.peek.type == :colon
-            name = e
-            @lexer.expected!("comma") unless name.is_a?(Tree::Variable)
-            assert_tok(:colon)
-            value = assert_expr(subexpr, description)
-
-            if keywords[name.name]
-              raise SyntaxError.new("Keyword argument \"#{name.to_sass}\" passed more than once")
-            end
+        without_stop_at do
+          args = []
+          keywords = Sass::Util::NormalizedMap.new
+          splat = nil
+          while (e = send(subexpr))
+            if @lexer.peek && @lexer.peek.type == :colon
+              name = e
+              @lexer.expected!("comma") unless name.is_a?(Tree::Variable)
+              assert_tok(:colon)
+              value = assert_expr(subexpr, description)
+
+              if keywords[name.name]
+                raise SyntaxError.new("Keyword argument \"#{name.to_sass}\" passed more than once")
+              end
 
-            keywords[name.name] = value
-          else
-            if try_tok(:splat)
-              return args, keywords, splat, e if splat
-              splat, e = e, nil
-            elsif splat
-              raise SyntaxError.new("Only keyword arguments may follow variable arguments (...).")
-            elsif !keywords.empty?
-              raise SyntaxError.new("Positional arguments must come before keyword arguments.")
+              keywords[name.name] = value
+            else
+              if try_tok(:splat)
+                return args, keywords, splat, e if splat
+                splat, e = e, nil
+              elsif splat
+                raise SyntaxError.new("Only keyword arguments may follow variable arguments (...).")
+              elsif !keywords.empty?
+                raise SyntaxError.new("Positional arguments must come before keyword arguments.")
+              end
+              args << e if e
             end
-            args << e if e
-          end
 
-          return args, keywords, splat unless try_tok(:comma)
+            return args, keywords, splat unless try_tok(:comma)
+          end
+          return args, keywords
         end
-        return args, keywords
       end
 
       def raw
@@ -605,7 +733,7 @@ RUBY
         return square_list unless first
         str = literal_node(first.value, first.source_range)
         return str unless try_tok(:string_interpolation)
-        mid = assert_expr :expr
+        mid = without_stop_at {assert_expr :expr}
         assert_tok :end_interpolation
         last = assert_expr(:special_fun)
         node(
@@ -617,54 +745,58 @@ RUBY
         start_pos = source_position
         return paren unless try_tok(:lsquare)
 
-        space_start_pos = source_position
-        e = interpolation(inner: :or_expr)
-        separator = nil
-        if e
-          elements = [e]
-          while (e = interpolation(inner: :or_expr))
-            elements << e
-          end
-
-          # If there's a comma after a space-separated list, it's actually a
-          # space-separated list nested in a comma-separated list.
-          if try_tok(:comma)
-            e = if elements.length == 1
-                  elements.first
-                else
-                  node(
-                    Sass::Script::Tree::ListLiteral.new(elements, separator: :space),
-                    space_start_pos)
-                end
+        without_stop_at do
+          space_start_pos = source_position
+          e = interpolation(inner: :or_expr)
+          separator = nil
+          if e
             elements = [e]
-
-            while (e = space)
+            while (e = interpolation(inner: :or_expr))
               elements << e
-              break unless try_tok(:comma)
             end
-            separator = :comma
+
+            # If there's a comma after a space-separated list, it's actually a
+            # space-separated list nested in a comma-separated list.
+            if try_tok(:comma)
+              e = if elements.length == 1
+                    elements.first
+                  else
+                    node(
+                      Sass::Script::Tree::ListLiteral.new(elements, separator: :space),
+                      space_start_pos)
+                  end
+              elements = [e]
+
+              while (e = space)
+                elements << e
+                break unless try_tok(:comma)
+              end
+              separator = :comma
+            else
+              separator = :space if elements.length > 1
+            end
           else
-            separator = :space if elements.length > 1
+            elements = []
           end
-        else
-          elements = []
-        end
 
-        assert_tok(:rsquare)
-        end_pos = source_position
+          assert_tok(:rsquare)
+          end_pos = source_position
 
-        node(Sass::Script::Tree::ListLiteral.new(elements, separator: separator, bracketed: true),
-             start_pos, end_pos)
+          node(Sass::Script::Tree::ListLiteral.new(elements, separator: separator, bracketed: true),
+               start_pos, end_pos)
+        end
       end
 
       def paren
         return variable unless try_tok(:lparen)
-        start_pos = source_position
-        e = map
-        e.force_division! if e
-        end_pos = source_position
-        assert_tok(:rparen)
-        e || node(Sass::Script::Tree::ListLiteral.new([]), start_pos, end_pos)
+        without_stop_at do
+          start_pos = source_position
+          e = map
+          e.force_division! if e
+          end_pos = source_position
+          assert_tok(:rparen)
+          e || node(Sass::Script::Tree::ListLiteral.new([]), start_pos, end_pos)
+        end
       end
 
       def variable
@@ -681,7 +813,7 @@ RUBY
         return str unless try_tok(:string_interpolation)
         mid = assert_expr :expr
         assert_tok :end_interpolation
-        last = assert_expr(:string)
+        last = without_stop_at {assert_expr(:string)}
         node(Tree::StringInterpolation.new(str, mid, last), first.source_range.start_pos)
       end
 
@@ -739,7 +871,12 @@ RUBY
       def peek_tok(name)
         # Avoids an array allocation caused by argument globbing in the try_toks method.
         peeked = @lexer.peek
-        peeked && name == peeked.type
+        peeked && name == peeked.type && peeked
+      end
+
+      def peek_toks(*names)
+        peeked = @lexer.peek
+        peeked && names.include?(peeked.type) && peeked
       end
 
       def try_tok(name)
@@ -747,8 +884,7 @@ RUBY
       end
 
       def try_toks(*names)
-        peeked = @lexer.peek
-        peeked && names.include?(peeked.type) && @lexer.next
+        peek_toks(*names) && @lexer.next
       end
 
       def assert_done
@@ -762,6 +898,14 @@ RUBY
         end
       end
 
+      def without_stop_at
+        old_stop_at = @stop_at
+        @stop_at = nil
+        yield
+      ensure
+        @stop_at = old_stop_at
+      end
+
       # @overload node(value, source_range)
       #   @param value [Sass::Script::Value::Base]
       #   @param source_range [Sass::Source::Range]
@@ -794,6 +938,29 @@ RUBY
         node
       end
 
+      # Converts an array of strings and expressions to a string interoplation
+      # object.
+      #
+      # @param array [Array<Script::Tree:Node | String>]
+      # @return [Script::Tree::StringInterpolation]
+      def array_to_interpolation(array)
+        Sass::Util.merge_adjacent_strings(array).reverse.inject(nil) do |after, value|
+          if value.is_a?(::String)
+            literal = Sass::Script::Tree::Literal.new(
+              Sass::Script::Value::String.new(value))
+            next literal unless after
+            Sass::Script::Tree::StringInterpolation.new(literal, after.mid, after.after)
+          else
+            Sass::Script::Tree::StringInterpolation.new(
+              Sass::Script::Tree::Literal.new(
+                Sass::Script::Value::String.new('')),
+              value,
+              after || Sass::Script::Tree::Literal.new(
+                Sass::Script::Value::String.new('')))
+          end
+        end
+      end
+
       # Checks a script node for any immediately-deprecated interpolations, and
       # emits warnings for them.
       #