sass 3.2.0.alpha.278 → 3.2.0.alpha.291

data/REVISION

@@ -1 +1 @@
-daf44b6e5e3a25e1fadb77a4161ffe27edea74ab
+b79252d738656e1cea492c2c09624ae1581681f6

data/VERSION

@@ -1 +1 @@
-3.2.0.alpha.278
+3.2.0.alpha.291

data/VERSION_DATE

@@ -1 +1 @@
-04 August 2012 00:02:51 GMT
+10 August 2012 23:31:56 GMT

data/lib/sass/engine.rb

@@ -52,11 +52,14 @@ module Sass
   # `name`: `String`
   # : The name of the mixin/function.
   #
-  # `args`: `Array<(String, Script::Node)>`
+  # `args`: `Array<(Script::Node, Script::Node)>`
   # : The arguments for the mixin/function.
-  #   Each element is a tuple containing the name of the argument
+  #   Each element is a tuple containing the variable node of the argument
   #   and the parse tree for the default value of the argument.
   #
+  # `splat`: `Script::Node?`
+  # : The variable node of the splat argument for this callable, or null.
+  #
   # `environment`: {Sass::Environment}
   # : The environment in which the mixin/function was defined.
   #   This is captured so that the mixin/function can have access
@@ -67,7 +70,10 @@ module Sass
   #
   # `has_content`: `Boolean`
   # : Whether the callable accepts a content block.
-  Callable = Struct.new(:name, :args, :environment, :tree, :has_content)
+  #
+  # `type`: `String`
+  # : The user-friendly name of the type of the callable.
+  Callable = Struct.new(:name, :args, :splat, :environment, :tree, :has_content, :type)
 
   # This class handles the parsing and compilation of the Sass template.
   # Example usage:
@@ -827,9 +833,9 @@ WARNING
       raise SyntaxError.new("Invalid mixin \"#{line.text[1..-1]}\".") if name.nil?
 
       offset = line.offset + line.text.size - arg_string.size
-      args = Script::Parser.new(arg_string.strip, @line, offset, @options).
+      args, splat = Script::Parser.new(arg_string.strip, @line, offset, @options).
         parse_mixin_definition_arglist
-      Tree::MixinDefNode.new(name, args)
+      Tree::MixinDefNode.new(name, args, splat)
     end
 
     CONTENT_RE = /^@content\s*(.+)?$/
@@ -847,9 +853,9 @@ WARNING
       raise SyntaxError.new("Invalid mixin include \"#{line.text}\".") if name.nil?
 
       offset = line.offset + line.text.size - arg_string.size
-      args, keywords = Script::Parser.new(arg_string.strip, @line, offset, @options).
+      args, keywords, splat = Script::Parser.new(arg_string.strip, @line, offset, @options).
         parse_mixin_include_arglist
