sass 3.4.0 → 3.4.25

data/lib/sass/script/lexer.rb

@@ -19,13 +19,13 @@ module Sass
       # `source_range`: \[`Sass::Source::Range`\]
       # : The range in the source file in which the token appeared.
       #
-      # `pos`: \[`Fixnum`\]
+      # `pos`: \[`Integer`\]
       # : The scanner position at which the SassScript token appeared.
       Token = Struct.new(:type, :value, :source_range, :pos)
 
       # The line number of the lexer's current position.
       #
-      # @return [Fixnum]
+      # @return [Integer]
       def line
         return @line unless @tok
         @tok.source_range.start_pos.line
@@ -34,7 +34,7 @@ module Sass
       # The number of bytes into the current line
       # of the lexer's current position (1-based).
       #
-      # @return [Fixnum]
+      # @return [Integer]
       def offset
         return @offset unless @tok
         @tok.source_range.start_pos.offset
@@ -71,8 +71,8 @@ module Sass
       OPERATORS_REVERSE = Sass::Util.map_hash(OPERATORS) {|k, v| [v, k]}
 
       TOKEN_NAMES = Sass::Util.map_hash(OPERATORS_REVERSE) {|k, v| [k, v.inspect]}.merge(
-          :const => "variable (e.g. $foo)",
-          :ident => "identifier (e.g. middle)")
+        :const => "variable (e.g. $foo)",
+        :ident => "identifier (e.g. middle)")
 
       # A list of operator strings ordered with longer names first
       # so that `>` and `<` don't clobber `>=` and `<=`.
@@ -80,7 +80,7 @@ module Sass
 
       # A sub-list of {OP_NAMES} that only includes operators
       # with identifier names.
-      IDENT_OP_NAMES = OP_NAMES.select {|k, v| k =~ /^\w+/}
+      IDENT_OP_NAMES = OP_NAMES.select {|k, _v| k =~ /^\w+/}
 
       PARSEABLE_NUMBER = /(?:(\d*\.\d+)|(\d+))(?:[eE]([+-]?\d+))?(#{UNIT})?/
 
@@ -142,12 +142,12 @@ module Sass
       }
 
       # @param str [String, StringScanner] The source text to lex
-      # @param line [Fixnum] The 1-based line on which the SassScript appears.
+      # @param line [Integer] The 1-based line on which the SassScript appears.
       #   Used for error reporting and sourcemap building
-      # @param offset [Fixnum] The 1-based character (not byte) offset in the line in the source.
+      # @param offset [Integer] The 1-based character (not byte) offset in the line in the source.
       #   Used for error reporting and sourcemap building
       # @param options [{Symbol => Object}] An options hash;
-      #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
+      #   see {file:SASS_REFERENCE.md#Options the Sass options documentation}
       def initialize(str, line, offset, options)
         @scanner = str.is_a?(StringScanner) ? str : Sass::Util::MultibyteStringScanner.new(str)
         @line = line
@@ -155,6 +155,8 @@ module Sass
         @options = options
         @interpolation_stack = []
         @prev = nil
+        @tok = nil
+        @next_tok = nil
       end
 
       # Moves the lexer forward one token.
@@ -179,6 +181,13 @@ module Sass
         end
       end
 
+      # Returns the given character.
+      #
+      # @return [String]
+      def char(pos = @scanner.pos)
+        @scanner.string[pos, 1]
+      end
+
       # Returns the next token without moving the lexer forward.
       #
       # @return [Token] The next token
@@ -189,16 +198,16 @@ module Sass
       # Rewinds the underlying StringScanner
       # to before the token returned by \{#peek}.
       def unpeek!
-        if @tok
-          @scanner.pos = @tok.pos
-          @line = @tok.source_range.start_pos.line
-          @offset = @tok.source_range.start_pos.offset
-        end
+        return unless @tok
+        @scanner.pos = @tok.pos
+        @line = @tok.source_range.start_pos.line
+        @offset = @tok.source_range.start_pos.offset
       end
 
       # @return [Boolean] Whether or not there's more source text to lex.
       def done?
-        whitespace unless after_interpolation? && @interpolation_stack.last
+        return if @next_tok
+        whitespace unless after_interpolation? && !@interpolation_stack.empty?
         @scanner.eos? && @tok.nil?
       end
 
@@ -235,6 +244,11 @@ module Sass
       private
 
       def read_token
+        if (tok = @next_tok)
+          @next_tok = nil
+          return tok
+        end
+
         return if done?
         start_pos = source_position
         value = token
