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

data/lib/sass/scss/parser.rb

@@ -170,16 +170,16 @@ module Sass
 
       def mixin_directive
         name = tok! IDENT
-        args = sass_script(:parse_mixin_definition_arglist)
+        args, splat = sass_script(:parse_mixin_definition_arglist)
         ss
-        block(node(Sass::Tree::MixinDefNode.new(name, args)), :directive)
+        block(node(Sass::Tree::MixinDefNode.new(name, args, splat)), :directive)
       end
 
       def include_directive
         name = tok! IDENT
-        args, keywords = sass_script(:parse_mixin_include_arglist)
+        args, keywords, splat = sass_script(:parse_mixin_include_arglist)
         ss
-        include_node = node(Sass::Tree::MixinNode.new(name, args, keywords))
+        include_node = node(Sass::Tree::MixinNode.new(name, args, keywords, splat))
         if tok?(/\{/)
           include_node.has_children = true
           block(include_node, :directive)
@@ -195,9 +195,9 @@ module Sass
 
       def function_directive
         name = tok! IDENT
-        args = sass_script(:parse_function_definition_arglist)
+        args, splat = sass_script(:parse_function_definition_arglist)
         ss
-        block(node(Sass::Tree::FunctionNode.new(name, args)), :function)
+        block(node(Sass::Tree::FunctionNode.new(name, args, splat)), :function)
       end
 
       def return_directive

data/lib/sass/tree/function_node.rb

@@ -15,11 +15,18 @@ module Sass
       # @return [Array<Script::Node>]
       attr_accessor :args
 
+      # The splat argument for this function, if one exists.
+      #
+      # @return [Script::Node?]
+      attr_accessor :splat
+
       # @param name [String] The function name
       # @param args [Array<(Script::Node, Script::Node)>] The arguments for the function.
-      def initialize(name, args)
+      # @param splat [Script::Node] See \{#splat}
+      def initialize(name, args, splat)
         @name = name
         @args = args
+        @splat = splat
         super()
       end
     end

data/lib/sass/tree/mixin_def_node.rb

@@ -15,15 +15,22 @@ module Sass
       # @return [Array<(Script::Node, Script::Node)>]
       attr_accessor :args
 
+      # The splat argument for this mixin, if one exists.
+      #
+      # @return [Script::Node?]
+      attr_accessor :splat
+
       # Whether the mixin uses `@content`. Set during the nesting check phase.
       # @return [Boolean]
       attr_accessor :has_content
 
       # @param name [String] The mixin name
       # @param args [Array<(Script::Node, Script::Node)>] See \{#args}
-      def initialize(name, args)
+      # @param splat [Script::Node] See \{#splat}
+      def initialize(name, args, splat)
         @name = name
         @args = args
+        @splat = splat
         super()
       end
     end

data/lib/sass/tree/mixin_node.rb

@@ -19,13 +19,20 @@ module Sass::Tree
     # @return [{String => Script::Node}]
     attr_accessor :keywords
 
+    # The splat argument for this mixin, if one exists.
+    #
+    # @return [Script::Node?]
+    attr_accessor :splat
+
     # @param name [String] The name of the mixin
     # @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
   end

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

@@ -121,6 +121,10 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     args = node.args.map do |v, d|
       d ? "#{v.to_sass(@options)}: #{d.to_sass(@options)}" : v.to_sass(@options)
     end.join(", ")
+    if node.splat
+      args << ", " unless node.args.empty?
+      args << node.splat.to_sass(@options) << "..."
+    end
 
     "#{tab_str}@function #{dasherize(node.name)}(#{args})#{yield}"
   end
@@ -167,27 +171,39 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
 
   def visit_mixindef(node)
     args =
-      if node.args.empty?
+      if node.args.empty? && node.splat.nil?
         ""
       else
-        '(' + node.args.map do |v, d|
+        str = '('
+        str << node.args.map do |v, d|
           if d
             "#{v.to_sass(@options)}: #{d.to_sass(@options)}"
           else
             v.to_sass(@options)
           end
-        end.join(", ") + ')'
+        end.join(", ")
+
+        if node.splat
+          str << ", " unless node.args.empty?
+          str << node.splat.to_sass(@options) << '...'
+        end
+
+        str << ')'
       end
-          
+
     "#{tab_str}#{@format == :sass ? '=' : '@mixin '}#{dasherize(node.name)}#{args}#{yield}"
   end
 
   def visit_mixin(node)
-    unless node.args.empty? && node.keywords.empty?
+    unless node.args.empty? && node.keywords.empty? && node.splat.nil?
       args = node.args.map {|a| a.to_sass(@options)}.join(", ")
       keywords = Sass::Util.hash_to_a(node.keywords).
         map {|k, v| "$#{dasherize(k)}: #{v.to_sass(@options)}"}.join(', ')
-      arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
+      if node.splat
+        splat = (args.empty? && keywords.empty?) ? "" : ", "
+        splat = "#{splat}#{node.splat.to_sass(@options)}..."
+      end
+      arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
     end
     "#{tab_str}#{@format == :sass ? '+' : '@include '}#{dasherize(node.name)}#{arglist}#{node.has_children ? yield : semi}\n"
   end

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

@@ -7,6 +7,83 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     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}"
+
+    begin
+      unless keywords.empty?
+        unknown_args = 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?
+          raise Sass::SyntaxError.new("#{desc} doesn't have #{unknown_args.length > 1 ? 'the following arguments:' : 'an argument named'} #{unknown_args.map{|name| "$#{name}"}.join ', '}.")
+        end
+      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 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::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::ArgList)
+    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
+
+    if callable.splat
+      rest = args[callable.args.length..-1]
+      arg_list = Sass::Script::ArgList.new(rest, keywords.dup, splat_sep)
+      arg_list.options = env.options
+      env.set_local_var(callable.splat.name, arg_list)
+    end
+
+    yield env
+  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) &&
+        ($!.nil? || $!.is_a?(Sass::SyntaxError))
+      raise keyword_exception
+    elsif $!
+      raise $!
+    end
+  end
+
   protected
 
   def initialize(env)
