sass 3.7.4 → 4.0.0.alpha.1

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

@@ -13,11 +13,6 @@ 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>]
@@ -44,19 +39,13 @@ module Sass::Script::Tree
     # @return [Node?]
     attr_accessor :kwarg_splat
 
-    # @param name_or_callable [String, Sass::Callable] See \{#name}
+    # @param name [String] 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_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
+    def initialize(name, args, keywords, splat, kwarg_splat)
+      @name = name
       @args = args
       @keywords = keywords
       @splat = splat
@@ -67,12 +56,15 @@ module Sass::Script::Tree
     # @return [String] A string representation of the function call
     def inspect
       args = @args.map {|a| a.inspect}.join(', ')
-      keywords = @keywords.as_stored.to_a.map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
+      keywords = Sass::Util.hash_to_a(@keywords.as_stored).
+          map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
+      # rubocop:disable RedundantSelf
       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
 
@@ -85,12 +77,15 @@ module Sass::Script::Tree
       end
 
       args = @args.map(&arg_to_sass)
-      keywords = @keywords.as_stored.to_a.map {|k, v| "$#{dasherize(k, opts)}: #{arg_to_sass[v]}"}
+      keywords = Sass::Util.hash_to_a(@keywords.as_stored).
+        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})"
@@ -125,31 +120,24 @@ 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 = @args.each_with_index.
+      args = Sass::Util.enum_with_index(@args).
         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)
-
-      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
+      if (fn = environment.function(@name))
+        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) && (!fn || fn.origin == :builtin)
+      if Sass::Script::Functions.callable?(ruby_name)
         local_environment = Sass::Environment.new(environment.global_env, environment.options)
         local_environment.caller = Sass::ReadOnlyEnvironment.new(environment, environment.options)
-        result = local_environment.stack.with_function(filename, line, name) do
-          opts(Sass::Script::Functions::EvaluationContext.new(
-            local_environment).send(ruby_name, *args))
-        end
+        result = opts(Sass::Script::Functions::EvaluationContext.new(
+          local_environment).send(ruby_name, *args))
         without_original(result)
       else
         opts(to_literal(args))
@@ -215,13 +203,12 @@ 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
 
       argnames = signature.args[args.size..-1] || []
       deprecated_argnames = (signature.deprecated && signature.deprecated[args.size..-1]) || []
-      args += argnames.zip(deprecated_argnames).map do |(argname, deprecated_argname)|
+      args = 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)
@@ -281,31 +268,36 @@ module Sass::Script::Tree
           message = "wrong number of arguments (#{given} for #{expected})"
         end
       elsif Sass::Util.jruby?
-        should_maybe_raise =
-          e.message =~ /^wrong number of arguments calling `[^`]+` \((\d+) for (\d+)\)/
-        given, expected = $1, $2
+        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
 
         if should_maybe_raise
           # JRuby 1.7 includes __send__ before send and _perform.
           trace = e.backtrace.dup
-          raise e if trace.shift !~ /:in `__send__'$/
+          raise e if !Sass::Util.jruby1_6? && 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
-          else
+          elsif !Sass::Util.jruby1_6?
             # JRuby 1.7 doesn't use standard formatting for its ArgumentErrors.
             message = "wrong number of arguments (#{given} for #{expected})"
           end
         end
-      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}'$/
+      elsif e.message =~ /^wrong number of arguments \(\d+ for \d+\)/ &&
+          e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/
         raise e
       end
       raise Sass::SyntaxError.new("#{message} for `#{name}'")

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

@@ -1,220 +1,75 @@
 module Sass::Script::Tree
-  # A SassScript object representing `#{}` interpolation outside a string.
+  # A SassScript object representing a single `#{}` interpolation.
   #
-  # @see StringInterpolation
+  # This is used to wrap instances of interpolation in statement-level nodes. It
+  # includes logic for converting back to the source representation, and it
+  # optionally produces warnings when the values return named colors.
+  #
+  # TODO: Rather than representing this as a script node, it would be cleaner to
+  # have a non-node Interpolation class that represents an interpolated chunk of
+  # text.
   class Interpolation < Node