@@ -293,9 +307,9 @@ MESSAGE
         end
 
         if @scanner[2] == '#{' # '
-          @scanner.pos -= 2 # Don't actually consume the #{
-          @offset -= 2
           @interpolation_stack << [:string, re]
+          start_pos = Sass::Source::Position.new(@line, @offset - 2)
+          @next_tok = Token.new(:string_interpolation, range(start_pos), @scanner.pos - 2)
         end
         str =
           if re == :uri
@@ -392,9 +406,9 @@ MESSAGE
           else
             raise "[BUG] Unreachable" unless @scanner[1] == '#{' # '
             str.slice!(-2..-1)
-            @scanner.pos -= 2 # Don't actually consume the #{
-            @offset -= 2
             @interpolation_stack << [:special_fun, parens]
+            start_pos = Sass::Source::Position.new(@line, @offset - 2)
+            @next_tok = Token.new(:string_interpolation, range(start_pos), @scanner.pos - 2)
           end
 
           return [:special_fun, Sass::Script::Value::String.new(str)]
@@ -405,7 +419,7 @@ MESSAGE
       end
 
       def special_val
-        return unless scan(/!important/i)
+        return unless scan(/!#{W}important/i)
         [:string, Script::Value::String.new("!important")]
       end
 
@@ -418,8 +432,9 @@ MESSAGE
       def op
         op = scan(REGULAR_EXPRESSIONS[:op])
         return unless op
-        @interpolation_stack << nil if op == :begin_interpolation
-        [OPERATORS[op]]
+        name = OPERATORS[op]
+        @interpolation_stack << nil if name == :begin_interpolation
+        [name]
       end
 
       def raw(rx)

data/lib/sass/script/parser.rb

@@ -1,4 +1,5 @@
 require 'sass/script/lexer'
+require 'sass/script/css_variable_warning'
 
 module Sass
   module Script
@@ -7,28 +8,34 @@ module Sass
     class Parser
       # The line number of the parser's current position.
       #
-      # @return [Fixnum]
+      # @return [Integer]
       def line
         @lexer.line
       end
 
       # The column number of the parser's current position.
       #
-      # @return [Fixnum]
+      # @return [Integer]
       def offset
         @lexer.offset
       end
 
       # @param str [String, StringScanner] The source text to parse
-      # @param line [Fixnum] The line on which the SassScript appears.
+      # @param line [Integer] The line on which the SassScript appears.
       #   Used for error reporting and sourcemap building
-      # @param offset [Fixnum] The character (not byte) offset where the script starts in the line.
+      # @param offset [Integer] The character (not byte) offset where the script starts in the line.
       #   Used for error reporting and sourcemap building
-      # @param options [{Symbol => Object}] An options hash;
-      #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
+      # @param options [{Symbol => Object}] An options hash; see
+      #   {file:SASS_REFERENCE.md#Options the Sass options documentation}.
+      #   This supports an additional `:allow_extra_text` option that controls
+      #   whether the parser throws an error when extra text is encountered
+      #   after the parsed construct.
       def initialize(str, line, offset, options = {})
         @options = options
+        @allow_extra_text = options.delete(:allow_extra_text)
         @lexer = lexer_class.new(str, line, offset, options)
+        @stop_at = nil
+        @css_variable_warning = nil
       end
 
       # Parses a SassScript expression within an interpolated segment (`#{}`).
@@ -46,7 +53,8 @@ module Sass
         expr = assert_expr :expr
         assert_tok :end_interpolation
         expr = Sass::Script::Tree::Interpolation.new(
-          nil, expr, nil, !:wb, !:wa, !:originally_text, warn_for_color)
+          nil, expr, nil, false, false, :warn_for_color => warn_for_color)
+        check_for_interpolation expr
         expr.options = @options
         node(expr, start_pos)
       rescue Sass::SyntaxError => e
@@ -56,12 +64,23 @@ module Sass
 
       # Parses a SassScript expression.
       #
+      # @param css_variable [Boolean] Whether this is the value of a CSS variable.
       # @return [Script::Tree::Node] The root node of the parse tree
       # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
-      def parse
+      def parse(css_variable = false)
+        if css_variable
+          @css_variable_warning = CssVariableWarning.new
+        end
+
         expr = assert_expr :expr
         assert_done
         expr.options = @options
+        check_for_interpolation expr
+
+        if css_variable
+          @css_variable_warning.value = expr
+        end
+
         expr
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -79,6 +98,7 @@ module Sass
         expr = assert_expr :expr
         assert_done
         expr.options = @options
