sass 3.3.0.alpha.253 → 3.3.0.alpha.255

data/REVISION

@@ -1 +1 @@
-b6f71a816b6d7fd3c54def0dbb2eb4266c1585d1
+a4e9233341aeaf94bd00b4c85b95e004c94df2f7

data/VERSION

@@ -1 +1 @@
-3.3.0.alpha.253
+3.3.0.alpha.255

data/VERSION_DATE

@@ -1 +1 @@
-07 September 2013 00:38:13 GMT
+18 September 2013 22:11:11 GMT

data/lib/sass/engine.rb

@@ -1060,9 +1060,10 @@ WARNING
       raise SyntaxError.new("Invalid mixin include \"#{line.text}\".") if name.nil?
 
       offset = line.offset + line.text.size - arg_string.size
-      args, keywords, splat = Script::Parser.new(arg_string.strip, @line, to_parser_offset(offset), @options).
-        parse_mixin_include_arglist
-      Tree::MixinNode.new(name, args, keywords, splat)
+      args, keywords, splat, kwarg_splat =
+        Script::Parser.new(arg_string.strip, @line, to_parser_offset(offset), @options).
+          parse_mixin_include_arglist
+      Tree::MixinNode.new(name, args, keywords, splat, kwarg_splat)
     end
 
     FUNCTION_RE = /^@function\s*(#{Sass::SCSS::RX::IDENT})(.*)$/

data/lib/sass/script/functions.rb

@@ -194,6 +194,9 @@ module Sass::Script
   # \{#map_has_key map-has-key($key)}
   # : Returns whether a map has a value associated with a given key.
   #
+  # \{#keywords keywords($args)}
+  # : Returns the keywords passed to a function that takes variable arguments.
+  #
   # ## Introspection Functions
   #
   # \{#feature_exists feature-exists($feature)}
@@ -367,6 +370,11 @@ module Sass::Script
     class EvaluationContext
       include Functions
 
+      # The human-readable names for [Sass::Script::Value::Base]. The default is
+      # just the downcased name of the type. The default is the downcased type
+      # name.
+      TYPE_NAMES = {:ArgList => 'variable argument list'}
+
       # The global environment.
       #
       # @return [Environment]
@@ -401,7 +409,7 @@ module Sass::Script
         klass = Sass::Script::Value.const_get(type)
         return if value.is_a?(klass)
         return if value.is_a?(Sass::Script::Value::List) && type == :Map && value.is_pseudo_map?
-        err = "#{value.inspect} is not a #{type.to_s.downcase}"
+        err = "#{value.inspect} is not a #{TYPE_NAMES[type] || type.to_s.downcase}"
         err = "$#{name.to_s.gsub('_', '-')}: " + err if name
         raise ArgumentError.new(err)
       end
@@ -1859,6 +1867,26 @@ module Sass::Script
     end
     declare :map_has_key, [:map, :key]
 
+    # Returns the map of named arguments passed to a function or mixin that
+    # takes a variable argument list. The argument names are strings, and they
+    # do not contain the leading `$`.
+    #
+    # @example
+    #   @mixin foo($args...) {
+    #     @debug keywords($args); //=> (arg1: val, arg2: val)
+    #   }
+    #
+    #   @include foo($arg1: val, $arg2: val);
+    # @overload keywords($args)
+    # @param $args [Sass::Script::Value::ArgList]
+    # @return [Sass::Script::Value::Map]
+    # @raise [ArgumentError] if `$args` isn't a variable argument list
+    def keywords(args)
+      assert_type args, :ArgList
+      Sass::Script::Value::Map.new(Sass::Util.map_keys(args.keywords) {|k| Sass::Script::String.new(k)})
+    end
+    declare :keywords, [:args]
+
     # Returns one of two values, depending on whether or not `$condition` is
     # true. Just like in `@if`, all values other than `false` and `null` are
     # considered to be true.
@@ -1917,6 +1945,7 @@ module Sass::Script
         name.value,
         args.map {|a| Sass::Script::Tree::Literal.new(a)},
         Sass::Util.map_vals(kwargs) {|v| Sass::Script::Tree::Literal.new(v)},
+        nil,
         nil)
       funcall.options = options
       funcall.perform(environment)

data/lib/sass/script/parser.rb

@@ -81,14 +81,14 @@ module Sass
 
       # Parses the argument list for a mixin include.
       #
-      # @return [(Array<Script::Tree::Node>, {String => Script::Tree::Node}, Script::Tree::Node)]
+      # @return [(Array<Script::Tree::Node>, {String => Script::Tree::Node}, Script::Tree::Node, Script::Tree::Node)]
       #   The root nodes of the positional arguments, keyword arguments, and