-    # @return [Node] The SassScript before the interpolation
-    attr_reader :before
-
-    # @return [Node] The SassScript within the interpolation
-    attr_reader :mid
-
-    # @return [Node] The SassScript after the interpolation
-    attr_reader :after
-
-    # @return [Boolean] Whether there was whitespace between `before` and `#{`
-    attr_reader :whitespace_before
-
-    # @return [Boolean] Whether there was whitespace between `}` and `after`
-    attr_reader :whitespace_after
-
-    # @return [Boolean] Whether the original format of the interpolation was
-    #   plain text, not an interpolation. This is used when converting back to
-    #   SassScript.
-    attr_reader :originally_text
+    # @return [Node] The SassScript within the
+    attr_reader :value
 
     # @return [Boolean] Whether a color value passed to the interpolation should
     #   generate a warning.
     attr_reader :warn_for_color
 
-    # The type of interpolation deprecation for this node.
-    #
-    # This can be `:none`, indicating that the node doesn't use deprecated
-    # interpolation; `:immediate`, indicating that a deprecation warning should
-    # be emitted as soon as possible; or `:potential`, indicating that a
-    # deprecation warning should be emitted if the resulting string is used in a
-    # way that would distinguish it from a list.
-    #
-    # @return [Symbol]
-    attr_reader :deprecation
-
-    # Interpolation in a property is of the form `before #{mid} after`.
-    #
-    # @param before [Node] See {Interpolation#before}
-    # @param mid [Node] See {Interpolation#mid}
-    # @param after [Node] See {Interpolation#after}
-    # @param wb [Boolean] See {Interpolation#whitespace_before}
-    # @param wa [Boolean] See {Interpolation#whitespace_after}
-    # @param originally_text [Boolean] See {Interpolation#originally_text}
+    # @param value [Node] See {Interpolation#value}
     # @param warn_for_color [Boolean] See {Interpolation#warn_for_color}
-    def initialize(before, mid, after, wb, wa, opts = {})
-      @before = before
-      @mid = mid
-      @after = after
-      @whitespace_before = wb
-      @whitespace_after = wa
-      @originally_text = opts[:originally_text] || false
-      @warn_for_color = opts[:warn_for_color] || false
-      @deprecation = opts[:deprecation] || :none
+    def initialize(value, warn_for_color = false)
+      @value = value
+      @warn_for_color = warn_for_color
     end
 
     # @return [String] A human-readable s-expression representation of the interpolation
     def inspect
-      "(interpolation #{@before.inspect} #{@mid.inspect} #{@after.inspect})"
+      "(interpolation #{@value.inspect})"
     end
 
     # @see Node#to_sass
     def to_sass(opts = {})
-      return to_quoted_equivalent.to_sass if deprecation == :immediate
-
-      res = ""
-      res << @before.to_sass(opts) if @before
-      res << ' ' if @before && @whitespace_before
-      res << '#{' unless @originally_text
-      res << @mid.to_sass(opts)
-      res << '}' unless @originally_text
-      res << ' ' if @after && @whitespace_after
-      res << @after.to_sass(opts) if @after
-      res
-    end
-
-    # Returns an `unquote()` expression that will evaluate to the same value as
-    # this interpolation.
-    #
-    # @return [Sass::Script::Tree::Node]
-    def to_quoted_equivalent
-      Funcall.new(
-        "unquote",
-        [to_string_interpolation(self)],
-        Sass::Util::NormalizedMap.new,
-        nil,
-        nil)
+      "\#{#{@value.to_sass(opts)}}"
     end
 
-    # Returns the three components of the interpolation, `before`, `mid`, and `after`.
+    # Returns the three interpolation's value.
     #
     # @return [Array<Node>]
     # @see #initialize
     # @see Node#children
     def children
-      [@before, @mid, @after].compact
+      [@value]
     end
 
     # @see Node#deep_copy
     def deep_copy
       node = dup
-      node.instance_variable_set('@before', @before.deep_copy) if @before
-      node.instance_variable_set('@mid', @mid.deep_copy)
-      node.instance_variable_set('@after', @after.deep_copy) if @after
+      node.instance_variable_set('@value', @value.deep_copy)
       node
     end
 
     protected
 
