sass 3.3.0.alpha.149 → 3.3.0.alpha.162

data/lib/sass/script/tree.rb

@@ -0,0 +1,14 @@
+# The module containing nodes in the SassScript parse tree. These nodes are
+# all subclasses of {Sass::Script::Tree::Node}.
+module Sass::Script::Tree
+end
+
+require 'sass/script/tree/node'
+require 'sass/script/tree/variable'
+require 'sass/script/tree/funcall'
+require 'sass/script/tree/operation'
+require 'sass/script/tree/unary_operation'
+require 'sass/script/tree/interpolation'
+require 'sass/script/tree/string_interpolation'
+require 'sass/script/tree/literal'
+require 'sass/script/tree/list_literal'

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

@@ -0,0 +1,242 @@
+require 'sass/script/functions'
+
+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 splat argument for this function, if one exists.
+    #
+    # @return [Node?]
+    attr_accessor :splat
+
+    # @param name [String] See \{#name}
+    # @param args [Array<Node>] See \{#args}
+    # @param splat [Node] See \{#splat}
+    # @param keywords [{String => Node}] See \{#keywords}
+    def initialize(name, args, keywords, splat)
+      @name = name
+      @args = args
+      @keywords = keywords
+      @splat = 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).
+          map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
+      if self.splat
+        splat = (args.empty? && keywords.empty?) ? "" : ", "
+        splat = "#{splat}#{self.splat.inspect}..."
+      end
+      "#{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).join(', ')
+      keywords = Sass::Util.hash_to_a(@keywords).
+        map {|k, v| "$#{dasherize(k, opts)}: #{arg_to_sass[v]}"}.join(', ')
+      if self.splat
+        splat = (args.empty? && keywords.empty?) ? "" : ", "
+        splat = "#{splat}#{arg_to_sass[self.splat]}..."
+      end
+      "#{dasherize(name, opts)}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
+    end
+
+    # Returns the arguments to the function.
+    #
+    # @return [Array<Node>]
+    # @see Node#children
+    def children
+      res = @args + @keywords.values
+      res << @splat if @splat
+      res
+    end
+
+    # @see Node#deep_copy
+    def deep_copy
+      node = dup
+      node.instance_variable_set('@args', args.map {|a| a.deep_copy})
+      node.instance_variable_set('@keywords', Hash[keywords.map {|k, v| [k, v.deep_copy]}])
+      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 = @args.map {|a| a.perform(environment)}
+      splat = @splat.perform(environment) if @splat
+      if fn = environment.function(@name)
+        keywords = Sass::Util.map_hash(@keywords) {|k, v| [k, v.perform(environment)]}
+        return perform_sass_fn(fn, args, keywords, splat)
+      end
+
+      ruby_name = @name.tr('-', '_')
+      args = construct_ruby_args(ruby_name, args, splat, environment)
+
+      unless Sass::Script::Functions.callable?(ruby_name)
+        opts(to_literal(args))
+      else
+        local_environment = Sass::Environment.new(environment.global_env, environment.options)
+        opts(Sass::Script::Functions::EvaluationContext.new(local_environment).send(ruby_name, *args))
+      end
+    rescue ArgumentError => 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
+
+    # Compass historically overrode this before it changed name to {#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 construct_ruby_args(name, args, splat, environment)
+      args += splat.to_a if splat
+
+      # If variable arguments were passed, there won't be any explicit keywords.
+      if splat.is_a?(Sass::Script::Value::ArgList)
+        kwargs_size = splat.keywords.size
+        splat.keywords_accessed = false
+      else
+        kwargs_size = @keywords.size
+      end
+
+      unless signature = Sass::Script::Functions.signature(name.to_sym, args.size, kwargs_size)
+        return args if @keywords.empty?
+        raise Sass::SyntaxError.new("Function #{name} doesn't support keyword arguments")
+      end
+      keywords = splat.is_a?(Sass::Script::Value::ArgList) ? splat.keywords :
+        Sass::Util.map_hash(@keywords) {|k, v| [k, v.perform(environment)]}
+
+      # 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, keywords, splat)
+      Sass::Tree::Visitors::Perform.perform_arguments(function, args, keywords, splat) do |env|
+        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
+  end
+end

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

@@ -1,19 +1,36 @@
-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 {#before}
+    # @param mid [Node] See {#mid}
+    # @param after [Node] See {#after}
+    # @param wb [Boolean] See {#whitespace\_before}
+    # @param wa [Boolean] See {#whitespace\_after}
+    # @param originally_text [Boolean] See {#originally\_text}
     def initialize(before, mid, after, wb, wa, originally_text = false)
       @before = before
       @mid = mid
@@ -64,16 +81,16 @@ 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,65 @@
+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 Node#to_sass
+    def to_sass(opts = {})
+      return "()" if elements.empty?
+      precedence = Sass::Script::Parser.precedence_of(separator)
+      elements.map do |v|
+        if v.is_a?(ListLiteral) && Sass::Script::Parser.precedence_of(v.separator) <= precedence
+          "(#{v.to_sass(opts)})"
+        else
+          v.to_sass(opts)
+        end
+      end.join(separator == :space ? ' ' : ', ')
+    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 = self.options
+      list
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+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 [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/{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.
@@ -45,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
@@ -87,23 +87,23 @@ module Sass::Script
     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