sass 3.4.25 → 3.5.0

data/lib/sass/script/parser.rb

@@ -1,5 +1,4 @@
 require 'sass/script/lexer'
-require 'sass/script/css_variable_warning'
 
 module Sass
   module Script
@@ -35,7 +34,6 @@ module Sass
         @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 (`#{}`).
@@ -64,23 +62,13 @@ 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(css_variable = false)
-        if css_variable
-          @css_variable_warning = CssVariableWarning.new
-        end
-
+      def parse
         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]
@@ -127,7 +115,7 @@ module Sass
           a.options = @options
         end
 
-        keywords.each do |_k, v|
+        keywords.each do |_, v|
           check_for_interpolation v
           v.options = @options
         end
@@ -232,12 +220,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(value, line, offset, options = {})
-        css_variable = options.delete :css_variable
-        new(value, line, offset, options).parse(css_variable)
+      def self.parse(*args)
+        new(*args).parse
       end
 
       PRECEDENCE = [
@@ -250,8 +238,6 @@ 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.
@@ -291,10 +277,6 @@ 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
@@ -310,8 +292,6 @@ 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
@@ -338,7 +318,6 @@ 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
@@ -364,7 +343,7 @@ RUBY
       def list(first, start_pos)
         return first unless @lexer.peek && @lexer.peek.type == :comma
 
-        list = node(Sass::Script::Tree::ListLiteral.new([first], :comma), start_pos)
+        list = node(Sass::Script::Tree::ListLiteral.new([first], separator: :comma), start_pos)
         while (tok = try_tok(:comma))
           element_before_interp = list.elements.length == 1 ? list.elements.first : list
           if (interp = try_op_before_interp(tok, element_before_interp))
@@ -401,7 +380,7 @@ RUBY
           Script::Tree::Interpolation.new(
             prev, str, nil, wb, false, :originally_text => true, :deprecation => deprecation),
           (prev || str).source_range.start_pos)
-        interpolation(interp)
+        interpolation(first: interp)
       end
 
       def try_ops_after_interp(ops, name, prev = nil)
@@ -431,17 +410,17 @@ RUBY
         interp
       end
 
-      def interpolation(first = space)
-        e = first
+      def interpolation(first: nil, inner: :space)
+        e = first || send(inner)
         while (interp = try_tok(:begin_interpolation))
           wb = @lexer.whitespace?(interp)
           char_before = @lexer.char(interp.pos - 1)
-          mid = without_css_variable_warning {assert_expr :expr}
+          mid = assert_expr :expr
           assert_tok :end_interpolation
           wa = @lexer.whitespace?
           char_after = @lexer.char
 
-          after = space
+          after = send(inner)
           before_deprecation = e.is_a?(Script::Tree::Interpolation) ? e.deprecation : :none
           after_deprecation = after.is_a?(Script::Tree::Interpolation) ? after.deprecation : :none
 
@@ -500,7 +479,7 @@ RUBY
         if arr.size == 1
           arr.first
         else
-          node(Sass::Script::Tree::ListLiteral.new(arr, :space), start_pos)
+          node(Sass::Script::Tree::ListLiteral.new(arr, separator: :space), start_pos)
         end
       end
 
@@ -549,12 +528,12 @@ RUBY
         else
           return [], nil unless try_tok(:lparen)
         end
-        return [], nil if try_tok(:rparen)
 
         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)
@@ -585,12 +564,8 @@ RUBY
       def arglist(subexpr, description)
         args = []
         keywords = Sass::Util::NormalizedMap.new
-        e = send(subexpr)
-
-        return [args, keywords] unless e
-
         splat = nil
-        loop do
+        while (e = send(subexpr))
           if @lexer.peek && @lexer.peek.type == :colon
             name = e
             @lexer.expected!("comma") unless name.is_a?(Tree::Variable)
@@ -611,13 +586,12 @@ RUBY
             elsif !keywords.empty?
               raise SyntaxError.new("Positional arguments must come before keyword arguments.")
             end