-      #   splat argument. Keyword arguments are in a hash from names to values.
+      #   splat argument(s). 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, splat = mixin_arglist
+          args, keywords, splat, kwarg_splat = mixin_arglist
           assert_tok(:rparen)
         end
         assert_done
@@ -96,7 +96,8 @@ module Sass
         args.each {|a| a.options = @options}
         keywords.each {|k, v| v.options = @options}
         splat.options = @options if splat
-        return args, keywords, splat
+        kwarg_splat.options = @options if kwarg_splat
+        return args, keywords, splat, kwarg_splat
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
         raise e
@@ -366,9 +367,9 @@ RUBY
 
       def funcall
         return raw unless tok = try_tok(:funcall)
-        args, keywords, splat = fn_arglist
+        args, keywords, splat, kwarg_splat = fn_arglist
         assert_tok(:rparen)
-        node(Script::Tree::Funcall.new(tok.value, args, keywords, splat),
+        node(Script::Tree::Funcall.new(tok.value, args, keywords, splat, kwarg_splat),
           tok.source_range.start_pos, source_position)
       end
 
@@ -433,7 +434,13 @@ RUBY
               raise SyntaxError.new("Positional arguments must come before keyword arguments.")
             end
 
-            return args, keywords, e if try_tok(:splat)
+            if try_tok(:splat)
+              splat = e
+              return args, keywords, splat unless try_tok(:comma)
+              kwarg_splat = assert_expr(subexpr, description)
+              assert_tok(:splat)
+              return args, keywords, splat, kwarg_splat
+            end
             args << e
           end
 
@@ -517,6 +524,7 @@ RUBY
         :default => "expression (e.g. 1px, bold)",
         :mixin_arglist => "mixin argument",
         :fn_arglist => "function argument",
+        :splat => "...",
       }
 
       def assert_expr(name, expected = nil)

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

@@ -23,20 +23,33 @@ module Sass::Script::Tree
     # @return [{String => Node}]
     attr_reader :keywords
 
-    # The splat argument for this function, if one exists.
+    # 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}
-    def initialize(name, args, keywords, 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
 
@@ -48,6 +61,7 @@ module Sass::Script::Tree
       if self.splat
         splat = (args.empty? && keywords.empty?) ? "" : ", "
         splat = "#{splat}#{self.splat.inspect}..."
+        splat = "#{splat}, #{kwarg_splat.inspect}..." if kwarg_splat
       end
       "#{name}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
     end
@@ -66,6 +80,7 @@ module Sass::Script::Tree
       if self.splat
         splat = (args.empty? && keywords.empty?) ? "" : ", "
         splat = "#{splat}#{arg_to_sass[self.splat]}..."
+        splat = "#{splat}, #{arg_to_sass[kwarg_splat]}..." if kwarg_splat
       end
       "#{dasherize(name, opts)}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
     end
@@ -77,6 +92,7 @@ module Sass::Script::Tree
     def children
       res = @args + @keywords.values
       res << @splat if @splat
+      res << @kwarg_splat if @kwarg_splat
       res
     end
 
@@ -99,14 +115,14 @@ module Sass::Script::Tree
     # @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
+      splat = Sass::Tree::Visitors::Perform.perform_splat(@splat, @kwarg_splat, environment)
+      keywords = Sass::Util.map_hash(@keywords) {|k, v| [k, v.perform(environment)]}
       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, environment)
       end
 
       ruby_name = @name.tr('-', '_')
-      args = construct_ruby_args(ruby_name, args, splat, environment)
+      args = construct_ruby_args(ruby_name, args, keywords, splat, environment)
 
       unless Sass::Script::Functions.callable?(ruby_name)
         opts(to_literal(args))
@@ -179,23 +195,20 @@ module Sass::Script::Tree
 
     private
 
