sass 3.3.0.alpha.378 → 3.3.0.alpha.380

data/REVISION

@@ -1 +1 @@
-af904635d4da0719e029b715cd2acb9fa6446b0a
+898bec6bfb7fa4ce8a1ca8e2ff210387c7f98f0e

data/VERSION

@@ -1 +1 @@
-3.3.0.alpha.378
+3.3.0.alpha.380

data/VERSION_DATE

@@ -1 +1 @@
-11 October 2013 21:25:34 GMT
+11 October 2013 22:11:57 GMT

data/lib/sass/script/parser.rb

@@ -437,6 +437,7 @@ RUBY
 
         return [args, keywords] unless e
 
+        splat = nil
         loop do
           if @lexer.peek && @lexer.peek.type == :colon
             name = e
@@ -450,21 +451,19 @@ RUBY
 
             keywords[name.name] = value
           else
-            unless keywords.empty?
+            if try_tok(:splat)
+              return args, keywords, splat, e if splat
+              splat, e = e, nil
+            elsif splat
+              raise SyntaxError.new("Only keyword arguments may follow variable arguments (...).")
+            elsif !keywords.empty?
               raise SyntaxError.new("Positional arguments must come before keyword arguments.")
             end
 
-            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
+            args << e if e
           end
 
-          return args, keywords unless try_tok(:comma)
+          return args, keywords, splat unless try_tok(:comma)
           e = assert_expr(subexpr, description)
         end
       end

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

@@ -76,17 +76,18 @@ module Sass::Script::Tree
         sass
       end
 
-      args = @args.map(&arg_to_sass).join(', ')
+      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]}"}.join(', ')
+        map {|k, v| "$#{dasherize(k, opts)}: #{arg_to_sass[v]}"}
+
       # rubocop:disable RedundantSelf
       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
+        splat = "#{arg_to_sass[self.splat]}..."
+        kwarg_splat = "#{arg_to_sass[self.kwarg_splat]}..." if self.kwarg_splat
       end
       # rubocop:enable RedundantSelf
-      arglist = "#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat}"
+
+      arglist = [args, splat, keywords, kwarg_splat].flatten.compact.join(', ')
       "#{dasherize(name, opts)}(#{arglist})"
     end
 
@@ -121,16 +122,16 @@ module Sass::Script::Tree
     def _perform(environment)
       args = Sass::Util.enum_with_index(@args).
         map {|a, i| perform_arg(a, environment, signature && signature.args[i])}
-      splat = Sass::Tree::Visitors::Perform.perform_splat(@splat, @kwarg_splat, environment)
       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, keywords, splat, environment)
+        return perform_sass_fn(fn, args, splat, environment)
       end
 
-      ruby_name = @name.tr('-', '_')
-      args = construct_ruby_args(ruby_name, args, keywords, splat, environment)
+      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)
@@ -141,54 +142,7 @@ module Sass::Script::Tree
         opts(to_literal(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}'")
+      reformat_argument_error(e)
     end
 
     # Compass historically overrode this before it changed name to {Funcall#to_value}.
@@ -206,6 +160,10 @@ module Sass::Script::Tree
 
     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)
@@ -215,15 +173,14 @@ module Sass::Script::Tree
       @signature ||= Sass::Script::Functions.signature(name.to_sym, @args.size, @keywords.size)
     end
 
-    def construct_ruby_args(name, args, keywords, splat, environment)
+    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 && !splat.keywords.empty?
-        old_keywords_accessed = splat.keywords_accessed
-        keywords = splat.keywords
-        splat.keywords_accessed = old_keywords_accessed
-      end
+      # 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?
@@ -267,8 +224,8 @@ module Sass::Script::Tree
       args
     end
 
-    def perform_sass_fn(function, args, keywords, splat, environment)
-      Sass::Tree::Visitors::Perform.perform_arguments(function, args, keywords, splat) do |env|
+    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
@@ -278,5 +235,56 @@ module Sass::Script::Tree
         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/tree/visitors/convert.rb

@@ -206,15 +206,16 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     end
 
     unless node.args.empty? && node.keywords.empty? && node.splat.nil?
-      args = node.args.map(&arg_to_sass).join(", ")
+      args = node.args.map(&arg_to_sass)
       keywords = Sass::Util.hash_to_a(node.keywords).