+        check_for_interpolation expr
         expr
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -102,10 +122,26 @@ module Sass
         end
         assert_done
 
-        args.each {|a| a.options = @options}
-        keywords.each {|k, v| v.options = @options}
-        splat.options = @options if splat
-        kwarg_splat.options = @options if kwarg_splat
+        args.each do |a|
+          check_for_interpolation a
+          a.options = @options
+        end
+
+        keywords.each do |_k, v|
+          check_for_interpolation v
+          v.options = @options
+        end
+
+        if splat
+          check_for_interpolation splat
+          splat.options = @options
+        end
+
+        if kwarg_splat
+          check_for_interpolation kwarg_splat
+          kwarg_splat.options = @options
+        end
+
         return args, keywords, splat, kwarg_splat
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -122,10 +158,20 @@ module Sass
         assert_done
 
         args.each do |k, v|
+          check_for_interpolation k
           k.options = @options
-          v.options = @options if v
+
+          if v
+            check_for_interpolation v
+            v.options = @options
+          end
         end
-        splat.options = @options if splat
+
+        if splat
+          check_for_interpolation splat
+          splat.options = @options
+        end
+
         return args, splat
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -142,10 +188,20 @@ module Sass
         assert_done
 
         args.each do |k, v|
+          check_for_interpolation k
           k.options = @options
-          v.options = @options if v
+
+          if v
+            check_for_interpolation v
+            v.options = @options
+          end
         end
-        splat.options = @options if splat
+
+        if splat
+          check_for_interpolation splat
+          splat.options = @options
+        end
+
         return args, splat
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -165,6 +221,7 @@ module Sass
         end
 
         expr = assert_expr :funcall
+        check_for_interpolation expr
         expr.options = @options
         @lexer.unpeek!
         expr
@@ -175,12 +232,12 @@ module Sass
 
       # Parses a SassScript expression.
       #
-      # @overload parse(str, line, offset, filename = nil)
       # @return [Script::Tree::Node] The root node of the parse tree
       # @see Parser#initialize
       # @see Parser#parse
