sass 3.3.0 → 3.4.25

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 (`#{}`).
@@ -36,13 +43,20 @@ module Sass
       # which signals the end of an interpolated segment,
       # it returns rather than throwing an error.
       #
+      # @param warn_for_color [Boolean] Whether raw color values passed to
+      #   interoplation should cause a warning.
       # @return [Script::Tree::Node] The root node of the parse tree
       # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
-      def parse_interpolated
+      def parse_interpolated(warn_for_color = false)
+        # Start two characters back to compensate for #{
+        start_pos = Sass::Source::Position.new(line, offset - 2)
         expr = assert_expr :expr
         assert_tok :end_interpolation
+        expr = Sass::Script::Tree::Interpolation.new(
+          nil, expr, nil, false, false, :warn_for_color => warn_for_color)
+        check_for_interpolation expr
         expr.options = @options
-        expr
+        node(expr, start_pos)
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
         raise e
@@ -50,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]
@@ -73,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]
@@ -96,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]
@@ -116,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]
@@ -136,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]
@@ -159,6 +221,7 @@ module Sass
         end
 
         expr = assert_expr :funcall
+        check_for_interpolation expr
         expr.options = @options
         @lexer.unpeek!
         expr
@@ -169,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 = [
@@ -187,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.
@@ -226,8 +291,12 @@ module Sass
                   return other_interp
                 end
 
-                start_pos = source_position
-                e = node(Tree::Operation.new(e, assert_expr(#{sub.inspect}), tok.type), start_pos)
+                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
               e
             end
@@ -241,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
@@ -267,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
@@ -302,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
@@ -323,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
@@ -340,15 +435,60 @@ RUBY
         e = first
         while (interp = try_tok(:begin_interpolation))
           wb = @lexer.whitespace?(interp)
-          mid = parse_interpolated
+          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
@@ -382,7 +522,7 @@ RUBY
 
         name = @lexer.next
         if (color = Sass::Script::Value::Color::COLOR_NAMES[name.value.downcase])
-          literal_node(Sass::Script::Value::Color.new(color), name.source_range)
+          literal_node(Sass::Script::Value::Color.new(color, name.value), name.source_range)
         elsif name.value == "true"
           literal_node(Sass::Script::Value::Bool.new(true), name.source_range)
         elsif name.value == "false"
@@ -487,41 +627,36 @@ RUBY
       end
 
       def special_fun
-        start_pos = source_position
-        tok = try_tok(:special_fun)
-        return paren unless tok
-        first = literal_node(Script::Value::String.new(tok.value.first),
-          start_pos, start_pos.after(tok.value.first))
-        Sass::Util.enum_slice(tok.value[1..-1], 2).inject(first) do |l, (i, r)|
-          end_pos = i.source_range.end_pos
-          end_pos = end_pos.after(r) if r
-          node(
-            Script::Tree::Interpolation.new(
-              l, i,
-              r && literal_node(Script::Value::String.new(r),
-                i.source_range.end_pos, end_pos),
-              false, false),
-            start_pos, end_pos)
-        end
+        first = try_tok(:special_fun)
+        return paren unless first
+        str = literal_node(first.value, first.source_range)
+        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)
       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
 
@@ -529,8 +664,9 @@ 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 = parse_interpolated
+        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)
       end
@@ -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
 
@@ -563,6 +701,7 @@ RUBY
         :mixin_arglist => "mixin argument",
         :fn_arglist => "function argument",
         :splat => "...",
+        :special_fun => '")"',
       }
 
       def assert_expr(name, expected = nil)
@@ -596,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)
@@ -626,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

data/lib/sass/script/tree/funcall.rb

@@ -1,5 +1,5 @@
 require 'sass/script/functions'
-require 'sass/util/normalized_map'
+require 'sass/util'
 
 module Sass::Script::Tree
   # A SassScript parse node representing a function call.
@@ -128,12 +128,15 @@ module Sass::Script::Tree
       splat = Sass::Tree::Visitors::Perform.perform_splat(
         @splat, keywords, @kwarg_splat, environment)
       if (fn = environment.function(@name))
+        css_variable_warning.warn! if css_variable_warning
         return without_original(perform_sass_fn(fn, args, splat, environment))
       end
 
       args = construct_ruby_args(ruby_name, args, splat, environment)
 
       if Sass::Script::Functions.callable?(ruby_name)
+        css_variable_warning.warn! if css_variable_warning
+
         local_environment = Sass::Environment.new(environment.global_env, environment.options)
         local_environment.caller = Sass::ReadOnlyEnvironment.new(environment, environment.options)
         result = opts(Sass::Script::Functions::EvaluationContext.new(
@@ -208,13 +211,13 @@ module Sass::Script::Tree
 
       argnames = signature.args[args.size..-1] || []
       deprecated_argnames = (signature.deprecated && signature.deprecated[args.size..-1]) || []
-      args = args + argnames.zip(deprecated_argnames).map do |(argname, deprecated_argname)|
+      args += argnames.zip(deprecated_argnames).map do |(argname, deprecated_argname)|
         if keywords.has_key?(argname)
           keywords.delete(argname)
         elsif deprecated_argname && keywords.has_key?(deprecated_argname)
           deprecated_argname = keywords.denormalize(deprecated_argname)
           Sass::Util.sass_warn("DEPRECATION WARNING: The `$#{deprecated_argname}' argument for " +
-            "`#{name}()' has been renamed to `$#{argname}'.")
+            "`#{@name}()' has been renamed to `$#{argname}'.")
           keywords.delete(deprecated_argname)
         else
           raise Sass::SyntaxError.new("Function #{name} requires an argument named $#{argname}")
@@ -241,7 +244,7 @@ module Sass::Script::Tree
     end
 
     def perform_sass_fn(function, args, splat, environment)
-      Sass::Tree::Visitors::Perform.perform_arguments(function, args, splat) do |env|
+      Sass::Tree::Visitors::Perform.perform_arguments(function, args, splat, environment) do |env|
         env.caller = Sass::Environment.new(environment)
 
         val = catch :_sass_return do
@@ -296,8 +299,12 @@ module Sass::Script::Tree
             message = "wrong number of arguments (#{given} for #{expected})"
           end
         end
-      elsif e.message =~ /^wrong number of arguments \(\d+ for \d+\)/ &&
-          e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/
+      elsif (md = /^wrong number of arguments \(given (\d+), expected (\d+)\)/.match(e.message)) &&
+            e.backtrace[0] =~ /:in `#{ruby_name}'$/
+        # Handle ruby 2.3 error formatting
+        message = "wrong number of arguments (#{md[1]} for #{md[2]})"
+      elsif e.message =~ /^wrong number of arguments/ &&
+            e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/
         raise e
       end
       raise Sass::SyntaxError.new("#{message} for `#{name}'")