@@ -114,7 +191,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   def visit_function(node)
     env = Sass::Environment.new(@environment, node.options)
     @environment.set_local_function(node.name,
-      Sass::Callable.new(node.name, node.args, env, node.children, !:has_content))
+      Sass::Callable.new(node.name, node.args, node.splat, env, node.children, !:has_content, "function"))
     []
   end
 
@@ -157,7 +234,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   def visit_mixindef(node)
     env = Sass::Environment.new(@environment, node.options)
     @environment.set_local_mixin(node.name,
-      Sass::Callable.new(node.name, node.args, env, node.children, node.has_content))
+      Sass::Callable.new(node.name, node.args, node.splat, env, node.children, node.has_content, "mixin"))
     []
   end
 
@@ -174,40 +251,18 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
       raise Sass::SyntaxError.new(%Q{Mixin "#{node.name}" does not accept a content block.})
     end
 
-    passed_args = node.args.dup
-    passed_keywords = node.keywords.dup
+    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
 
-    raise Sass::SyntaxError.new(<<END.gsub("\n", "")) if mixin.args.size < passed_args.size
-Mixin #{node.name} takes #{mixin.args.size} argument#{'s' if mixin.args.size != 1}
- but #{node.args.size} #{node.args.size == 1 ? 'was' : 'were'} passed.
-END
+    self.class.perform_arguments(mixin, args, keywords, splat) do |env|
+      env.caller = Sass::Environment.new(@environment)
+      env.content = node.children if node.has_children
 