-
             args << e if e
           end
 
           return args, keywords, splat unless try_tok(:comma)
-          e = assert_expr(subexpr, description)
         end
+        return args, keywords
       end
 
       def raw
@@ -628,10 +602,10 @@ RUBY
 
       def special_fun
         first = try_tok(:special_fun)
-        return paren unless first
+        return square_list 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}
+        mid = assert_expr :expr
         assert_tok :end_interpolation
         last = assert_expr(:special_fun)
         node(
@@ -639,6 +613,50 @@ RUBY
           first.source_range.start_pos)
       end
 
+      def square_list
+        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
+            elements = [e]
+
+            while (e = space)
+              elements << e
+              break unless try_tok(:comma)
+            end
+            separator = :comma
+          else
+            separator = :space if elements.length > 1
+          end
+        else
+          elements = []
+        end
+
+        assert_tok(:rsquare)
+        end_pos = source_position
+
+        node(Sass::Script::Tree::ListLiteral.new(elements, separator: separator, bracketed: true),
+             start_pos, end_pos)
+      end
+
       def paren
         return variable unless try_tok(:lparen)
         start_pos = source_position
@@ -646,17 +664,13 @@ RUBY
         e.force_division! if e
         end_pos = source_position
         assert_tok(:rparen)
-
-        @css_variable_warning.warn! if @css_variable_warning
-        e || node(Sass::Script::Tree::ListLiteral.new([], nil), start_pos, end_pos)
+        e || node(Sass::Script::Tree::ListLiteral.new([]), 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
 
@@ -665,7 +679,7 @@ RUBY
         return number 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}
+        mid = assert_expr :expr
         assert_tok :end_interpolation
         last = assert_expr(:string)
         node(Tree::StringInterpolation.new(str, mid, last), first.source_range.start_pos)
@@ -683,7 +697,6 @@ RUBY
       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
 
@@ -723,10 +736,14 @@ RUBY
         @lexer.expected!(names.map {|tok| Lexer::TOKEN_NAMES[tok] || tok}.join(" or "))
       end
 
-      def try_tok(name)
+      def peek_tok(name)
         # Avoids an array allocation caused by argument globbing in the try_toks method.
         peeked = @lexer.peek
-        peeked && name == peeked.type && @lexer.next
+        peeked && name == peeked.type
+      end
+
+      def try_tok(name)
+        peek_tok(name) && @lexer.next
       end
 
       def try_toks(*names)
@@ -771,27 +788,12 @@ 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.
       #

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

@@ -13,6 +13,11 @@ module Sass::Script::Tree
     # @return [String]
     attr_reader :name
 
+    # The callable to be invoked
+    #
+    # @return [Sass::Callable] or nil if no callable is provided.
+    attr_reader :callable
+
     # The arguments to the function.
     #
     # @return [Array<Node>]
@@ -39,13 +44,19 @@ module Sass::Script::Tree
     # @return [Node?]
     attr_accessor :kwarg_splat
 
-    # @param name [String] See \{#name}
+    # @param name_or_callable [String, Sass::Callable] See \{#name}
     # @param args [Array<Node>] See \{#args}
     # @param keywords [Sass::Util::NormalizedMap<Node>] See \{#keywords}
     # @param splat [Node] See \{#splat}
     # @param kwarg_splat [Node] See \{#kwarg_splat}
-    def initialize(name, args, keywords, splat, kwarg_splat)
-      @name = name
+    def initialize(name_or_callable, args, keywords, splat, kwarg_splat)
+      if name_or_callable.is_a?(Sass::Callable)
+        @callable = name_or_callable
+        @name = name_or_callable.name
+      else
+        @callable = nil
+        @name = name_or_callable
+      end
       @args = args
       @keywords = keywords
       @splat = splat
