sass 3.2.7 → 3.3.0.rc.1

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

@@ -0,0 +1,290 @@
+require 'sass/script/functions'
+require 'sass/util/normalized_map'
+
+module Sass::Script::Tree
+  # A SassScript parse node representing a function call.
+  #
+  # A function call either calls one of the functions in
+  # {Sass::Script::Functions}, or if no function with the given name exists it
+  # returns a string representation of the function call.
+  class Funcall < Node
+    # The name of the function.
+    #
+    # @return [String]
+    attr_reader :name
+
+    # The arguments to the function.
+    #
+    # @return [Array<Node>]
+    attr_reader :args
+
+    # The keyword arguments to the function.
+    #
+    # @return [{String => Node}]
+    attr_reader :keywords
+
+    # The first splat argument for this function, if one exists.
+    #
+    # This could be a list of positional arguments, a map of keyword
+    # arguments, or an arglist containing both.
+    #
+    # @return [Node?]
+    attr_accessor :splat
+
+    # The second splat argument for this function, if one exists.
+    #
+    # If this exists, it's always a map of keyword arguments, and
+    # \{#splat} is always either a list or an arglist.
+    #
+    # @return [Node?]
+    attr_accessor :kwarg_splat
+
+    # @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, args, keywords, splat, kwarg_splat)
+      @name = name
+      @args = args
+      @keywords = keywords
+      @splat = splat
+      @kwarg_splat = kwarg_splat
+      super()
+    end
+
+    # @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
+      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
+
+    # @see Node#to_sass
+    def to_sass(opts = {})
+      arg_to_sass = lambda do |arg|
+        sass = arg.to_sass(opts)
+        sass = "(#{sass})" if arg.is_a?(Sass::Script::Tree::ListLiteral) && arg.separator == :comma
+        sass
+      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]}"}
+
+      # 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})"
+    end
+
+    # Returns the arguments to the function.
+    #
+    # @return [Array<Node>]
+    # @see Node#children
+    def children
+      res = @args + @keywords.values
+      res << @splat if @splat
+      res << @kwarg_splat if @kwarg_splat
+      res
+    end
+
+    # @see Node#deep_copy
+    def deep_copy
+      node = dup
+      node.instance_variable_set('@args', args.map {|a| a.deep_copy})
+      copied_keywords = Sass::Util::NormalizedMap.new
+      @keywords.as_stored.each {|k, v| copied_keywords[k] = v.deep_copy}
+      node.instance_variable_set('@keywords', copied_keywords)
+      node
+    end
+
+    protected
+
+    # Evaluates the function call.
+    #
+    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+    # @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).
+        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))
+        return perform_sass_fn(fn, args, splat, environment)
+      end
+
+      args = construct_ruby_args(ruby_name, args, splat, environment)
+
+      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)
+        opts(Sass::Script::Functions::EvaluationContext.new(
+          local_environment).send(ruby_name, *args))
+      else
+        opts(to_literal(args))
+      end
+    rescue ArgumentError => e
+      reformat_argument_error(e)
+    end
+
+    # Compass historically overrode this before it changed name to {Funcall#to_value}.
+    # We should get rid of it in the future.
+    def to_literal(args)
+      to_value(args)
+    end
+
+    # This method is factored out from `_perform` so that compass can override
+    # it with a cross-browser implementation for functions that require vendor prefixes
+    # in the generated css.
+    def to_value(args)
+      Sass::Script::Value::String.new("#{name}(#{args.join(', ')})")
+    end
+
+    private
+
+    def ruby_name
+      @ruby_name ||= @name.tr('-', '_')
+    end
+
+    def perform_arg(argument, environment, name)
+      return argument if signature && signature.delayed_args.include?(name)
+      argument.perform(environment)
+    end
+
+    def signature
+      @signature ||= Sass::Script::Functions.signature(name.to_sym, @args.size, @keywords.size)
+    end
+
+    def construct_ruby_args(name, args, splat, environment)
+      args += splat.to_a if splat
+
+      # All keywords are contained in splat.keywords for consistency,
+      # even if there were no splats passed in.
+      old_keywords_accessed = splat.keywords_accessed
+      keywords = splat.keywords
+      splat.keywords_accessed = old_keywords_accessed
+
+      unless (signature = Sass::Script::Functions.signature(name.to_sym, args.size, keywords.size))
+        return args if keywords.empty?
+        raise Sass::SyntaxError.new("Function #{name} doesn't support keyword arguments")
+      end
+
+      # If the user passes more non-keyword args than the function expects,
+      # but it does expect keyword args, Ruby's arg handling won't raise an error.
+      # Since we don't want to make functions think about this,
+      # we'll handle it for them here.
+      if signature.var_kwargs && !signature.var_args && args.size > signature.args.size
+        raise Sass::SyntaxError.new(
+          "#{args[signature.args.size].inspect} is not a keyword argument for `#{name}'")
+      elsif keywords.empty?
+        return args
+      end
+
+      args = args + (signature.args[args.size..-1] || []).map do |argname|
+        if keywords.has_key?(argname)
+          keywords.delete(argname)
+        else
+          raise Sass::SyntaxError.new("Function #{name} requires an argument named $#{argname}")
+        end
+      end
+
+      if keywords.size > 0
+        if signature.var_kwargs
+          args << keywords
+        else
+          argname = keywords.keys.sort.first
+          if signature.args.include?(argname)
+            raise Sass::SyntaxError.new(
+              "Function #{name} was passed argument $#{argname} both by position and by name")
+          else
+            raise Sass::SyntaxError.new(
+              "Function #{name} doesn't have an argument named $#{argname}")
+          end
+        end
+      end
+
+      args
+    end
+
+    def perform_sass_fn(function, args, splat, environment)
+      Sass::Tree::Visitors::Perform.perform_arguments(function, args, splat) do |env|
+        env.caller = Sass::Environment.new(environment)
+
+        val = catch :_sass_return do
+          function.tree.each {|c| Sass::Tree::Visitors::Perform.visit(c, env)}
+          raise Sass::SyntaxError.new("Function #{@name} finished without @return")
+        end
+        val
+      end
+    end
+
+    def reformat_argument_error(e)
+      message = e.message
+
+      # If this is a legitimate Ruby-raised argument error, re-raise it.
+      # Otherwise, it's an error in the user's stylesheet, so wrap it.
+      if Sass::Util.rbx?
+        # Rubinius has a different error report string than vanilla Ruby. It
+        # also doesn't put the actual method for which the argument error was
+        # thrown in the backtrace, nor does it include `send`, so we look for
+        # `_perform`.
+        if e.message =~ /^method '([^']+)': given (\d+), expected (\d+)/
+          error_name, given, expected = $1, $2, $3
+          raise e if error_name != ruby_name || e.backtrace[0] !~ /:in `_perform'$/
+          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
+
+        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__'$/
+
+          # 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?
+            # JRuby 1.7 doesn't use standard formatting for its ArgumentErrors.
+            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}'$/
+        raise e
+      end
+      raise Sass::SyntaxError.new("#{message} for `#{name}'")
+    end
+  end
+end