-    # Converts a script node into a corresponding string interpolation
-    # expression.
-    #
-    # @param node_or_interp [Sass::Script::Tree::Node]
-    # @return [Sass::Script::Tree::StringInterpolation]
-    def to_string_interpolation(node_or_interp)
-      unless node_or_interp.is_a?(Interpolation)
-        node = node_or_interp
-        return string_literal(node.value.to_s) if node.is_a?(Literal)
-        if node.is_a?(StringInterpolation)
-          return concat(string_literal(node.quote), concat(node, string_literal(node.quote)))
-        end
-        return StringInterpolation.new(string_literal(""), node, string_literal(""))
-      end
-
-      interp = node_or_interp
-      after_string_or_interp =
-        if interp.after
-          to_string_interpolation(interp.after)
-        else
-          string_literal("")
-        end
-      if interp.after && interp.whitespace_after
-        after_string_or_interp = concat(string_literal(' '), after_string_or_interp)
-      end
-
-      mid_string_or_interp = to_string_interpolation(interp.mid)
-
-      before_string_or_interp =
-        if interp.before
-          to_string_interpolation(interp.before)
-        else
-          string_literal("")
-        end
-      if interp.before && interp.whitespace_before
-        before_string_or_interp = concat(before_string_or_interp, string_literal(' '))
-      end
-
-      concat(before_string_or_interp, concat(mid_string_or_interp, after_string_or_interp))
-    end
-
-    private
-
     # Evaluates the interpolation.
     #
     # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
     # @return [Sass::Script::Value::String]
     #   The SassScript string that is the value of the interpolation
     def _perform(environment)
-      res = ""
-      res << @before.perform(environment).to_s if @before
-      res << " " if @before && @whitespace_before
-
-      val = @mid.perform(environment)
-      if @warn_for_color && val.is_a?(Sass::Script::Value::Color) && val.name
-        alternative = Operation.new(Sass::Script::Value::String.new("", :string), @mid, :plus)
+      result = @value.perform(environment)
+      if @warn_for_color && result.is_a?(Sass::Script::Value::Color) && result.name
+        alternative = Operation.new(Sass::Script::Value::String.new("", :string), @value, :plus)
         Sass::Util.sass_warn <<MESSAGE
 WARNING on line #{line}, column #{source_range.start_pos.offset}#{" of #{filename}" if filename}:
-You probably don't mean to use the color value `#{val}' in interpolation here.
-It may end up represented as #{val.inspect}, which will likely produce invalid CSS.
-Always quote color names when using them as strings (for example, "#{val}").
+You probably don't mean to use the color value `#{result}' in interpolation here.
+It may end up represented as #{result.inspect}, which will likely produce invalid CSS.
+Always quote color names when using them as strings (for example, "#{result}").
 If you really want to use the color value here, use `#{alternative.to_sass}'.
 MESSAGE
       end
 
-      res << val.to_s(:quote => :none)
-      res << " " if @after && @whitespace_after
-      res << @after.perform(environment).to_s if @after
-      str = Sass::Script::Value::String.new(
-        res, :identifier,
-        (to_quoted_equivalent.to_sass if deprecation == :potential))
-      str.source_range = source_range
-      opts(str)
-    end
-
-    # Concatenates two string literals or string interpolation expressions.
-    #
-    # @param string_or_interp1 [Sass::Script::Tree::Literal|Sass::Script::Tree::StringInterpolation]
-    # @param string_or_interp2 [Sass::Script::Tree::Literal|Sass::Script::Tree::StringInterpolation]
-    # @return [Sass::Script::Tree::StringInterpolation]
-    def concat(string_or_interp1, string_or_interp2)
-      if string_or_interp1.is_a?(Literal) && string_or_interp2.is_a?(Literal)
-        return string_literal(string_or_interp1.value.value + string_or_interp2.value.value)
-      end
-
-      if string_or_interp1.is_a?(Literal)
-        string = string_or_interp1
-        interp = string_or_interp2
-        before = string_literal(string.value.value + interp.before.value.value)
-        return StringInterpolation.new(before, interp.mid, interp.after)
-      end
-
-      StringInterpolation.new(
-        string_or_interp1.before,
-        string_or_interp1.mid,
-        concat(string_or_interp1.after, string_or_interp2))
-    end
-
-    # Returns a string literal with the given contents.
-    #
-    # @param string [String]
-    # @return string [Sass::Script::Tree::Literal]
-    def string_literal(string)
-      Literal.new(Sass::Script::Value::String.new(string, :string))
+      opts(Sass::Script::Value::String.new(result.to_s(:quote => :none)))
     end
   end
 end

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

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