-    def construct_ruby_args(name, args, splat, environment)
+    def construct_ruby_args(name, args, keywords, 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
+      if splat && !splat.keywords.empty?
+        old_keywords_accessed = splat.keywords_accessed
+        keywords = splat.keywords
+        splat.keywords_accessed = old_keywords_accessed
       end
 
-      unless signature = Sass::Script::Functions.signature(name.to_sym, args.size, kwargs_size)
-        return args if @keywords.empty?
+      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
-      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.

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

@@ -28,10 +28,5 @@ module Sass::Script::Value
       @keywords_accessed = true
       @keywords
     end
-
-    # @see Base#children
-    def children
-      super + @keywords.values
-    end
   end
 end

data/lib/sass/scss/parser.rb

@@ -209,9 +209,9 @@ module Sass
 
       def include_directive(start_pos)
         name = tok! IDENT
-        args, keywords, splat = sass_script(:parse_mixin_include_arglist)
+        args, keywords, splat, kwarg_splat = sass_script(:parse_mixin_include_arglist)
         ss
-        include_node = node(Sass::Tree::MixinNode.new(name, args, keywords, splat), start_pos)
+        include_node = node(Sass::Tree::MixinNode.new(name, args, keywords, splat, kwarg_splat), start_pos)
         if tok?(/\{/)
           include_node.has_children = true
           block(include_node, :directive)

data/lib/sass/tree/mixin_node.rb

@@ -19,20 +19,33 @@ module Sass::Tree
     # @return [{String => Script::Tree::Node}]
     attr_accessor :keywords
 
-    # The splat argument for this mixin, if one exists.
+    # The first splat argument for this mixin, if one exists.
     #
-    # @return [Script::Tree::Node?]
+    # 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 mixin, 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] The name of the mixin
     # @param args [Array<Script::Tree::Node>] See \{#args}
     # @param splat [Script::Tree::Node] See \{#splat}
+    # @param kwarg_splat [Script::Tree::Node] See \{#kwarg_splat}
     # @param keywords [{String => Script::Tree::Node}] See \{#keywords}
-    def initialize(name, args, keywords, splat)
+    def initialize(name, args, keywords, splat, kwarg_splat)
       @name = name
       @args = args
       @keywords = keywords
       @splat = splat
+      @kwarg_splat = kwarg_splat
       super()
     end
   end

data/lib/sass/tree/visitors/convert.rb

@@ -208,6 +208,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
       if node.splat
         splat = (args.empty? && keywords.empty?) ? "" : ", "
         splat = "#{splat}#{arg_to_sass[node.splat]}..."
+        splat = "#{splat}, #{node.kwarg_splat.inspect}..." if node.kwarg_splat
       end
       arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
     end

data/lib/sass/tree/visitors/perform.rb

@@ -1,89 +1,135 @@
 # A visitor for converting a dynamic Sass tree into a static Sass tree.
 class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
-  # @param root [Tree::Node] The root node of the tree to visit.
-  # @param environment [Sass::Environment] The lexical environment.
-  # @return [Tree::Node] The resulting tree of static nodes.
-  def self.visit(root, environment = nil)
-    new(environment).send(:visit, root)
-  end
+  class << self
+    # @param root [Tree::Node] The root node of the tree to visit.
+    # @param environment [Sass::Environment] The lexical environment.
+    # @return [Tree::Node] The resulting tree of static nodes.
+    def visit(root, environment = nil)
+      new(environment).send(:visit, root)
+    end
 
-  # @api private
-  def self.perform_arguments(callable, args, keywords, splat)
-    desc = "#{callable.type.capitalize} #{callable.name}"
-    downcase_desc = "#{callable.type} #{callable.name}"
+    # @api private
+    def perform_arguments(callable, args, keywords, splat)
+      desc = "#{callable.type.capitalize} #{callable.name}"
+      downcase_desc = "#{callable.type} #{callable.name}"
 
-    begin
-      unless keywords.empty?
-        unknown_args = Sass::Util.array_minus(keywords.keys,
-          callable.args.map {|var| var.first.underscored_name})
-        if callable.splat && unknown_args.include?(callable.splat.underscored_name)
-          raise Sass::SyntaxError.new("Argument $#{callable.splat.name} of #{downcase_desc} cannot be used as a named argument.")
-        elsif unknown_args.any?
-          description = unknown_args.length > 1 ? 'the following arguments:' : 'an argument named'
-          raise Sass::SyntaxError.new("#{desc} doesn't have #{description} #{unknown_args.map {|name| "$#{name}"}.join ', '}.")
+      # If variable arguments were passed, there won't be any explicit keywords.
+      if splat && !splat.keywords.empty?
+        old_keywords_accessed = splat.keywords_accessed
+        keywords = splat.keywords
+        splat.keywords_accessed = old_keywords_accessed
+      end
+
+      begin
+        unless keywords.empty?
+          unknown_args = Sass::Util.array_minus(keywords.keys,
+            callable.args.map {|var| var.first.underscored_name})
+          if callable.splat && unknown_args.include?(callable.splat.underscored_name)
+            raise Sass::SyntaxError.new("Argument $#{callable.splat.name} of #{downcase_desc} cannot be used as a named argument.")
+          elsif unknown_args.any?
+            description = unknown_args.length > 1 ? 'the following arguments:' : 'an argument named'
+            raise Sass::SyntaxError.new("#{desc} doesn't have #{description} #{unknown_args.map {|name| "$#{name}"}.join ', '}.")
+          end
         end
+      rescue Sass::SyntaxError => keyword_exception
       end
-    rescue Sass::SyntaxError => keyword_exception
-    end
 
-    # If there's no splat, raise the keyword exception immediately. The actual
-    # raising happens in the ensure clause at the end of this function.
-    return if keyword_exception && !callable.splat
+      # If there's no splat, raise the keyword exception immediately. The actual
+      # raising happens in the ensure clause at the end of this function.
+      return if keyword_exception && !callable.splat
 
-    if args.size > callable.args.size && !callable.splat
-      takes = callable.args.size
-      passed = args.size
-      raise Sass::SyntaxError.new(
-        "#{desc} takes #{takes} argument#{'s' unless takes == 1} " +
-        "but #{passed} #{passed == 1 ? 'was' : 'were'} passed.")
-    end
+      if args.size > callable.args.size && !callable.splat
+        takes = callable.args.size
+        passed = args.size
+        raise Sass::SyntaxError.new(
+          "#{desc} takes #{takes} argument#{'s' unless takes == 1} " +
+          "but #{passed} #{passed == 1 ? 'was' : 'were'} passed.")
+      end
 
-    splat_sep = :comma
-    if splat
-      args += splat.to_a
-      splat_sep = splat.separator if splat.is_a?(Sass::Script::Value::List)
-      # If the splat argument exists, there won't be any keywords passed in
-      # manually, so we can safely overwrite rather than merge here.
-      keywords = splat.keywords if splat.is_a?(Sass::Script::Value::ArgList)
-    end
+      splat_sep = :comma
+      if splat
+        args += splat.to_a
+        splat_sep = splat.separator
+      end
+
+      keywords = keywords.dup
+      env = Sass::Environment.new(callable.environment)
+      callable.args.zip(args[0...callable.args.length]) do |(var, default), value|
+        if value && keywords.include?(var.underscored_name)
+          raise Sass::SyntaxError.new("#{desc} was passed argument $#{var.name} both by position and by name.")
+        end
+
+        value ||= keywords.delete(var.underscored_name)
+        value ||= default && default.perform(env)
+        raise Sass::SyntaxError.new("#{desc} is missing argument #{var.inspect}.") unless value
+        env.set_local_var(var.name, value)
+      end
 
-    keywords = keywords.dup
-    env = Sass::Environment.new(callable.environment)
-    callable.args.zip(args[0...callable.args.length]) do |(var, default), value|
-      if value && keywords.include?(var.underscored_name)
-        raise Sass::SyntaxError.new("#{desc} was passed argument $#{var.name} both by position and by name.")
+      if callable.splat
+        rest = args[callable.args.length..-1] || []
+        arg_list = Sass::Script::Value::ArgList.new(rest, keywords.dup, splat_sep)
+        arg_list.options = env.options
+        env.set_local_var(callable.splat.name, arg_list)
       end
 
-      value ||= keywords.delete(var.underscored_name)
-      value ||= default && default.perform(env)
-      raise Sass::SyntaxError.new("#{desc} is missing argument #{var.inspect}.") unless value
-      env.set_local_var(var.name, value)
+      yield env
+    rescue Exception => e
+    ensure
+      # If there's a keyword exception, we don't want to throw it immediately,
+      # because the invalid keywords may be part of a glob argument that should be
+      # passed on to another function. So we only raise it if we reach the end of
+      # this function *and* the keywords attached to the argument list glob object
+      # haven't been accessed.
+      #
+      # The keyword exception takes precedence over any Sass errors, but not over
+      # non-Sass exceptions.
+      if keyword_exception &&
+          !(arg_list && arg_list.keywords_accessed) &&
+          (e.nil? || e.is_a?(Sass::SyntaxError))
+        raise keyword_exception
+      elsif e
+        raise e
+      end
     end
 
-    if callable.splat
-      rest = args[callable.args.length..-1]
-      arg_list = Sass::Script::Value::ArgList.new(rest, keywords.dup, splat_sep)
-      arg_list.options = env.options
-      env.set_local_var(callable.splat.name, arg_list)
+    # @api private
+    # @return [Sass::Script::Value::ArgList]
+    def perform_splat(splat, kwarg_splat, environment)
+      return unless splat
+      splat = splat.perform(environment)
+      unless kwarg_splat
+        return splat if splat.is_a?(Sass::Script::Value::ArgList)
+        if splat.is_a?(Sass::Script::Value::Map)
+          args = []
+          kwargs = arg_hash(splat)
+        else
+          args = splat.to_a
+          kwargs = {}
+        end
+        return Sass::Script::Value::ArgList.new(args, kwargs, splat.separator || :comma)
+      end
+
+      kwarg_splat = kwarg_splat.perform(environment)
+      unless kwarg_splat.is_a?(Sass::Script::Value::Map)
+        raise Sass::SyntaxError.new("Variable keyword arguments must be a map (was #{kwarg_splat.inspect}).")
+      end
+
+      if splat.is_a?(Sass::Script::Value::ArgList)
+        return Sass::Script::Value::ArgList.new(
+          splat.value, splat.keywords.merge(arg_hash(kwarg_splat)), splat.separator)
+      else
+        return Sass::Script::Value::ArgList.new(splat.to_a, arg_hash(kwarg_splat), splat.separator)
+      end
     end
 
-    yield env
-  rescue Exception => e
-  ensure
-    # If there's a keyword exception, we don't want to throw it immediately,
-    # because the invalid keywords may be part of a glob argument that should be
-    # passed on to another function. So we only raise it if we reach the end of
-    # this function *and* the keywords attached to the argument list glob object
-    # haven't been accessed.
-    #
-    # The keyword exception takes precedence over any Sass errors, but not over
-    # non-Sass exceptions.
-    if keyword_exception &&
-        !(arg_list && arg_list.keywords_accessed) &&
-        (e.nil? || e.is_a?(Sass::SyntaxError))
-      raise keyword_exception
-    elsif e
-      raise e
+    private
+
+    def arg_hash(map)
+      Sass::Util.map_keys(map.to_h) do |key|
+        next key.value if key.is_a?(Sass::Script::Value::String)
+        raise Sass::SyntaxError.new("Variable keyword argument map must have string keys.\n" +
+          "#{key.inspect} is not a string in #{map.inspect}.");
+      end
     end
   end
 
@@ -267,7 +313,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
       args = node.args.map {|a| a.perform(@environment)}
       keywords = Sass::Util.map_hash(node.keywords) {|k, v| [k, v.perform(@environment)]}
-      splat = node.splat.perform(@environment) if node.splat
+      splat = self.class.perform_splat(node.splat, node.kwarg_splat, @environment)
 
       self.class.perform_arguments(mixin, args, keywords, splat) do |env|
         env.caller = Sass::Environment.new(@environment)

data/test/sass/conversion_test.rb

@@ -1621,6 +1621,26 @@ SASS
 SCSS
   end
 
+  def test_mixin_var_kwargs
+    assert_scss_to_sass <<SASS, <<SCSS
+=foo($a: b, $c: d)
+  a: $a
+  c: $c
+
+.foo
+  +foo($list..., $map...)
+SASS
+@mixin foo($a: b, $c: d) {
+  a: $a;
+  c: $c;
+}
+
+.foo {
+  @include foo($list..., $map...);
+}
+SCSS
+  end
+
   def test_function_var_args
     assert_scss_to_sass <<SASS, <<SCSS
 @function foo($args...)
@@ -1648,6 +1668,24 @@ SASS
 SCSS
   end
 
+  def test_function_var_kwargs
+    assert_scss_to_sass <<SASS, <<SCSS
+@function foo($a: b, $c: d)
+  @return foo
+
+.foo
+  a: foo($list..., $map...)
+SASS
+@function foo($a: b, $c: d) {
+  @return foo;
+}
+
+.foo {
+  a: foo($list..., $map...);
+}
+SCSS
+  end
+
   def test_at_root
     assert_scss_to_sass <<SASS, <<SCSS
 .foo
@@ -1684,6 +1722,24 @@ SASS
 SCSS
   end
 
+  def test_function_var_kwargs_with_list
+    assert_scss_to_sass <<SASS, <<SCSS
+@function foo($a: b, $c: d)
+  @return $a, $c
+
+.foo
+  a: foo($list..., $map...)
+SASS
+@function foo($a: b, $c: d) {
+  @return $a, $c;
+}
+
+.foo {
+  a: foo($list..., $map...);
+}
+SCSS
+  end
+
   ## Regression Tests
 
   def test_list_in_args

data/test/sass/engine_test.rb

@@ -3282,6 +3282,26 @@ SASS
       ], e.sass_backtrace)
   end
 
+  def test_mixin_with_args_and_varargs_passed_no_var_args
+    assert_equal <<CSS, render(<<SASS, :syntax => :scss)
+.foo {
+  a: 1;
+  b: 2;
+  c: 3; }
+CSS
+@mixin three-or-more-args($a, $b, $c, $rest...) {
+  a: $a;
+  b: $b;
+  c: $c;
+}
+
+.foo {
+  @include three-or-more-args($a: 1, $b: 2, $c: 3);
+}
+SASS
+
+  end
+
   private
 
   def assert_hash_has(hash, expected)

data/test/sass/functions_test.rb

@@ -1350,6 +1350,12 @@ WARNING
     end
   end
 
+  def test_keywords
+    # The actual functionality is tested in tests where real arglists are passed.
+    assert_error_message("12 is not a variable argument list for `keywords'", "keywords(12)")
+    assert_error_message("(1 2 3) is not a variable argument list for `keywords'", "keywords(1 2 3)")
+  end
+
   def test_partial_list_of_pairs_doesnt_work_as_a_map
     assert_raises(Sass::SyntaxError) {evaluate("map-get((foo bar, baz bang, bip), 1)")}
     assert_raises(Sass::SyntaxError) {evaluate("map-get((foo bar, baz bang, bip bap bop), 1)")}

data/test/sass/scss/scss_test.rb

@@ -954,6 +954,139 @@ CSS
 SCSS
   end
 
+  def test_mixin_var_keyword_args
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  a: 1;
+  b: 2;
+  c: 3; }
+CSS
+@mixin foo($args...) {
+  a: map-get(keywords($args), a);
+  b: map-get(keywords($args), b);
+  c: map-get(keywords($args), c);
+}
+
+.foo {@include foo($a: 1, $b: 2, $c: 3)}
+SCSS
+  end
+
+  def test_mixin_empty_var_keyword_args
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  length: 0; }
+CSS
+@mixin foo($args...) {
+  length: length(keywords($args));
+}
+
+.foo {@include foo}
+SCSS
+  end
+
+  def test_mixin_map_splat
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  a: 1;
+  b: 2;
+  c: 3; }
+CSS
+@mixin foo($a, $b, $c) {
+  a: $a;
+  b: $b;
+  c: $c;
+}
+
+.foo {
+  $map: (a: 1, b: 2, c: 3);
+  @include foo($map...);
+}
+SCSS
+  end
+
+  def test_mixin_map_and_list_splat
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  a: x;
+  b: y;
+  c: z;
+  d: 1;
+  e: 2;
+  f: 3; }
+CSS
+@mixin foo($a, $b, $c, $d, $e, $f) {
+  a: $a;
+  b: $b;
+  c: $c;
+  d: $d;
+  e: $e;
+  f: $f;
+}
+
+.foo {
+  $list: x y z;
+  $map: (d: 1, e: 2, f: 3);
+  @include foo($list..., $map...);
+}
+SCSS
+  end
+
+  def test_mixin_map_splat_takes_precedence_over_pass_through
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  a: 1;
+  b: 2;
+  c: z; }
+CSS
+@mixin foo($args...) {
+  $map: (c: z);
+  @include bar($args..., $map...);
+}
+
+@mixin bar($a, $b, $c) {
+  a: $a;
+  b: $b;
+  c: $c;
+}
+
+.foo {
+  @include foo(1, $b: 2, $c: 3);
+}
+SCSS
+  end
+
+  def test_mixin_list_of_pairs_splat_treated_as_list
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  a: a 1;
+  b: b 2;
+  c: c 3; }
+CSS
+@mixin foo($a, $b, $c) {
+  a: $a;
+  b: $b;
+  c: $c;
+}
+
+.foo {
+  @include foo((a 1, b 2, c 3)...);
+}
+SCSS
+  end
+
+  def test_mixin_keyword_splat_must_have_string_keys
+    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render <<SCSS}
+Variable keyword argument map must have string keys.
+12 is not a string in (12: 1).
+MESSAGE
+@mixin foo($a) {
+  a: $a;
+}
+
+.foo {@include foo((12: 1)...)}
+SCSS
+  end
+
   def test_mixin_var_args_with_keyword
     assert_raise_message(Sass::SyntaxError, "Positional arguments must come before keyword arguments.") {render <<SCSS}
 @mixin foo($a, $b...) {
@@ -987,6 +1120,46 @@ SCSS
 SCSS
   end
 
+  def test_mixin_map_splat_before_list_splat
+    assert_raise_message(Sass::SyntaxError, "Variable keyword arguments must be a map (was (2 3)).") {render <<SCSS}
+@mixin foo($a, $b, $c) {
+  a: $a;
+  b: $b;
+  c: $c;
+}
+
+.foo {
+  @include foo((a: 1)..., (2 3)...);
+}
+SCSS
+  end
+
+  def test_mixin_map_splat_with_unknown_keyword
+    assert_raise_message(Sass::SyntaxError, "Mixin foo doesn't have an argument named $c.") {render <<SCSS}
+@mixin foo($a, $b) {
+  a: $a;
+  b: $b;
+}
+
+.foo {
+  @include foo(1, 2, (c: 1)...);
+}
+SCSS
+  end
+
+  def test_mixin_map_splat_with_wrong_type
+    assert_raise_message(Sass::SyntaxError, "Variable keyword arguments must be a map (was 12).") {render <<SCSS}
+@mixin foo($a, $b) {
+  a: $a;
+  b: $b;
+}
+
+.foo {
+  @include foo((1, 2)..., 12...);
+}
+SCSS
+  end
+
   def test_function_var_args
     assert_equal <<CSS, render(<<SCSS)
 .foo {
@@ -1112,10 +1285,122 @@ CSS
 SCSS
   end
 
+  def test_function_var_keyword_args
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  val: "a: 1, b: 2, c: 3"; }
+CSS
+@function foo($args...) {
+  @return "a: \#{map-get(keywords($args), a)}, " +
+    "b: \#{map-get(keywords($args), b)}, " +
+    "c: \#{map-get(keywords($args), c)}";
+}
+
+.foo {val: foo($a: 1, $b: 2, $c: 3)}
+SCSS
+  end
+
+  def test_function_empty_var_keyword_args
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  length: 0; }
+CSS
+@function foo($args...) {
+  @return length(keywords($args));
+}
+
+.foo {length: foo()}
+SCSS
+  end
+
+  def test_function_map_splat
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  val: "a: 1, b: 2, c: 3"; }
+CSS
+@function foo($a, $b, $c) {
+  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
+}
+
+.foo {
+  $map: (a: 1, b: 2, c: 3);
+  val: foo($map...);
+}
+SCSS
+  end
+
+  def test_function_map_and_list_splat
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  val: "a: x, b: y, c: z, d: 1, e: 2, f: 3"; }
+CSS
+@function foo($a, $b, $c, $d, $e, $f) {
+  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}, d: \#{$d}, e: \#{$e}, f: \#{$f}";
+}
+
+.foo {
+  $list: x y z;
+  $map: (d: 1, e: 2, f: 3);
+  val: foo($list..., $map...);
+}
+SCSS
+  end
+
+  def test_function_map_splat_takes_precedence_over_pass_through
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  val: "a: 1, b: 2, c: z"; }
+CSS
+@function foo($args...) {
+  $map: (c: z);
+  @return bar($args..., $map...);
+}
+
+@function bar($a, $b, $c) {
+  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
+}
+
+.foo {
+  val: foo(1, $b: 2, $c: 3);
+}
+SCSS
+  end
+
+  def test_ruby_function_map_splat_takes_precedence_over_pass_through
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  val: 1 2 3 z; }
+CSS
+@function foo($args...) {
+  $map: (val: z);
+  @return append($args..., $map...);
+}
+
+.foo {
+  val: foo(1 2 3, $val: 4)
+}
+SCSS
+  end
+
+  def test_function_list_of_pairs_splat_treated_as_list
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  val: "a: a 1, b: b 2, c: c 3"; }
+CSS
+@function foo($a, $b, $c) {
+  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
+}
+
+.foo {
+  val: foo((a 1, b 2, c 3)...);
+}
+SCSS
+  end
+
   def test_function_var_args_with_keyword
     assert_raise_message(Sass::SyntaxError, "Positional arguments must come before keyword arguments.") {render <<SCSS}
 @function foo($a, $b...) {
-  @return "a: \#{$a}, b: $b";
+  @return "a: \#{$a}, b: \#{$b}";
 }
 
 .foo {val: foo($a: 1, 2, 3, 4)}