-        map {|k, v| "$#{dasherize(k)}: #{arg_to_sass[v]}"}.join(', ')
+        map {|k, v| "$#{dasherize(k)}: #{arg_to_sass[v]}"}
+
       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
+        splat = "#{arg_to_sass[node.splat]}..."
+        kwarg_splat = "#{arg_to_sass[node.kwarg_splat]}..." if node.kwarg_splat
       end
-      arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
+
+      arglist = "(#{[args, splat, keywords, kwarg_splat].flatten.compact.join(', ')})"
     end
     "#{tab_str}#{@format == :sass ? '+' : '@include '}" +
       "#{dasherize(node.name)}#{arglist}#{node.has_children ? yield : semi}\n"

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

@@ -11,16 +11,15 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     # @api private
     # @comment
     #   rubocop:disable MethodLength
-    def perform_arguments(callable, args, keywords, splat)
+    def perform_arguments(callable, args, splat)
       desc = "#{callable.type.capitalize} #{callable.name}"
       downcase_desc = "#{callable.type} #{callable.name}"
 
-      # 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
+      # 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
 
       begin
         unless keywords.empty?
@@ -99,33 +98,34 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
     # @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 = []
+    def perform_splat(splat, performed_keywords, kwarg_splat, environment)
+      args, kwargs, separator = [], Sass::Util.ordered_hash, :comma
+
+      if splat
+        splat = splat.perform(environment)
+        separator = splat.separator || separator
+        if splat.is_a?(Sass::Script::Value::ArgList)
+          args = splat.to_a
+          kwargs = splat.keywords
+        elsif splat.is_a?(Sass::Script::Value::Map)
           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
+      kwargs = kwargs.merge(performed_keywords)
 
-      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)
+      if kwarg_splat
+        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
+        kwargs = kwargs.merge(arg_hash(kwarg_splat))
       end
+
+      Sass::Script::Value::ArgList.new(args, kwargs, separator)
     end
 
     private
@@ -326,9 +326,9 @@ 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 = self.class.perform_splat(node.splat, node.kwarg_splat, @environment)
+      splat = self.class.perform_splat(node.splat, keywords, node.kwarg_splat, @environment)
 
-      self.class.perform_arguments(mixin, args, keywords, splat) do |env|
+      self.class.perform_arguments(mixin, args, splat) do |env|
         env.caller = Sass::Environment.new(@environment)
         env.content = [node.children, @environment] if node.has_children
 

data/test/sass/conversion_test.rb

@@ -1629,6 +1629,7 @@ SCSS
 
 .foo
   +foo($list..., $map...)