-    passed_keywords.each do |name, value|
-      # TODO: Make this fast
-      unless mixin.args.find {|(var, default)| var.underscored_name == name}
-        raise Sass::SyntaxError.new("Mixin #{node.name} doesn't have an argument named $#{name}")
-      end
-    end
-
-    environment = mixin.args.zip(passed_args).
-      inject(Sass::Environment.new(mixin.environment)) do |env, ((var, default), value)|
-      env.set_local_var(var.name,
-        if value
-          value.perform(@environment)
-        elsif kv = passed_keywords[var.underscored_name]
-          kv.perform(@environment)
-        elsif default
-          default.perform(env)
-        end)
-      raise Sass::SyntaxError.new("Mixin #{node.name} is missing argument #{var.inspect}.") unless env.var(var.name)
-      env
+      trace_node = Sass::Tree::TraceNode.from_node(node.name, node)
+      with_environment(env) {trace_node.children = mixin.tree.map {|c| visit(c)}.flatten}
+      trace_node
     end
-    environment.caller = Sass::Environment.new(@environment)
-    environment.content = node.children if node.has_children
-
-    trace_node = Sass::Tree::TraceNode.from_node(node.name, node)
-    with_environment(environment) {trace_node.children = mixin.tree.map {|c| visit(c)}.flatten}
-    trace_node
   rescue Sass::SyntaxError => e
     unless include_loop
       e.modify_backtrace(:mixin => node.name, :line => node.line)

data/test/sass/conversion_test.rb