@@ -1135,7 +1420,7 @@ SCSS
   def test_function_keyword_for_unknown_arg_with_var_args
     assert_raise_message(Sass::SyntaxError, "Function foo doesn't have an argument named $c.") {render <<SCSS}
 @function foo($a, $b...) {
-  @return "a: \#{$a}, b: \#{$b}";
+  @return "a: \#{$a}, b: \#{length($b)}";
 }
 
 .foo {val: foo(1, $c: 2 3 4)}
@@ -1155,6 +1440,55 @@ CSS
 SCSS
   end
 
+  def test_function_map_splat_before_list_splat
+    assert_raise_message(Sass::SyntaxError, "Variable keyword arguments must be a map (was (2 3)).") {render <<SCSS}
+@function foo($a, $b, $c) {
+  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
+}
+
+.foo {
+  val: foo((a: 1)..., (2 3)...);
+}
+SCSS
+  end
+
+  def test_function_map_splat_with_unknown_keyword
+    assert_raise_message(Sass::SyntaxError, "Function foo doesn't have an argument named $c.") {render <<SCSS}
+@function foo($a, $b) {
+  @return "a: \#{$a}, b: \#{$b}";
+}
+
+.foo {
+  val: foo(1, 2, (c: 1)...);
+}
+SCSS
+  end
+
+  def test_function_map_splat_with_wrong_type
+    assert_raise_message(Sass::SyntaxError, "Variable keyword arguments must be a map (was 12).") {render <<SCSS}
+@function foo($a, $b) {
+  @return "a: \#{$a}, b: \#{$b}";
+}
+
+.foo {
+  val: foo((1, 2)..., 12...);
+}
+SCSS
+  end
+
+  def test_function_keyword_splat_must_have_string_keys
+    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render <<SCSS}
+Variable keyword argument map must have string keys.
+12 is not a string in (12: 1).
+MESSAGE
+@function foo($a) {
+  @return $a;
+}
+
+.foo {val: foo((12: 1)...)}
+SCSS
+  end
+
   ## Interpolation
 
   def test_basic_selector_interpolation

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  hash: 592302839
+  hash: 592302835
   prerelease: 6
   segments: 
   - 3
   - 3
   - 0
   - alpha