-      def self.parse(*args)
-        new(*args).parse
+      def self.parse(value, line, offset, options = {})
+        css_variable = options.delete :css_variable
+        new(value, line, offset, options).parse(css_variable)
       end
 
       PRECEDENCE = [
@@ -193,6 +250,8 @@ module Sass
 
       ASSOCIATIVE = [:plus, :times]
 
+      VALID_CSS_OPS = [:comma, :single_eq, :space, :div]
+
       class << self
         # Returns an integer representing the precedence
         # of the given operator.
@@ -232,6 +291,10 @@ module Sass
                   return other_interp
                 end
 
+                if @css_variable_warning && !VALID_CSS_OPS.include?(tok.type)
+                  @css_variable_warning.warn!
+                end
+
                 e = node(Tree::Operation.new(e, assert_expr(#{sub.inspect}), tok.type),
                          e.source_range.start_pos)
               end
@@ -247,6 +310,8 @@ RUBY
               interp = try_op_before_interp(tok)
               return interp if interp
               start_pos = source_position
+
+              @css_variable_warning.warn! if @css_variable_warning
               node(Tree::UnaryOperation.new(assert_expr(:unary_#{op}), :#{op}), start_pos)
             end
 RUBY
@@ -273,6 +338,7 @@ RUBY
         return list e, start_pos unless @lexer.peek && @lexer.peek.type == :colon
 
         pair = map_pair(e)
+        @css_variable_warning.warn! if @css_variable_warning
         map = node(Sass::Script::Tree::MapLiteral.new([pair]), start_pos)
         while try_tok(:comma)
           pair = map_pair
@@ -308,19 +374,32 @@ RUBY
           end
           return list unless (e = interpolation)
           list.elements << e
+          list.source_range.end_pos = list.elements.last.source_range.end_pos
         end
         list
       end
 
       production :equals, :interpolation, :single_eq
 
-      def try_op_before_interp(op, prev = nil)
+      def try_op_before_interp(op, prev = nil, after_interp = false)
         return unless @lexer.peek && @lexer.peek.type == :begin_interpolation
+        unary = !prev && !after_interp
         wb = @lexer.whitespace?(op)
         str = literal_node(Script::Value::String.new(Lexer::OPERATORS_REVERSE[op.type]),
                            op.source_range)
+
+        deprecation =
+          case op.type
+          when :comma; :potential
+          when :div, :single_eq; :none
+          when :plus; unary ? :none : :immediate
+          when :minus; @lexer.whitespace?(@lexer.peek) ? :immediate : :none
+          else; :immediate
+          end
+
         interp = node(
-          Script::Tree::Interpolation.new(prev, str, nil, wb, !:wa, :originally_text),
+          Script::Tree::Interpolation.new(
+            prev, str, nil, wb, false, :originally_text => true, :deprecation => deprecation),
           (prev || str).source_range.start_pos)
         interpolation(interp)
       end
@@ -329,15 +408,25 @@ RUBY
         return unless @lexer.after_interpolation?
         op = try_toks(*ops)
         return unless op
-        interp = try_op_before_interp(op, prev)
+        interp = try_op_before_interp(op, prev, :after_interp)
         return interp if interp
 
         wa = @lexer.whitespace?
         str = literal_node(Script::Value::String.new(Lexer::OPERATORS_REVERSE[op.type]),
                            op.source_range)
         str.line = @lexer.line
+
+        deprecation =
+          case op.type
+          when :comma; :potential
+          when :div, :single_eq; :none
+          when :minus; @lexer.whitespace?(op) ? :immediate : :none
+          else; :immediate
+          end
         interp = node(
-          Script::Tree::Interpolation.new(prev, str, assert_expr(name), !:wb, wa, :originally_text),
+          Script::Tree::Interpolation.new(
+            prev, str, assert_expr(name), false, wa,
+            :originally_text => true, :deprecation => deprecation),
           (prev || str).source_range.start_pos)
         interp
       end
@@ -346,16 +435,60 @@ RUBY
         e = first
         while (interp = try_tok(:begin_interpolation))
           wb = @lexer.whitespace?(interp)
-          mid = assert_expr :expr
+          char_before = @lexer.char(interp.pos - 1)
+          mid = without_css_variable_warning {assert_expr :expr}
           assert_tok :end_interpolation
           wa = @lexer.whitespace?
+          char_after = @lexer.char
+
+          after = space
+          before_deprecation = e.is_a?(Script::Tree::Interpolation) ? e.deprecation : :none
+          after_deprecation = after.is_a?(Script::Tree::Interpolation) ? after.deprecation : :none
+
+          deprecation =
+            if before_deprecation == :immediate || after_deprecation == :immediate ||
+               # Warn for #{foo}$var and #{foo}(1) but not #{$foo}1.
+               (after && !wa && char_after =~ /[$(]/) ||
+               # Warn for $var#{foo} and (a)#{foo} but not a#{foo}.
+               (e && !wb && is_unsafe_before?(e, char_before))
+              :immediate
+            else
+              :potential
+            end
+
           e = node(
-            Script::Tree::Interpolation.new(e, mid, space, wb, wa),
-            (e || mid).source_range.start_pos)
+            Script::Tree::Interpolation.new(e, mid, after, wb, wa, :deprecation => deprecation),
+            (e || interp).source_range.start_pos)
         end
         e
       end
 
+      # Returns whether `expr` is unsafe to include before an interpolation.
+      #
+      # @param expr [Node] The expression to check.
+      # @param char_before [String] The character immediately before the
+      #   interpolation being checked (and presumably the last character of
+      #   `expr`).
+      # @return [Boolean]
+      def is_unsafe_before?(expr, char_before)
+        return char_before == ')' if is_safe_value?(expr)
+
+        # Otherwise, it's only safe if it was another interpolation.
+        !expr.is_a?(Script::Tree::Interpolation)
+      end
+
+      # Returns whether `expr` is safe as the value immediately before an
+      # interpolation.
+      #
+      # It's safe as long as the previous expression is an identifier or number,
+      # or a list whose last element is also safe.
+      def is_safe_value?(expr)
+        return is_safe_value?(expr.elements.last) if expr.is_a?(Script::Tree::ListLiteral)
+        return false unless expr.is_a?(Script::Tree::Literal)
+        expr.value.is_a?(Script::Value::Number) ||
+          (expr.value.is_a?(Script::Value::String) && expr.value.type == :identifier)
+      end
+
       def space
         start_pos = source_position
         e = or_expr
@@ -497,30 +630,33 @@ RUBY
         first = try_tok(:special_fun)
         return paren unless first
         str = literal_node(first.value, first.source_range)
-        return str unless try_tok(:begin_interpolation)
-        mid = parse_interpolated
+        return str unless try_tok(:string_interpolation)
+        mid = without_css_variable_warning {assert_expr :expr}
+        assert_tok :end_interpolation
         last = assert_expr(:special_fun)
-        node(Tree::Interpolation.new(str, mid, last, false, false),
-            first.source_range.start_pos)
+        node(
+          Tree::Interpolation.new(str, mid, last, false, false),
+          first.source_range.start_pos)
       end
 
       def paren
         return variable unless try_tok(:lparen)
-        was_in_parens = @in_parens
-        @in_parens = true
         start_pos = source_position
         e = map
+        e.force_division! if e
         end_pos = source_position
         assert_tok(:rparen)
-        return e || node(Sass::Script::Tree::ListLiteral.new([], nil), start_pos, end_pos)
-      ensure
-        @in_parens = was_in_parens
+
+        @css_variable_warning.warn! if @css_variable_warning
+        e || node(Sass::Script::Tree::ListLiteral.new([], nil), start_pos, end_pos)
       end
 
       def variable
         start_pos = source_position
         c = try_tok(:const)
         return string unless c
+
+        @css_variable_warning.warn! if @css_variable_warning
         node(Tree::Variable.new(*c.value), start_pos)
       end
 
@@ -528,8 +664,8 @@ RUBY
         first = try_tok(:string)
         return number unless first
         str = literal_node(first.value, first.source_range)
-        return str unless try_tok(:begin_interpolation)
-        mid = assert_expr :expr
+        return str unless try_tok(:string_interpolation)
+        mid = without_css_variable_warning {assert_expr :expr}
         assert_tok :end_interpolation
         last = assert_expr(:string)
         node(Tree::StringInterpolation.new(str, mid, last), first.source_range.start_pos)
@@ -539,13 +675,15 @@ RUBY
         tok = try_tok(:number)
         return selector unless tok
         num = tok.value
-        num.original = num.to_s unless @in_parens
+        num.options = @options
+        num.original = num.to_s
         literal_node(num, tok.source_range.start_pos)
       end
 
       def selector
         tok = try_tok(:selector)
         return literal unless tok
+        @css_variable_warning.warn! if @css_variable_warning
         node(tok.value, tok.source_range.start_pos)
       end
 
@@ -597,8 +735,14 @@ RUBY
       end
 
       def assert_done
-        return if @lexer.done?
-        @lexer.expected!(EXPR_NAMES[:default])
+        if @allow_extra_text
+          # If extra text is allowed, just rewind the lexer so that the
+          # StringScanner is pointing to the end of the parsed text.
+          @lexer.unpeek!
+        else
+          return if @lexer.done?
+          @lexer.expected!(EXPR_NAMES[:default])
+        end
       end
 
       # @overload node(value, source_range)
@@ -627,11 +771,62 @@ RUBY
             range(source_range_or_start_pos, end_pos)
           end
 
+        node.css_variable_warning = @css_variable_warning
         node.line = source_range.start_pos.line
         node.source_range = source_range
         node.filename = @options[:filename]
         node
       end
+
+      # Runs the given block without CSS variable warnings enabled.
+      #
+      # CSS warnings don't apply within interpolation, so this is used to
+      # disable them.
+      #
+      # @yield []
+      def without_css_variable_warning
+        old_css_variable_warning = @css_variable_warning
+        @css_variable_warning = nil
+        yield
+      ensure
+        @css_variable_warning = old_css_variable_warning
+      end
+
+      # Checks a script node for any immediately-deprecated interpolations, and
+      # emits warnings for them.
+      #
+      # @param node [Sass::Script::Tree::Node]
+      def check_for_interpolation(node)
+        nodes = [node]
+        until nodes.empty?
+          node = nodes.pop
+          unless node.is_a?(Sass::Script::Tree::Interpolation) &&
+                 node.deprecation == :immediate
+            nodes.concat node.children
+            next
+          end
+
+          interpolation_deprecation(node)
+        end
+      end
+
+      # Emits a deprecation warning for an interpolation node.
+      #
+      # @param node [Sass::Script::Tree::Node]
+      def interpolation_deprecation(interpolation)
+        return if @options[:_convert]
+        location = "on line #{interpolation.line}"
+        location << " of #{interpolation.filename}" if interpolation.filename
+        Sass::Util.sass_warn <<WARNING
+DEPRECATION WARNING #{location}:
+\#{} interpolation near operators will be simplified in a future version of Sass.
+To preserve the current behavior, use quotes:
+
+  #{interpolation.to_quoted_equivalent.to_sass}
+
+You can use the sass-convert command to automatically fix most cases.
+WARNING
+      end
     end
   end
 end