data/lib/sass/script/{interpolation.rb → tree/interpolation.rb}

@@ -1,20 +1,40 @@
-module Sass::Script
+module Sass::Script::Tree
   # A SassScript object representing `#{}` interpolation outside a string.
   #
   # @see StringInterpolation
   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
+
     # Interpolation in a property is of the form `before #{mid} after`.
     #
-    # @param before [Node] The SassScript before the interpolation
-    # @param mid [Node] The SassScript within the interpolation
-    # @param after [Node] The SassScript after the interpolation
-    # @param wb [Boolean] Whether there was whitespace between `before` and `#{`
-    # @param wa [Boolean] Whether there was whitespace between `}` and `after`
-    # @param originally_text [Boolean]
-    #   Whether the original format of the interpolation was plain text,
-    #   not an interpolation.
-    #   This is used when converting back to SassScript.
+    # @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}
+    # @comment
+    #   rubocop:disable ParameterLists
     def initialize(before, mid, after, wb, wa, originally_text = false)
+      # rubocop:enable ParameterLists
       @before = before
       @mid = mid
       @after = after
@@ -64,16 +84,17 @@ module Sass::Script
     # Evaluates the interpolation.
     #
     # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
-    # @return [Sass::Script::String] The SassScript string that is the value of the interpolation
+    # @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)
-      res << (val.is_a?(Sass::Script::String) ? val.value : val.to_s)
+      res << (val.is_a?(Sass::Script::Value::String) ? val.value : val.to_s)
       res << " " if @after && @whitespace_after
       res << @after.perform(environment).to_s if @after