@@ -56,8 +67,7 @@ module Sass::Script::Tree
     # @return [String] A string representation of the function call
     def inspect
       args = @args.map {|a| a.inspect}.join(', ')
-      keywords = Sass::Util.hash_to_a(@keywords.as_stored).
-          map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
+      keywords = @keywords.as_stored.to_a.map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
       # rubocop:disable RedundantSelf
       if self.splat
         splat = args.empty? && keywords.empty? ? "" : ", "
@@ -77,8 +87,7 @@ module Sass::Script::Tree
       end
 
       args = @args.map(&arg_to_sass)
-      keywords = Sass::Util.hash_to_a(@keywords.as_stored).
-        map {|k, v| "$#{dasherize(k, opts)}: #{arg_to_sass[v]}"}
+      keywords = @keywords.as_stored.to_a.map {|k, v| "$#{dasherize(k, opts)}: #{arg_to_sass[v]}"}
 
       # rubocop:disable RedundantSelf
       if self.splat
@@ -120,27 +129,31 @@ module Sass::Script::Tree
     # @return [Sass::Script::Value] The SassScript object that is the value of the function call
     # @raise [Sass::SyntaxError] if the function call raises an ArgumentError
     def _perform(environment)
-      args = Sass::Util.enum_with_index(@args).
+      args = @args.each_with_index.
         map {|a, i| perform_arg(a, environment, signature && signature.args[i])}
       keywords = Sass::Util.map_hash(@keywords) do |k, v|
         [k, perform_arg(v, environment, k.tr('-', '_'))]
       end
       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))
+
+      fn = @callable || environment.function(@name)
+
+      if fn && fn.origin == :stylesheet
+        environment.stack.with_function(filename, line, name) do
+          return without_original(perform_sass_fn(fn, args, splat, environment))
+        end
       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
-
+      if Sass::Script::Functions.callable?(ruby_name) && (!fn || fn.origin == :builtin)
         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(
-          local_environment).send(ruby_name, *args))
+        result = local_environment.stack.with_function(filename, line, name) do
+          opts(Sass::Script::Functions::EvaluationContext.new(
+            local_environment).send(ruby_name, *args))
+        end
         without_original(result)
       else
         opts(to_literal(args))
@@ -206,6 +219,7 @@ module Sass::Script::Tree
         raise Sass::SyntaxError.new(
           "#{args[signature.args.size].inspect} is not a keyword argument for `#{name}'")
       elsif keywords.empty?
+        args << {} if signature.var_kwargs
         return args
       end
 
@@ -271,30 +285,21 @@ module Sass::Script::Tree
           message = "wrong number of arguments (#{given} for #{expected})"
         end
       elsif Sass::Util.jruby?