-  - 253
-  version: 3.3.0.alpha.253
+  - 255
+  version: 3.3.0.alpha.255
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -19,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-09-06 00:00:00 -04:00
+date: 2013-09-18 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -129,10 +129,10 @@ files:
 - lib/sass/script/tree/map_literal.rb
 - lib/sass/script/tree/node.rb
 - lib/sass/script/tree/operation.rb
+- lib/sass/script/tree/selector.rb
 - lib/sass/script/tree/string_interpolation.rb
 - lib/sass/script/tree/unary_operation.rb
 - lib/sass/script/tree/variable.rb
-- lib/sass/script/tree/selector.rb
 - lib/sass/script/value.rb
 - lib/sass/script/value/arg_list.rb
 - lib/sass/script/value/base.rb
@@ -159,18 +159,18 @@ files:
 - lib/sass/shared.rb
 - lib/sass/supports.rb
 - lib/sass/version.rb
-- lib/sass/tree/charset_node.rb
 - lib/sass/tree/comment_node.rb
+- lib/sass/tree/charset_node.rb
+- lib/sass/tree/debug_node.rb
 - lib/sass/tree/content_node.rb
 - lib/sass/tree/css_import_node.rb
-- lib/sass/tree/debug_node.rb
 - lib/sass/tree/directive_node.rb
 - lib/sass/tree/each_node.rb
 - lib/sass/tree/extend_node.rb
 - lib/sass/tree/for_node.rb
 - lib/sass/tree/function_node.rb
-- lib/sass/tree/if_node.rb
 - lib/sass/tree/import_node.rb
+- lib/sass/tree/if_node.rb
 - lib/sass/tree/media_node.rb
 - lib/sass/tree/mixin_def_node.rb
 - lib/sass/tree/mixin_node.rb
@@ -179,9 +179,10 @@ files:
 - lib/sass/tree/return_node.rb
 - lib/sass/tree/root_node.rb
 - lib/sass/tree/rule_node.rb
-- lib/sass/tree/supports_node.rb
 - lib/sass/tree/trace_node.rb
+- lib/sass/tree/supports_node.rb
 - lib/sass/tree/variable_node.rb
+- lib/sass/tree/warn_node.rb
 - lib/sass/tree/visitors/base.rb
 - lib/sass/tree/visitors/check_nesting.rb
 - lib/sass/tree/visitors/convert.rb
@@ -191,7 +192,6 @@ files:
 - lib/sass/tree/visitors/perform.rb
 - lib/sass/tree/visitors/set_options.rb
 - lib/sass/tree/visitors/to_css.rb
-- lib/sass/tree/warn_node.rb
 - lib/sass/tree/while_node.rb
 - lib/sass/tree/at_root_node.rb
 - lib/sass/source/map.rb