-      opts(Sass::Script::String.new(res))
+      opts(Sass::Script::Value::String.new(res))
     end
   end
 end

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

@@ -0,0 +1,80 @@
+module Sass::Script::Tree
+  # A parse tree node representing a list literal. When resolved, this returns a
+  # {Sass::Tree::Value::List}.
+  class ListLiteral < Node
+    # The parse nodes for members of this list.
+    #
+    # @return [Array<Node>]
+    attr_reader :elements
+
+    # The operator separating the values of the list. Either `:comma` or
+    # `:space`.
+    #
+    # @return [Symbol]
+    attr_reader :separator
+
+    # Creates a new list literal.
+    #
+    # @param elements [Array<Node>] See \{#elements}
+    # @param separator [Symbol] See \{#separator}
+    def initialize(elements, separator)
+      @elements = elements
+      @separator = separator
+    end
+
+    # @see Node#children
+    def children; elements; end
+
+    # @see Value#to_sass
+    def to_sass(opts = {})
+      return "()" if elements.empty?
+      precedence = Sass::Script::Parser.precedence_of(separator)
+      members = elements.map do |v|
+        if v.is_a?(ListLiteral) && Sass::Script::Parser.precedence_of(v.separator) <= precedence ||
+            separator == :space && v.is_a?(UnaryOperation) &&
+            (v.operator == :minus || v.operator == :plus)
+          "(#{v.to_sass(opts)})"
+        else
+          v.to_sass(opts)
+        end
+      end
+
+      return "(#{members.first},)" if separator == :comma && members.length == 1
+
+      members.join(sep_str(nil))
+    end
+
+
+    # @see Node#deep_copy
+    def deep_copy
+      node = dup
+      node.instance_variable_set('@elements', elements.map {|e| e.deep_copy})
+      node
+    end
+
+    def inspect
+      "(#{elements.map {|e| e.inspect}.join(separator == :space ? ' ' : ', ')})"
+    end
+
+    protected
+
+    def _perform(environment)
+      list = Sass::Script::Value::List.new(
+        elements.map {|e| e.perform(environment)},
+        separator)
+      list.line = line
+      list.source_range = source_range
+      list.filename = filename
+      list.options = options
+      list
+    end
+
+    private
+
+    def sep_str(opts = options)
+      return ' ' if separator == :space
+      return ',' if opts && opts[:style] == :compressed
+      ', '
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Sass::Script::Tree
+  # The parse tree node for a literal scalar value. This wraps an instance of
+  # {Sass::Script::Value::Base}.
+  #
+  # List literals should use {ListLiteral} instead.
+  class Literal < Node
+    # The wrapped value.
+    #
+    # @return [Sass::Script::Value::Base]
+    attr_reader :value
+
+    # Creates a new literal value.
+    #
+    # @param value [Sass::Script::Value::Base]
+    # @see #value
+    def initialize(value)
+      @value = value
+    end
+
+    # @see Node#children
+    def children; []; end
+
+    # @see Node#to_sass
+    def to_sass(opts = {}); value.to_sass(opts); end
+
+    # @see Node#deep_copy
+    def deep_copy; dup; end
+
+    # @see Node#options=
+    def options=(options)
+      value.options = options
+    end
+
+    def inspect
+      value.inspect
+    end
+
+    protected
+
+    def _perform(environment)
+      value.line = line
+      value.source_range = source_range
+      value.filename = filename
+      value
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Sass::Script::Tree
+  # A class representing a map literal. When resolved, this returns a
+  # {Sass::Script::Node::Map}.
+  class MapLiteral < Node
+    # The key/value pairs that make up this map node. This isn't a Hash so that
+    # we can detect key collisions once all the keys have been performed.
+    #
+    # @return [Array<(Node, Node)>]
+    attr_reader :pairs
+
+    # Creates a new map literal.
+    #
+    # @param pairs [Array<(Node, Node)>] See \{#pairs}
+    def initialize(pairs)
+      @pairs = pairs
+    end
+
+    # @see Node#children
+    def children
+      @pairs.flatten
+    end
+
+    # @see Node#to_sass
+    def to_sass(opts = {})
+      return "()" if pairs.empty?
+
+      to_sass = lambda do |value|
+        if value.is_a?(ListLiteral) && value.separator == :comma
+          "(#{value.to_sass(opts)})"
+        else
+          value.to_sass(opts)
+        end
+      end
+
+      "(" + pairs.map {|(k, v)| "#{to_sass[k]}: #{to_sass[v]}"}.join(', ') + ")"
+    end
+    alias_method :inspect, :to_sass
+
+    # @see Node#deep_copy
+    def deep_copy
+      node = dup
+      node.instance_variable_set('@pairs',
+        pairs.map {|(k, v)| [k.deep_copy, v.deep_copy]})
+      node
+    end
+
+    protected
+
+    # @see Node#_perform
+    def _perform(environment)
+      keys = Set.new
+      map = Sass::Script::Value::Map.new(Sass::Util.to_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))
+      map.options = options
+      map
+    end
+  end
+end