-        if Sass::Util.jruby1_6?
-          should_maybe_raise = e.message =~ /^wrong number of arguments \((\d+) for (\d+)\)/ &&
-            # The one case where JRuby does include the Ruby name of the function
-            # is manually-thrown ArgumentErrors, which are indistinguishable from
-            # legitimate ArgumentErrors. We treat both of these as
-            # Sass::SyntaxErrors even though it can hide Ruby errors.
-            e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/
-        else
-          should_maybe_raise =
-            e.message =~ /^wrong number of arguments calling `[^`]+` \((\d+) for (\d+)\)/
-          given, expected = $1, $2
-        end
+        should_maybe_raise =
+          e.message =~ /^wrong number of arguments calling `[^`]+` \((\d+) for (\d+)\)/
+        given, expected = $1, $2
 
         if should_maybe_raise
           # JRuby 1.7 includes __send__ before send and _perform.
           trace = e.backtrace.dup
-          raise e if !Sass::Util.jruby1_6? && trace.shift !~ /:in `__send__'$/
+          raise e if trace.shift !~ /:in `__send__'$/
 
           # JRuby (as of 1.7.2) doesn't put the actual method
           # for which the argument error was thrown in the backtrace, so we
           # detect whether our send threw an argument error.
           if !(trace[0] =~ /:in `send'$/ && trace[1] =~ /:in `_perform'$/)
             raise e
-          elsif !Sass::Util.jruby1_6?
+          else
             # JRuby 1.7 doesn't use standard formatting for its ArgumentErrors.
             message = "wrong number of arguments (#{given} for #{expected})"
           end

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

@@ -13,13 +13,20 @@ module Sass::Script::Tree
     # @return [Symbol]
     attr_reader :separator
 
+    # Whether the list is surrounded by square brackets.
+    #
+    # @return [Boolean]
+    attr_reader :bracketed
+
     # Creates a new list literal.
     #
     # @param elements [Array<Node>] See \{#elements}
     # @param separator [Symbol] See \{#separator}
-    def initialize(elements, separator)
+    # @param bracketed [Boolean] See \{#bracketed}
+    def initialize(elements, separator: nil, bracketed: false)
       @elements = elements
       @separator = separator
+      @bracketed = bracketed
     end
 
     # @see Node#children
@@ -27,7 +34,7 @@ module Sass::Script::Tree
 
     # @see Value#to_sass
     def to_sass(opts = {})
-      return "()" if elements.empty?
+      return bracketed ? "[]" : "()" if elements.empty?
       members = elements.map do |v|
         if element_needs_parens?(v)
           "(#{v.to_sass(opts)})"
@@ -36,9 +43,12 @@ module Sass::Script::Tree
         end
       end
 
-      return "(#{members.first},)" if separator == :comma && members.length == 1
+      if separator == :comma && members.length == 1
+        return "#{bracketed ? '[' : '('}#{members.first},#{bracketed ? ']' : ')'}"
+      end
 
-      members.join(sep_str(nil))
+      contents = members.join(sep_str(nil))
+      bracketed ? "[#{contents}]" : contents
     end
 
     # @see Node#deep_copy
@@ -49,7 +59,9 @@ module Sass::Script::Tree
     end
 
     def inspect
-      "(#{elements.map {|e| e.inspect}.join(separator == :space ? ' ' : ', ')})"
+      (bracketed ? '[' : '(') +
+        elements.map {|e| e.inspect}.join(separator == :space ? ' ' : ', ') +
+        (bracketed ? ']' : ')')
     end
 
     def force_division!
@@ -61,7 +73,8 @@ module Sass::Script::Tree
     def _perform(environment)
       list = Sass::Script::Value::List.new(
         elements.map {|e| e.perform(environment)},
-        separator)
+        separator: separator,
+        bracketed: bracketed)
       list.source_range = source_range
       list.options = options
       list
@@ -73,8 +86,10 @@ module Sass::Script::Tree
     # when serialized to Sass.
     def element_needs_parens?(element)
       if element.is_a?(ListLiteral)
-        return Sass::Script::Parser.precedence_of(element.separator) <=
-               Sass::Script::Parser.precedence_of(separator)
+        return false if element.elements.length < 2
+        return false if element.bracketed
+        return Sass::Script::Parser.precedence_of(element.separator || :space) <=
+               Sass::Script::Parser.precedence_of(separator || :space)
       end
 
       return false unless separator == :space

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

@@ -49,14 +49,14 @@ module Sass::Script::Tree
     # @see Node#_perform
     def _perform(environment)
       keys = Set.new
-      map = Sass::Script::Value::Map.new(Sass::Util.to_hash(pairs.map do |(k, v)|
+      map = Sass::Script::Value::Map.new(Hash[pairs.map do |(k, v)|
         k, v = k.perform(environment), v.perform(environment)
         if keys.include?(k)
           raise Sass::SyntaxError.new("Duplicate key #{k.inspect} in map #{to_sass}.")
         end
         keys << k
         [k, v]
-      end))
+      end])
       map.options = options
       map
     end

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

@@ -23,14 +23,6 @@ module Sass::Script::Tree
     # @return [String]
     attr_accessor :filename
 
-    # The warning that this node should emit if it executes in a way that's not
-    # safe for a CSS variable value.
-    #
-    # This is `nil` if this is not in a CSS variable value.
-    #
-    # @return [Sass::Script::CssVariableWarning]
-    attr_accessor :css_variable_warning
-
     # Sets the options hash for this node,
     # as well as for all child nodes.
     # See {file:SASS_REFERENCE.md#Options the Sass options documentation}.

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

@@ -81,13 +81,6 @@ module Sass::Script::Tree
           "Invalid null operation: \"#{value1.inspect} #{@operator} #{value2.inspect}\".")
       end
 
