sass 3.4.25 → 3.7.4

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,15 +67,12 @@ 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(', ')
-      # rubocop:disable RedundantSelf
+      keywords = @keywords.as_stored.to_a.map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
       if self.splat
         splat = args.empty? && keywords.empty? ? "" : ", "
         splat = "#{splat}#{self.splat.inspect}..."
         splat = "#{splat}, #{kwarg_splat.inspect}..." if kwarg_splat
       end
-      # rubocop:enable RedundantSelf
       "#{name}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
     end
 
@@ -77,15 +85,12 @@ 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
         splat = "#{arg_to_sass[self.splat]}..."
         kwarg_splat = "#{arg_to_sass[self.kwarg_splat]}..." if self.kwarg_splat
       end
-      # rubocop:enable RedundantSelf
 
       arglist = [args, splat, keywords, kwarg_splat].flatten.compact.join(', ')
       "#{dasherize(name, opts)}(#{arglist})"
@@ -120,27 +125,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 +215,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 +281,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/interpolation.rb

@@ -47,10 +47,7 @@ module Sass::Script::Tree
     # @param wa [Boolean] See {Interpolation#whitespace_after}
     # @param originally_text [Boolean] See {Interpolation#originally_text}
     # @param warn_for_color [Boolean] See {Interpolation#warn_for_color}
-    # @comment
-    #   rubocop:disable ParameterLists
     def initialize(before, mid, after, wb, wa, opts = {})
-      # rubocop:enable ParameterLists
       @before = before
       @mid = mid
       @after = after

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
@@ -118,7 +111,7 @@ module Sass::Script::Tree
       @@color_arithmetic_deprecation.warn(filename, line, <<WARNING)
 The operation `#{value1} #{@operator} #{value2}` is deprecated and will be an error in future versions.
 Consider using Sass's color functions instead.
-http://sass-lang.com/documentation/Sass/Script/Functions.html#other_color_functions
+https://sass-lang.com/documentation/Sass/Script/Functions.html#other_color_functions
 WARNING
     end
 

data/lib/sass/script/value.rb

@@ -9,3 +9,5 @@ require 'sass/script/value/null'
 require 'sass/script/value/list'
 require 'sass/script/value/arg_list'
 require 'sass/script/value/map'
+require 'sass/script/value/callable'
+require 'sass/script/value/function'

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

@@ -277,13 +277,14 @@ module Sass::Script::Value
     #
     # @return [Color]
     def self.from_hex(hex_string, alpha = nil)
-      unless hex_string =~ /^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i ||
-             hex_string =~ /^#?([0-9a-f])([0-9a-f])([0-9a-f])$/i
+      unless hex_string =~ /^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})?$/i ||
+             hex_string =~ /^#?([0-9a-f])([0-9a-f])([0-9a-f])([0-9a-f])?$/i
         raise ArgumentError.new("#{hex_string.inspect} is not a valid hex color.")
       end
       red   = $1.ljust(2, $1).to_i(16)
       green = $2.ljust(2, $2).to_i(16)
       blue  = $3.ljust(2, $3).to_i(16)
+      alpha = $4.ljust(2, $4).to_i(16).to_f / 0xff if $4
 
       hex_string = "##{hex_string}" unless hex_string[0] == ?#
       attrs = {:red => red, :green => green, :blue => blue, :representation => hex_string}
@@ -563,6 +564,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

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

@@ -0,0 +1,19 @@
+module Sass::Script::Value
+  # A SassScript object representing a function.
+  class Function < Callable
+    # Constructs a Function value for use in SassScript.
+    #
+    # @param function [Sass::Callable] The callable to be used when the
+    # function is invoked.
+    def initialize(function)
+      unless function.type == "function"
+        raise ArgumentError.new("A callable of type function was expected.")
+      end
+      super
+    end
+
+    def to_sass
+      %{get-function("#{value.name}")}
+    end
+  end
+end

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

@@ -1,8 +1,6 @@
 module Sass::Script::Value
   # Provides helper functions for creating sass values from within ruby methods.
   # @since `3.3.0`
-  # @comment
-  #   rubocop:disable ModuleLength
   module Helpers
     # Construct a Sass Boolean.
     #
@@ -68,26 +66,35 @@ module Sass::Script::Value
       Number.new(number, *parse_unit_string(unit_string))
     end
 
-    # @overload list(*elements, separator)
+    # @overload list(*elements, separator:, bracketed: false)
     #   Create a space-separated list from the arguments given.
     #   @param elements [Array<Sass::Script::Value::Base>] Each argument will be a list element.
     #   @param separator [Symbol] Either :space or :comma.
+    #   @param bracketed [Boolean] Whether the list uses square brackets.
     #   @return [Sass::Script::Value::List] The space separated list.
     #
-    # @overload list(array, separator)
+    # @overload list(array, separator:, bracketed: false)
     #   Create a space-separated list from the array given.
     #   @param array [Array<Sass::Script::Value::Base>] A ruby array of Sass values
     #     to make into a list.
+    #   @param separator [Symbol] Either :space or :comma.
+    #   @param bracketed [Boolean] Whether the list uses square brackets.
     #   @return [Sass::Script::Value::List] The space separated list.
-    def list(*elements)
-      unless elements.last.is_a?(Symbol)
-        raise ArgumentError.new("A list type of :space or :comma must be specified.")
+    def list(*elements, separator: nil, bracketed: false)
+      # Support passing separator as the last value in elements for
+      # backwards-compatibility.
+      if separator.nil?
+        if elements.last.is_a?(Symbol)
+          separator = elements.pop
+        else
+          raise ArgumentError.new("A separator of :space or :comma must be specified.")
+        end
       end
-      separator = elements.pop
+
       if elements.size == 1 && elements.first.is_a?(Array)
         elements = elements.first
       end
-      Sass::Script::Value::List.new(elements, separator)
+      Sass::Script::Value::List.new(elements, separator: separator, bracketed: bracketed)
     end
 
     # Construct a Sass map.
@@ -196,14 +203,33 @@ module Sass::Script::Value
       raise ArgumentError.new(err)
     end
 
-    # Returns true when the literal is a string containing a calc()
+    # Returns true when the literal is a string containing a calc().
+    #
+    # Use \{#special_number?} in preference to this.
     #
     # @param literal [Sass::Script::Value::Base] The value to check
-    # @return boolean
+    # @return Boolean
     def calc?(literal)
       literal.is_a?(Sass::Script::Value::String) && literal.value =~ /calc\(/
     end
 
+    # Returns true when the literal is a string containing a var().
+    #
+    # @param literal [Sass::Script::Value::Base] The value to check
+    # @return Boolean
+    def var?(literal)
+      literal.is_a?(Sass::Script::Value::String) && literal.value =~ /var\(/
+    end
+
+    # Returns whether the literal is a special CSS value that may evaluate to a
+    # number, such as `calc()` or `var()`.
+    #
+    # @param literal [Sass::Script::Value::Base] The value to check
+    # @return Boolean
+    def special_number?(literal)
+      literal.is_a?(Sass::Script::Value::String) && literal.value =~ /(calc|var)\(/
+    end
+
     private
 
     # Converts a user-provided selector into string form or throws an