data/lib/sass/script/{node.rb → tree/node.rb}

@@ -1,4 +1,4 @@
-module Sass::Script
+module Sass::Script::Tree
   # The abstract superclass for SassScript parse tree nodes.
   #
   # Use \{#perform} to evaluate a parse tree.
@@ -13,6 +13,16 @@ module Sass::Script
     # @return [Fixnum]
     attr_accessor :line
 
+    # The source range in the document on which this node appeared.
+    #
+    # @return [Sass::Source::Range]
+    attr_accessor :source_range
+
+    # The file name of the document on which this node appeared.
+    #
+    # @return [String]
+    attr_accessor :filename
+
     # Sets the options hash for this node,
     # as well as for all child nodes.
     # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
@@ -22,7 +32,7 @@ module Sass::Script
       @options = options
       children.each do |c|
         if c.is_a? Hash
-          c.values.each {|v| v.options = options }
+          c.values.each {|v| v.options = options}
         else
           c.options = options
         end
@@ -35,7 +45,7 @@ module Sass::Script
     # instead, override \{#\_perform}.
     #
     # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
-    # @return [Literal] The SassScript object that is the value of the SassScript
+    # @return [Sass::Script::Value] The SassScript object that is the value of the SassScript
     def perform(environment)
       _perform(environment)
     rescue Sass::SyntaxError => e
@@ -70,30 +80,30 @@ module Sass::Script
     # Converts underscores to dashes if the :dasherize option is set.
     def dasherize(s, opts)
       if opts[:dasherize]
-        s.gsub(/_/,'-')
+        s.gsub(/_/, '-')
       else
         s
       end
     end
 
     # Evaluates this node.
-    # Note that all {Literal} objects created within this method
+    # Note that all {Sass::Script::Value} objects created within this method
     # should have their \{#options} attribute set, probably via \{#opts}.
     #
     # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
-    # @return [Literal] The SassScript object that is the value of the SassScript
+    # @return [Sass::Script::Value] The SassScript object that is the value of the SassScript
     # @see #perform
     def _perform(environment)
       Sass::Util.abstract(self)
     end
 
-    # Sets the \{#options} field on the given literal and returns it
+    # Sets the \{#options} field on the given value and returns it.
     #
-    # @param literal [Literal]
-    # @return [Literal]
-    def opts(literal)
-      literal.options = options
-      literal
+    # @param value [Sass::Script::Value]
+    # @return [Sass::Script::Value]
+    def opts(value)
+      value.options = options
+      value
     end
   end
 end