+  +foo(pos, $list..., $kwd: val, $map...)
 SASS
 @mixin foo($a: b, $c: d) {
   a: $a;
@@ -1637,6 +1638,7 @@ SASS
 
 .foo {
   @include foo($list..., $map...);
+  @include foo(pos, $list..., $kwd: val, $map...);
 }
 SCSS
   end
@@ -1675,6 +1677,7 @@ SCSS
 
 .foo
   a: foo($list..., $map...)
+  b: foo(pos, $list..., $kwd: val, $map...)
 SASS
 @function foo($a: b, $c: d) {
   @return foo;
@@ -1682,6 +1685,7 @@ SASS
 
 .foo {
   a: foo($list..., $map...);
+  b: foo(pos, $list..., $kwd: val, $map...);
 }
 SCSS
   end

data/test/sass/scss/scss_test.rb

@@ -1074,6 +1074,108 @@ CSS
 SCSS
   end
 
+  def test_mixin_splat_after_keyword_args
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  a: 1;
+  b: 2;
+  c: 3; }
+CSS
+@mixin foo($a, $b, $c) {
+  a: 1;
+  b: 2;
+  c: 3;
+}
+
+.foo {
+  @include foo(1, $c: 3, 2...);
+}
+SCSS
+  end
+
+  def test_mixin_keyword_args_after_splat
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  a: 1;
+  b: 2;
+  c: 3; }
+CSS
+@mixin foo($a, $b, $c) {
+  a: 1;
+  b: 2;
+  c: 3;
+}
+
+.foo {
+  @include foo(1, 2..., $c: 3);
+}
+SCSS
+  end
+
+  def test_mixin_keyword_splat_after_keyword_args
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  a: 1;
+  b: 2;
+  c: 3; }
+CSS
+@mixin foo($a, $b, $c) {
+  a: 1;
+  b: 2;
+  c: 3;
+}
+
+.foo {
+  @include foo(1, $b: 2, (c: 3)...);
+}
+SCSS
+  end
+
+  def test_mixin_triple_keyword_splat_merge
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  foo: 1;
+  bar: 2;
+  kwarg: 3;
+  a: 3;
+  b: 2;
+  c: 3; }
+CSS
+@mixin foo($foo, $bar, $kwarg, $a, $b, $c) {
+  foo: $foo;
+  bar: $bar;
+  kwarg: $kwarg;
+  a: $a;
+  b: $b;
+  c: $c;
+}
+
+@mixin bar($args...) {
+  @include foo($args..., $bar: 2, $a: 2, $b: 2, (kwarg: 3, a: 3, c: 3)...);
+}
+
+.foo {
+  @include bar($foo: 1, $a: 1, $b: 1, $c: 1);
+}
+SCSS
+  end
+
+  def test_mixin_conflicting_splat_after_keyword_args
+    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render(<<SCSS)}
+Mixin foo was passed argument $b both by position and by name.
+MESSAGE
+@mixin foo($a, $b, $c) {
+  a: 1;
+  b: 2;
+  c: 3;
+}
+
+.foo {
+  @include foo(1, $b: 2, 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.
@@ -1087,6 +1189,22 @@ MESSAGE
 SCSS
   end
 
+  def test_mixin_positional_arg_after_splat
+    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render(<<SCSS)}
+Only keyword arguments may follow variable arguments (...).
+MESSAGE
+@mixin foo($a, $b, $c) {
+  a: 1;
+  b: 2;
+  c: 3;
+}
+
+.foo {
+  @include foo(1, 2..., 3);
+}
+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...) {
@@ -1397,6 +1515,98 @@ CSS
 SCSS
   end
 
+  def test_function_splat_after_keyword_args
+    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 {
+  val: foo(1, $c: 3, 2...);
+}
+SCSS
+  end
+
+  def test_function_keyword_args_after_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 {
+  val: foo(1, 2..., $c: 3);
+}
+SCSS
+  end
+
+  def test_function_keyword_splat_after_keyword_args
+    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 {
+  val: foo(1, $b: 2, (c: 3)...);
+}
+SCSS
+  end
+
+  def test_function_triple_keyword_splat_merge
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  val: "foo: 1, bar: 2, kwarg: 3, a: 3, b: 2, c: 3"; }
+CSS
+@function foo($foo, $bar, $kwarg, $a, $b, $c) {
+  @return "foo: \#{$foo}, bar: \#{$bar}, kwarg: \#{$kwarg}, a: \#{$a}, b: \#{$b}, c: \#{$c}";
+}
+
+@function bar($args...) {
+  @return foo($args..., $bar: 2, $a: 2, $b: 2, (kwarg: 3, a: 3, c: 3)...);
+}
+
+.foo {
+  val: bar($foo: 1, $a: 1, $b: 1, $c: 1);
+}
+SCSS
+  end
+
+  def test_function_conflicting_splat_after_keyword_args
+    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render(<<SCSS)}
+Function foo was passed argument $b both by position and by name.
+MESSAGE
+@function foo($a, $b, $c) {
+  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
+}
+
+.foo {
+  val: foo(1, $b: 2, 3...);
+}
+SCSS
+  end
+
+  def test_function_positional_arg_after_splat
+    assert_raise_message(Sass::SyntaxError, <<MESSAGE.rstrip) {render(<<SCSS)}
+Only keyword arguments may follow variable arguments (...).
+MESSAGE
+@function foo($a, $b, $c) {
+  @return "a: \#{$a}, b: \#{$b}, c: \#{$c}";
+}
+
+.foo {
+  val: foo(1, 2..., 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...) {

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  hash: 592302585
+  hash: 592302581
   prerelease: 6
   segments: 
   - 3
   - 3
   - 0
   - alpha
-  - 378
-  version: 3.3.0.alpha.378
+  - 380
+  version: 3.3.0.alpha.380
 platform: ruby
 authors: 
 - Nathan Weizenbaum