-      if css_variable_warning && @operator == :div &&
-         !(value1.is_a?(Sass::Script::Value::Number) && value1.original &&
-           value2.is_a?(Sass::Script::Value::Number) && value2.original) &&
-         !(value1.is_a?(Sass::Script::Value::String) && value2.is_a?(Sass::Script::Value::String))
-        css_variable_warning.warn!
-      end
-
       begin
         result = opts(value1.send(@operator, value2))
       rescue NoMethodError => e

data/lib/sass/script/value/arg_list.rb

@@ -17,7 +17,7 @@ module Sass::Script::Value
     # @param keywords [Hash<String, Value>, NormalizedMap<Value>] See \{#keywords}
     # @param separator [String] See \{List#separator}.
     def initialize(value, keywords, separator)
-      super(value, separator)
+      super(value, separator: separator)
       if keywords.is_a?(Sass::Util::NormalizedMap)
         @keywords = keywords
       else

data/lib/sass/script/value/base.rb

@@ -192,6 +192,12 @@ MSG
     # @return [Symbol]
     def separator; nil; end
 
+    # Whether the value is surrounded by square brackets. For non-list values,
+    # this will be `false`.
+    #
+    # @return [Boolean]
+    def bracketed; false; end
+
     # Returns the value of this value as a list.
     # Single values are considered the same as single-element lists.
     #
@@ -228,6 +234,17 @@ MSG
       false
     end
 
+    # Creates a new list containing `contents` but with the same brackets and
+    # separators as this object, when interpreted as a list.
+    #
+    # @param contents [Array<Value>] The contents of the new list.
+    # @param separator [Symbol] The separator of the new list. Defaults to \{#separator}.
+    # @param bracketed [Boolean] Whether the new list is bracketed. Defaults to \{#bracketed}.
+    # @return [Sass::Script::Value::List]
+    def with_contents(contents, separator: self.separator, bracketed: self.bracketed)
+      Sass::Script::Value::List.new(contents, separator: separator, bracketed: bracketed)
+    end
+
     protected
 
     # Evaluates the value.

data/lib/sass/script/value/callable.rb

@@ -0,0 +1,25 @@
+module Sass::Script::Value
+  # A SassScript object representing a null value.
+  class Callable < Base
+    # Constructs a Callable value for use in SassScript.
+    #
+    # @param callable [Sass::Callable] The callable to be used when the
+    # callable is called.
+    def initialize(callable)
+      super(callable)
+    end
+
+    def to_s(opts = {})
+      raise Sass::SyntaxError.new("#{to_sass} isn't a valid CSS value.")
+    end
+
+    def inspect
+      to_sass
+    end
+
+    # @abstract
+    def to_sass
+      Sass::Util.abstract(self)
+    end
+  end
+end

data/lib/sass/script/value/color.rb

@@ -563,6 +563,11 @@ module Sass::Script::Value
     def to_s(opts = {})
       return smallest if options[:style] == :compressed
       return representation if representation
+
+      # IE10 doesn't properly support the color name "transparent", so we emit
+      # generated transparent colors as rgba(0, 0, 0, 0) in favor of that. See
+      # #1782.
+      return rgba_str if Number.basically_equal?(alpha, 0)
       return name if name
       alpha? ? rgba_str : hex_str
     end