@@ -1562,6 +1562,60 @@ foo {
 SCSS
   end
 
+  def test_mixin_var_args
+    assert_scss_to_sass <<SASS, <<SCSS
+=foo($args...)
+  a: b
+
+=bar($a, $args...)
+  a: b
+
+.foo
+  +foo($list...)
+  +bar(1, $list...)
+SASS
+@mixin foo($args...) {
+  a: b;
+}
+
+@mixin bar($a, $args...) {
+  a: b;
+}
+
+.foo {
+  @include foo($list...);
+  @include bar(1, $list...);
+}
+SCSS
+  end
+
+  def test_function_var_args
+    assert_scss_to_sass <<SASS, <<SCSS
+@function foo($args...)
+  @return foo
+
+@function bar($a, $args...)
+  @return bar
+
+.foo
+  a: foo($list...)
+  b: bar(1, $list...)
+SASS
+@function foo($args...) {
+  @return foo;
+}
+
+@function bar($a, $args...) {
+  @return bar;
+}
+
+.foo {
+  a: foo($list...);
+  b: bar(1, $list...);
+}
+SCSS
+  end
+
   ## Regression Tests
 
   def test_media_query_with_expr

data/test/sass/engine_test.rb

@@ -93,7 +93,7 @@ MSG
     "a-\#{$b\n  c: d" => ['Invalid CSS after "a-#{$b": expected "}", was ""', 1],
     "=a($b: 1, $c)" => "Required argument $c must come before any optional arguments.",
     "=a($b: 1)\n  a: $b\ndiv\n  +a(1,2)" => "Mixin a takes 1 argument but 2 were passed.",
-    "=a($b: 1)\n  a: $b\ndiv\n  +a(1,$c: 3)" => "Mixin a doesn't have an argument named $c",
+    "=a($b: 1)\n  a: $b\ndiv\n  +a(1,$c: 3)" => "Mixin a doesn't have an argument named $c.",
     "=a($b)\n  a: $b\ndiv\n  +a" => "Mixin a is missing argument $b.",
     "@function foo()\n  1 + 2" => "Functions can only contain variable declarations and control directives.",
     "@function foo()\n  foo: bar" => "Functions can only contain variable declarations and control directives.",
@@ -105,10 +105,10 @@ MSG
     "@function foo($)\n  @return 1" => ['Invalid CSS after "(": expected variable (e.g. $foo), was "$)"', 1],
     "@function foo()\n  @return" => 'Invalid @return: expected expression.',
     "@function foo()\n  @return 1\n    $var: val" => 'Illegal nesting: Nothing may be nested beneath return directives.',
-    "@function foo($a)\n  @return 1\na\n  b: foo()" => 'Function foo is missing argument $a',
-    "@function foo()\n  @return 1\na\n  b: foo(2)" => 'Wrong number of arguments (1 for 0) for `foo\'',
-    "@function foo()\n  @return 1\na\n  b: foo($a: 1)" => "Function foo doesn't have an argument named $a",
-    "@function foo()\n  @return 1\na\n  b: foo($a: 1, $b: 2)" => "Function foo doesn't have the following arguments: $a, $b",
+    "@function foo($a)\n  @return 1\na\n  b: foo()" => 'Function foo is missing argument $a.',
+    "@function foo()\n  @return 1\na\n  b: foo(2)" => 'Function foo takes 0 arguments but 1 was passed.',
+    "@function foo()\n  @return 1\na\n  b: foo($a: 1)" => "Function foo doesn't have an argument named $a.",
+    "@function foo()\n  @return 1\na\n  b: foo($a: 1, $b: 2)" => "Function foo doesn't have the following arguments: $a, $b.",
     "@return 1" => '@return may only be used within a function.',
     "@if true\n  @return 1" => '@return may only be used within a function.',
     "@mixin foo\n  @return 1\n@include foo" => ['@return may only be used within a function.', 2],
@@ -122,7 +122,7 @@ MSG
     '@for $a from "foo" to 1' => '"foo" is not an integer.',
     '@for $a from 1 to "2"' => '"2" is not an integer.',
     '@for $a from 1 to "foo"' => '"foo" is not an integer.',
-    '@for $a from 1 to 1.232323' => '1.232 is not an integer.',
+    '@for $a from 1 to 1.232323' => '1.23232 is not an integer.',
     '@for $a from 1px to 3em' => "Incompatible units: 'em' and 'px'.",
     '@if' => "Invalid if directive '@if': expected expression.",
     '@while' => "Invalid while directive '@while': expected expression.",
@@ -1294,7 +1294,7 @@ bar
 SASS
     flunk("Expected exception")
   rescue Sass::SyntaxError => e
-    assert_equal("Function plus is missing argument $var1", e.message)
+    assert_equal("Function plus is missing argument $var1.", e.message)
   end
 
   def test_function_with_extra_argument
@@ -1307,7 +1307,7 @@ bar
 SASS
     flunk("Expected exception")
   rescue Sass::SyntaxError => e
-    assert_equal("Function plus doesn't have an argument named $var3", e.message)
+    assert_equal("Function plus doesn't have an argument named $var3.", e.message)
   end
 
   def test_function_with_positional_and_keyword_argument
@@ -1320,7 +1320,7 @@ bar
 SASS
     flunk("Expected exception")
   rescue Sass::SyntaxError => e
-    assert_equal("Function plus was passed argument $var2 both by position and by name", e.message)
+    assert_equal("Function plus was passed argument $var2 both by position and by name.", e.message)
   end
 
   def test_function_with_keyword_before_positional_argument
@@ -1333,7 +1333,7 @@ bar
 SASS
     flunk("Expected exception")
   rescue Sass::SyntaxError => e
-    assert_equal("Positional arguments must come before keyword arguments", e.message)
+    assert_equal("Positional arguments must come before keyword arguments.", e.message)
   end
 
   def test_function_with_if
@@ -1759,7 +1759,7 @@ SASS
 
   def test_loud_comment_is_evaluated
     assert_equal <<CSS, render(<<SASS)
-/* Hue: 327.216deg */
+/* Hue: 327.21649deg */
 CSS
 /*!
   Hue: \#{hue(#f836a0)}
@@ -2872,11 +2872,13 @@ SCSS
   end
 
   def test_deprecated_PRECISION
-    assert_warning(<<END) {assert_equal 1000.0, Sass::Script::Number::PRECISION}
+    assert_warning(<<END) {assert_equal 100_000.0, Sass::Script::Number::PRECISION}
 Sass::Script::Number::PRECISION is deprecated and will be removed in a future release. Use Sass::Script::Number.precision_factor instead.
 END
   end
+
   def test_changing_precision
+    old_precision = Sass::Script::Number.precision
     begin
       Sass::Script::Number.precision = 8
       assert_equal <<CSS, render(<<SASS)
@@ -2889,7 +2891,7 @@ div
   too-much: 1.000000001
 SASS
     ensure
-      Sass::Script::Number.precision = 3
+      Sass::Script::Number.precision = old_precision
     end
   end