-      Tree::MixinNode.new(name, args, keywords)
+      Tree::MixinNode.new(name, args, keywords, splat)
     end
 
     FUNCTION_RE = /^@function\s*(#{Sass::SCSS::RX::IDENT})(.*)$/
@@ -858,9 +864,9 @@ WARNING
       raise SyntaxError.new("Invalid function definition \"#{line.text}\".") if name.nil?
 
       offset = line.offset + line.text.size - arg_string.size
-      args = Script::Parser.new(arg_string.strip, @line, offset, @options).
+      args, splat = Script::Parser.new(arg_string.strip, @line, offset, @options).
         parse_function_definition_arglist
-      Tree::FunctionNode.new(name, args)
+      Tree::FunctionNode.new(name, args, splat)
     end
 
     def parse_script(script, options = {})

data/lib/sass/script/arg_list.rb

@@ -0,0 +1,52 @@
+module Sass::Script
+  # A SassScript object representing a variable argument list. This works just
+  # like a normal list, but can also contain keyword arguments.
+  #
+  # The keyword arguments attached to this list are unused except when this is
+  # passed as a glob argument to a function or mixin.
+  class ArgList < List
+    # Whether \{#keywords} has been accessed. If so, we assume that all keywords
+    # were valid for the function that created this ArgList.
+    #
+    # @return [Boolean]
+    attr_accessor :keywords_accessed
+
+    # Creates a new argument list.
+    #
+    # @param value [Array<Literal>] See \{List#value}.
+    # @param keywords [Hash<String, Literal>] See \{#keywords}
+    # @param separator [String] See \{List#separator}.
+    def initialize(value, keywords, separator)
+      super(value, separator)
+      @keywords = keywords
+    end
+
+    # The keyword arguments attached to this list.
+    #
+    # @return [Hash<String, Literal>]
+    def keywords
+      @keywords_accessed = true
+      @keywords
+    end
+
+    # @see Node#children
+    def children
+      super + @keywords.values
+    end
+
+    # @see Node#deep_copy
+    def deep_copy
+      node = super
+      node.instance_variable_set('@keywords',
+        Sass::Util.map_hash(@keywords) {|k, v| [k, v.deep_copy]})
+      node
+    end
+
+    protected
+
+    # @see Node#_perform
+    def _perform(environment)
+      self
+    end
+  end
+end

data/lib/sass/script/funcall.rb

@@ -23,13 +23,20 @@ module Sass
       # @return [{String => Script::Node}]
       attr_reader :keywords
 
+      # The splat argument for this function, if one exists.
+      #
+      # @return [Script::Node?]
+      attr_accessor :splat
+
       # @param name [String] See \{#name}
       # @param args [Array<Script::Node>] See \{#args}
+      # @param splat [Script::Node] See \{#splat}
       # @param keywords [{String => Script::Node}] See \{#keywords}
-      def initialize(name, args, keywords)
+      def initialize(name, args, keywords, splat)
         @name = name
         @args = args
         @keywords = keywords
+        @splat = splat
         super()
       end
 
@@ -38,7 +45,11 @@ module Sass
         args = @args.map {|a| a.inspect}.join(', ')
         keywords = Sass::Util.hash_to_a(@keywords).
             map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
-        "#{name}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
+        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
@@ -46,7 +57,11 @@ module Sass
         args = @args.map {|a| a.to_sass(opts)}.join(', ')
         keywords = Sass::Util.hash_to_a(@keywords).
           map {|k, v| "$#{dasherize(k, opts)}: #{v.to_sass(opts)}"}.join(', ')
-        "#{dasherize(name, opts)}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
+        if self.splat
+          splat = (args.empty? && keywords.empty?) ? "" : ", "
+          splat = "#{splat}#{self.splat.inspect}..."
+        end
+        "#{dasherize(name, opts)}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
       end
 
       # Returns the arguments to the function.
@@ -54,7 +69,9 @@ module Sass
       # @return [Array<Node>]
       # @see Node#children
       def children
-        @args + @keywords.values
+        res = @args + @keywords.values
+        res << @splat if @splat
+        res
       end
 
       # @see Node#deep_copy
@@ -74,13 +91,14 @@ module Sass
       # @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)
+          return perform_sass_fn(fn, args, keywords, splat)
         end
 
         ruby_name = @name.tr('-', '_')
-        args = construct_ruby_args(ruby_name, args, environment)
+        args = construct_ruby_args(ruby_name, args, splat, environment)
 
         unless Functions.callable?(ruby_name)
           opts(to_literal(args))
@@ -106,12 +124,23 @@ module Sass
 
       private
 
-      def construct_ruby_args(name, args, environment)
-        unless signature = Functions.signature(name.to_sym, args.size, @keywords.size)
-          return args if keywords.empty?
+      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::ArgList)
+          kwargs_size = splat.keywords.size
+          splat.keywords_accessed = false
+        else
+          kwargs_size = @keywords.size
+        end
+
+        unless signature = 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 = Sass::Util.map_hash(@keywords) {|k, v| [k, v.perform(environment)]}
+        keywords = splat.is_a?(Sass::Script::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.
@@ -148,36 +177,14 @@ module Sass
         args
       end
 
-      def perform_sass_fn(function, args, keywords)
-        # TODO: merge with mixin arg evaluation?
-        if keywords.any?
-          unknown_args = keywords.keys - function.args.map {|var| var.first.underscored_name }
-          if unknown_args.any?
-            raise Sass::SyntaxError.new("Function #{@name} doesn't have #{unknown_args.length > 1 ? 'the following arguments:' : 'an argument named'} #{unknown_args.map{|name| "$#{name}"}.join ', '}")
+      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
-
-        if args.size > function.args.size
-          raise ArgumentError.new("Wrong number of arguments (#{args.size} for #{function.args.size})")
-        end
-
-        environment = function.args.zip(args).
-          inject(Sass::Environment.new(function.environment)) do |env, ((var, default), value)|
-          if value && keywords.include?(var.underscored_name)
-            raise Sass::SyntaxError.new("Function #{@name} was passed argument $#{var.name} both by position and by name")
-          end
-
-          env.set_local_var(var.name,
-            value || keywords[var.underscored_name] || (default && default.perform(env)))
-          raise Sass::SyntaxError.new("Function #{@name} is missing argument #{var.inspect}") unless env.var(var.name)
-          env
-        end
-
-        val = catch :_sass_return do
-          function.tree.each {|c| Sass::Tree::Visitors::Perform.visit(c, environment)}
-          raise Sass::SyntaxError.new("Function #{@name} finished without @return")
-        end
-        val
       end
     end
   end

data/lib/sass/script/lexer.rb

@@ -62,6 +62,7 @@ module Sass
         '}' => :end_interpolation,
         ';' => :semicolon,
         '{' => :lcurly,
+        '...' => :splat,
       }
 
       OPERATORS_REVERSE = Sass::Util.map_hash(OPERATORS) {|k, v| [v, k]}

data/lib/sass/script/list.rb

@@ -34,7 +34,7 @@ module Sass::Script
     # @see Node#eq
     def eq(other)
       Sass::Script::Bool.new(
-        self.class == other.class && self.value == other.value &&
+        other.is_a?(List) && self.value == other.value &&
         self.separator == other.separator)
     end
 

data/lib/sass/script/literal.rb

@@ -11,6 +11,7 @@ module Sass::Script
     require 'sass/script/bool'
     require 'sass/script/null'
     require 'sass/script/list'
+    require 'sass/script/arg_list'
 
     # Returns the Ruby value of the literal.
     # The type of this value varies based on the subclass.

data/lib/sass/script/number.rb

@@ -422,12 +422,13 @@ module Sass::Script
     end
 
     # A hash of unit names to their index in the conversion table
-    CONVERTABLE_UNITS = {"in" => 0,        "cm" => 1,    "pc" => 2,    "mm" => 3,   "pt" => 4}
-    CONVERSION_TABLE = [[ 1,                2.54,         6,            25.4,        72        ], # in
-                        [ nil,              1,            2.36220473,   10,          28.3464567], # cm
-                        [ nil,              nil,          1,            4.23333333,  12        ], # pc
-                        [ nil,              nil,          nil,          1,           2.83464567], # mm
-                        [ nil,              nil,          nil,          nil,         1         ]] # pt
+    CONVERTABLE_UNITS = {"in" => 0,        "cm" => 1,    "pc" => 2,    "mm" => 3,   "pt" => 4,  "px" => 5    }
+    CONVERSION_TABLE = [[ 1,                2.54,         6,            25.4,        72        , 96          ], # in
+                        [ nil,              1,            2.36220473,   10,          28.3464567, 37.795275591], # cm
+                        [ nil,              nil,          1,            4.23333333,  12        , 16          ], # pc
+                        [ nil,              nil,          nil,          1,           2.83464567, 3.7795275591], # mm
+                        [ nil,              nil,          nil,          nil,         1         , 1.3333333333], # pt
+                        [ nil,              nil,          nil,          nil,         nil       , 1           ]] # px
 
     def conversion_factor(from_unit, to_unit)
       res = CONVERSION_TABLE[CONVERTABLE_UNITS[from_unit]][CONVERTABLE_UNITS[to_unit]]

data/lib/sass/script/parser.rb

@@ -74,21 +74,22 @@ module Sass
 
       # Parses the argument list for a mixin include.
       #
-      # @return [(Array<Script::Node>, {String => Script::Note})]
-      #   The root nodes of the arguments.
-      #   Keyword arguments are in a hash from names to values.
+      # @return [(Array<Script::Node>, {String => Script::Node}, Script::Node)]
+      #   The root nodes of the positional arguments, keyword arguments, and
+      #   splat argument. Keyword arguments are in a hash from names to values.
       # @raise [Sass::SyntaxError] if the argument list isn't valid SassScript
       def parse_mixin_include_arglist
         args, keywords = [], {}
         if try_tok(:lparen)
-          args, keywords = mixin_arglist || [[], {}]
+          args, keywords, splat = mixin_arglist || [[], {}]
           assert_tok(:rparen)
         end
         assert_done
 
         args.each {|a| a.options = @options}
         keywords.each {|k, v| v.options = @options}
-        return args, keywords
+        splat.options = @options if splat
+        return args, keywords, splat
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
         raise e
@@ -96,17 +97,19 @@ module Sass
 
       # Parses the argument list for a mixin definition.
       #
-      # @return [Array<Script::Node>] The root nodes of the arguments.
+      # @return [(Array<Script::Node>, Script::Node)]
+      #   The root nodes of the arguments, and the splat argument.
       # @raise [Sass::SyntaxError] if the argument list isn't valid SassScript
       def parse_mixin_definition_arglist
-        args = defn_arglist!(false)
+        args, splat = defn_arglist!(false)
         assert_done
 
         args.each do |k, v|
           k.options = @options
           v.options = @options if v
         end
-        args
+        splat.options = @options if splat
+        return args, splat
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
         raise e
@@ -114,17 +117,19 @@ module Sass
 
       # Parses the argument list for a function definition.
       #
-      # @return [Array<Script::Node>] The root nodes of the arguments.
+      # @return [(Array<Script::Node>, Script::Node)]
+      #   The root nodes of the arguments, and the splat argument.
       # @raise [Sass::SyntaxError] if the argument list isn't valid SassScript
       def parse_function_definition_arglist
-        args = defn_arglist!(true)
+        args, splat = defn_arglist!(true)
         assert_done
 
         args.each do |k, v|
           k.options = @options
           v.options = @options if v
         end
-        args
+        splat.options = @options if splat
+        return args, splat
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
         raise e
@@ -324,37 +329,41 @@ RUBY
 
       def funcall
         return raw unless tok = try_tok(:funcall)
-        args, keywords = fn_arglist || [[], {}]
+        args, keywords, splat = fn_arglist || [[], {}]
         assert_tok(:rparen)
-        node(Script::Funcall.new(tok.value, args, keywords))
+        node(Script::Funcall.new(tok.value, args, keywords, splat))
       end
 
       def defn_arglist!(must_have_parens)
         if must_have_parens
           assert_tok(:lparen)
         else
-          return [] unless try_tok(:lparen)
+          return [], nil unless try_tok(:lparen)
         end
-        return [] if try_tok(:rparen)
+        return [], nil if try_tok(:rparen)
 
         res = []
+        splat = nil
         must_have_default = false
         loop do
           line = @lexer.line
           offset = @lexer.offset + 1
           c = assert_tok(:const)
           var = Script::Variable.new(c.value)
-          if tok = try_tok(:colon)
+          if try_tok(:colon)
             val = assert_expr(:space)
             must_have_default = true
           elsif must_have_default
             raise SyntaxError.new("Required argument #{var.inspect} must come before any optional arguments.")
+          elsif try_tok(:splat)
+            splat = var
+            break
           end
           res << [var, val]
           break unless try_tok(:comma)
         end
         assert_tok(:rparen)
-        res
+        return res, splat
       end
 
       def fn_arglist
@@ -376,34 +385,23 @@ RUBY
 
         unless try_tok(:comma)
           return [], keywords if keywords
+          return [], {}, e if try_tok(:splat)
           return [e], {}
         end
 
-        other_args, other_keywords = assert_expr(type)
+        other_args, other_keywords, splat = assert_expr(type)
         if keywords
-          if !other_args.empty?
-            raise SyntaxError.new("Positional arguments must come before keyword arguments")
+          if !other_args.empty? || splat
+            raise SyntaxError.new("Positional arguments must come before keyword arguments.")
           elsif other_keywords[name.underscored_name]
             raise SyntaxError.new("Keyword argument \"#{name.to_sass}\" passed more than once")
           end
-          return other_args, keywords.merge(other_keywords)
+          return other_args, keywords.merge(other_keywords), splat
         else
-          return [e, *other_args], other_keywords
+          return [e, *other_args], other_keywords, splat
         end
       end
 
-      def keyword_arglist
-        return unless var = try_tok(:const)
-        unless try_tok(:colon)
-          return_tok!
-          return
-        end
-        name = var[1]
-        value = interpolation
-        return {name => value} unless try_tok(:comma)
-        {name => value}.merge(assert_expr(:keyword_arglist))
-      end
-
       def raw
         return special_fun unless tok = try_tok(:raw)
         node(Script::String.new(tok.value))