sass 3.1.0.alpha.23 → 3.1.0.alpha.24

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-3.1.0.alpha.23
+3.1.0.alpha.24

data/VERSION

@@ -1 +1 @@
-3.1.0.alpha.23
+3.1.0.alpha.24

data/lib/sass/engine.rb

@@ -14,6 +14,7 @@ require 'sass/tree/extend_node'
 require 'sass/tree/if_node'
 require 'sass/tree/while_node'
 require 'sass/tree/for_node'
+require 'sass/tree/each_node'
 require 'sass/tree/debug_node'
 require 'sass/tree/warn_node'
 require 'sass/tree/import_node'
@@ -610,6 +611,8 @@ WARNING
         parse_mixin_include(line, root)
       elsif directive == "for"
         parse_for(line, root, value)
+      elsif directive == "each"
+        parse_each(line, root, value)
       elsif directive == "else"
         parse_else(parent, line, value)
       elsif directive == "while"
@@ -671,6 +674,27 @@ WARNING
       Tree::ForNode.new(var, parsed_from, parsed_to, to_name == 'to')
     end
 
+    def parse_each(line, root, text)
+      var, list_expr = text.scan(/^([^\s]+)\s+in\s+(.+)$/).first
+
+      if var.nil? # scan failed, try to figure out why for error message
+        if text !~ /^[^\s]+/
+          expected = "variable name"
+        elsif text !~ /^[^\s]+\s+from\s+.+/
+          expected = "'in <expr>'"
+        end
+        raise SyntaxError.new("Invalid for directive '@each #{text}': expected #{expected}.")
+      end
+      raise SyntaxError.new("Invalid variable \"#{var}\".") unless var =~ Script::VALIDATE
+      if var.slice!(0) == ?!
+        offset = line.offset + line.text.index("!" + var) + 1
+        Script.var_warning(var, @line, offset, @options[:filename])
+      end
+
+      parsed_list = parse_script(list_expr, :offset => line.offset + line.text.index(list_expr))
+      Tree::EachNode.new(var, parsed_list)
+    end
+
     def parse_else(parent, line, text)
       previous = parent.children.last
       raise SyntaxError.new("@else must come after @if.") unless previous.is_a?(Tree::IfNode)

data/lib/sass/less.rb

@@ -251,7 +251,7 @@ WARNING
         e, rest = _to_sass_tree_plus_minus_eq(arr)
         until rest.empty?
           e2, rest = _to_sass_tree_plus_minus_eq(rest)
-          e = Sass::Script::Operation.new(e, e2, :concat)
+          e = Sass::Script::Operation.new(e, e2, :space)
         end
         return e
       end

data/lib/sass/script/css_parser.rb

@@ -22,7 +22,7 @@ module Sass
       end
 
       # Short-circuit all the SassScript-only productions
-      alias_method :interpolation, :concat
+      alias_method :interpolation, :space
       alias_method :or_expr, :div
       alias_method :unary_div, :ident
       alias_method :paren, :string

data/lib/sass/script/functions.rb

@@ -113,6 +113,17 @@ module Sass::Script
   # \{#abs abs($value)}
   # : Returns the absolute value of a number.
   #
+  # ## List Functions {#list-functions}
+  #
+  # \{#length length($list)}
+  # : Returns the length of a list.
+  #
+  # \{#nth nth($list, $n)}
+  # : Returns a specific item in a list.
+  #
+  # \{#join join($list1, $list2, \[$separator\])}
+  # : Joins together two lists into one.
+  #
   # ## Introspection Functions
   #
   # \{#type_of type-of($value)}
@@ -705,7 +716,7 @@ module Sass::Script
     #   mix(#f00, #00f) => #7f007f
     #   mix(#f00, #00f, 25%) => #3f00bf
     #   mix(rgba(255, 0, 0, 0.5), #00f) => rgba(63, 0, 191, 0.75)
-    # @overload mix(color1, color2, weight = 50%)
+    # @overload mix(color1, color2, weight: 50%)
     #   @param color1 [Color]
     #   @param color2 [Color]
     #   @param weight [Number] between 0% and 100%
@@ -912,7 +923,7 @@ module Sass::Script
     #   round(10.6px) => 11px
     # @param value [Number] The number
     # @return [Number] The rounded number
-    # @raise [Sass::SyntaxError] if `value` isn't a number
+    # @raise [ArgumentError] if `value` isn't a number
     def round(value)
       numeric_transformation(value) {|n| n.round}
     end
@@ -925,7 +936,7 @@ module Sass::Script
     #   ciel(10.6px) => 11px
     # @param value [Number] The number
     # @return [Number] The rounded number
-    # @raise [Sass::SyntaxError] if `value` isn't a number
+    # @raise [ArgumentError] if `value` isn't a number
     def ceil(value)
       numeric_transformation(value) {|n| n.ceil}
     end
@@ -938,7 +949,7 @@ module Sass::Script
     #   floor(10.6px) => 10px
     # @param value [Number] The number
     # @return [Number] The rounded number
-    # @raise [Sass::SyntaxError] if `value` isn't a number
+    # @raise [ArgumentError] if `value` isn't a number
     def floor(value)
       numeric_transformation(value) {|n| n.floor}
     end
@@ -951,12 +962,122 @@ module Sass::Script
     #   abs(-10px) => 10px
     # @param value [Number] The number
     # @return [Number] The absolute value
-    # @raise [Sass::SyntaxError] if `value` isn't a number
+    # @raise [ArgumentError] if `value` isn't a number
     def abs(value)
       numeric_transformation(value) {|n| n.abs}
     end
     declare :abs, [:value]
 
+    # Return the length of a list.
+    #
+    # @example
+    #   length(10px) => 1
+    #   length(10px 20px 30px) => 3
+    # @param list [Literal] The list
+    # @return [Number] The length
+    def length(list)
+      Sass::Script::Number.new(list.to_a.size)
+    end
+    declare :length, [:list]
+
+    # Gets the nth item in a list.
+    #
+    # Note that unlike some languages, the first item in a Sass list is number 1,
+    # the second number 2, and so forth.
+    #
+    # @example
+    #   nth(10px 20px 30px, 1) => 10px
+    #   nth((Helvetica, Arial, sans-serif), 3) => sans-serif
+    # @param list [Literal] The list
+    # @param n [Number] The index into the list
+    # @return [Literal] The nth item in the list
+    # @raise [ArgumentError] If `n` isn't an integer between 1 and the list's length.
+    def nth(list, n)
+      assert_type n, :Number
+      if !n.int?
+        raise ArgumentError.new("List index #{n} must be an integer")
+      elsif n.to_i < 1
+        raise ArgumentError.new("List index #{n} must be greater than or equal to 1")
+      elsif n.to_i > (size = list.to_a.size)
+        raise ArgumentError.new("List index is #{n} but list is only #{size} item#{'s' if size != 1} long")
+      end
+
+      list.to_a[n.to_i - 1]
+    end
+    declare :nth, [:list, :n]
+
+    # Joins together two lists into a new list.
+    #
+    # Unless the `$separator` argument is passed,
+    # if one list is comma-separated and one is space-separated,
+    # the first parameter's separator is used for the resulting list.
+    # If the lists have only one item each, spaces are used for the resulting list.
+    #
+    # @example
+    #   join(10px 20px, 30px 40px) => 10px 20px 30px 40px
+    #   join((blue, red), (#abc, #def)) => blue, red, #abc, #def
+    #   join(10px, 20px) => 10px 20px
+    #   join(10px, 20px, comma) => 10px, 20px
+    #   join((blue, red), (#abc, #def), space) => blue red #abc #def
+    # @overload join(list1, list2, separator: auto)
+    #   @param list1 [Literal] The first list to join
+    #   @param list2 [Literal] The second list to join
+    #   @param separator [String] How the list separator (comma or space) should be determined.
+    #     If this is `comma` or `space`, that is always the separator;
+    #     if this is `auto` (the default), the separator is determined as explained above.
+    def join(list1, list2, separator = Sass::Script::String.new("auto"))
+      assert_type separator, :String
+      unless %w[auto space comma].include?(separator.value)
+        raise ArgumentError.new("Separator name must be space, comma, or auto")
+      end
+      sep1 = list1.separator if list1.is_a?(Sass::Script::List)
+      sep2 = list2.separator if list2.is_a?(Sass::Script::List)
+      Sass::Script::List.new(
+        list1.to_a + list2.to_a,
+        if separator.value == 'auto'
+          sep1 || sep2 || :space
+        else
+          separator.value.to_sym
+        end)
+    end
+    declare :join, [:list1, :list2]
+    declare :join, [:list1, :list2, :separator]
+
+    # Appends a single value onto the end of a list.
+    #
+    # Unless the `$separator` argument is passed,
+    # if the list has only one item,
+    # the resulting list will be space-separated.
+    #
+    # @example
+    #   append(10px 20px, 30px) => 10px 20px 30px
+    #   append((blue, red), green) => blue, red, green
+    #   append(10px 20px, 30px 40px) => 10px 20px (30px 40px)
+    #   join(10px, 20px, comma) => 10px, 20px
+    #   join((blue, red), green, space) => blue red green
+    # @overload join(list, val, separator: auto)
+    #   @param list1 [Literal] The first list to join
+    #   @param list2 [Literal] The second list to join
+    #   @param separator [String] How the list separator (comma or space) should be determined.
+    #     If this is `comma` or `space`, that is always the separator;
+    #     if this is `auto` (the default), the separator is determined as explained above.
+    def append(list, val, separator = Sass::Script::String.new("auto"))
+      assert_type separator, :String
+      unless %w[auto space comma].include?(separator.value)
+        raise ArgumentError.new("Separator name must be space, comma, or auto")
+      end
+      sep = list.separator if list.is_a?(Sass::Script::List)
+      Sass::Script::List.new(
+        list.to_a + [val],
+        if separator.value == 'auto'
+          sep || :space
+        else
+          separator.value.to_sym
+        end)
+    end
+    declare :append, [:list, :val]
+    declare :append, [:list, :val, :separator]
+
     private
 
     # This method implements the pattern of transforming a numeric value into

data/lib/sass/script/list.rb

@@ -0,0 +1,76 @@
+module Sass::Script
+  # A SassScript object representing a CSS list.
+  # This includes both comma-separated lists and space-separated lists.
+  class List < Literal
+    # The Ruby array containing the contents of the list.
+    #
+    # @return [Array<Literal>]
+    attr_reader :value
+    alias_method :children, :value
+    alias_method :to_a, :value
+
+    # The operator separating the values of the list.
+    # Either `:comma` or `:space`.
+    #
+    # @return [Symbol]
+    attr_reader :separator
+
+    # Creates a new list.
+    #
+    # @param value [Array<Literal>] See \{#value}
+    # @param separator [String] See \{#separator}
+    def initialize(value, separator)
+      super(value)
+      @separator = separator
+    end
+
+    # @see Node#eq
+    def eq(other)
+      Sass::Script::Bool.new(
+        self.class == other.class && self.value == other.value &&
+        self.separator == other.separator)
+    end
+
+    # @see Node#to_s
+    def to_s(opts = {})
+      return value.map {|e| e.to_s(opts)}.join(sep_str)
+    end
+
+    # @see Node#to_sass
+    def to_sass(opts = {})
+      precedence = Sass::Script::Parser.precedence_of(separator)
+      value.map do |v|
+        if v.is_a?(List) && Sass::Script::Parser.precedence_of(v.separator) <= precedence
+          "(#{v.to_sass(opts)})"
+        else
+          v.to_sass(opts)
+        end
+      end.join(sep_str(nil))
+    end
+
+    # @see Node#inspect
+    def inspect
+      "(#{to_sass})"
+    end
+
+    protected
+
+    # @see Node#_perform
+    def _perform(environment)
+      list = Sass::Script::List.new(
+        value.map {|e| e.perform(environment)},
+        separator)
+      list.options = self.options
+      list.context = self.context
+      list
+    end
+
+    private
+
+    def sep_str(opts = self.options)
+      return ' ' if separator == :space
+      return ',' if opts && opts[:style] == :compressed
+      return ', '
+    end
+  end
+end

data/lib/sass/script/literal.rb

@@ -9,6 +9,7 @@ module Sass::Script
     require 'sass/script/number'
     require 'sass/script/color'
     require 'sass/script/bool'
+    require 'sass/script/list'
 
     # Returns the Ruby value of the literal.
     # The type of this value varies based on the subclass.
@@ -107,7 +108,7 @@ MSG
     # @param other [Literal] The right-hand side of the operator
     # @return [Script::String] A string containing both literals
     #   separated by a space
-    def concat(other)
+    def space(other)
       Sass::Script::String.new("#{self.to_s} #{other.to_s}")
     end
 
@@ -214,6 +215,14 @@ MSG
     # @raise [Sass::SyntaxError] if this literal isn't an integer
     def assert_int!; to_i; end
 
+    # Returns the value of this literal as a list.
+    # Single literals are considered the same as single-element lists.
+    #
+    # @return [Array<Literal>] The of this literal as a list
+    def to_a
+      [self]
+    end
+
     # Returns the string representation of this literal
     # as it would be output to the CSS document.
     #

data/lib/sass/script/number.rb

@@ -238,7 +238,7 @@ module Sass::Script
     # @return [String] The CSS representation of this number
     # @raise [Sass::SyntaxError] if this number has units that can't be used in CSS
     #   (e.g. `px*in`)
-    def to_s
+    def to_s(opts = {})
       return original if original
       raise Sass::SyntaxError.new("#{inspect} isn't a valid CSS value.") unless legal_units?
       inspect

data/lib/sass/script/operation.rb

@@ -41,7 +41,7 @@ module Sass::Script
       sep =
         case @operator
         when :comma; ", "
-        when :concat; " "
+        when :space; " "
         else; " #{Lexer::OPERATORS_REVERSE[@operator]} "
         end
       "#{o1}#{sep}#{o2}"
@@ -66,7 +66,7 @@ module Sass::Script
       literal1 = @operand1.perform(environment)
       literal2 = @operand2.perform(environment)
 
-      if @operator == :concat && context == :equals
+      if @operator == :space && context == :equals
         literal1 = Sass::Script::String.new(literal1.value) if literal1.is_a?(Sass::Script::String)
         literal2 = Sass::Script::String.new(literal2.value) if literal2.is_a?(Sass::Script::String)
       end
@@ -82,6 +82,7 @@ module Sass::Script
     private
 
     def operand_to_sass(op, side, opts)
+      return "(#{op.to_sass(opts)})" if op.is_a?(List)
       return op.to_sass(opts) unless op.is_a?(Operation)
 
       pred = Sass::Script::Parser.precedence_of(@operator)

data/lib/sass/script/parser.rb

@@ -123,14 +123,14 @@ module Sass
       end
 
       PRECEDENCE = [
-        :comma, :single_eq, :concat, :or, :and,
+        :comma, :single_eq, :space, :or, :and,
         [:eq, :neq],
         [:gt, :gte, :lt, :lte],
         [:plus, :minus],
         [:times, :div, :mod],
       ]
 
-      ASSOCIATIVE = [:comma, :concat, :plus, :times]
+      ASSOCIATIVE = [:plus, :times]
 
       class << self
         # Returns an integer representing the precedence
@@ -193,7 +193,18 @@ RUBY
       # @private
       def lexer_class; Lexer; end
 
-      production :expr, :interpolation, :comma
+      def expr
+        interp = try_ops_after_interp([:comma], :expr) and return interp
+        line = @lexer.line
+        return unless e = interpolation
+        arr = [e]
+        while tok = try_tok(:comma)
+          interp = try_op_before_interp(tok, e) and return interp
+          arr << assert_expr(:interpolation)
+        end
+        arr.size == 1 ? arr.first : node(List.new(arr, :comma), line)
+      end
+
       production :equals, :interpolation, :single_eq
 
       def try_op_before_interp(op, prev = nil)
@@ -219,25 +230,27 @@ RUBY
         return interp
       end
 
-      def interpolation(first = concat)
+      def interpolation(first = space)
         e = first
         while interp = try_tok(:begin_interpolation)
           wb = @lexer.whitespace?(interp)
           line = @lexer.line
           mid = parse_interpolated
           wa = @lexer.whitespace?
-          e = Script::Interpolation.new(e, mid, concat, wb, wa)
+          e = Script::Interpolation.new(e, mid, space, wb, wa)
           e.line = line
         end
         e
       end
 
-      def concat
+      def space
+        line = @lexer.line
         return unless e = or_expr
-        while sub = or_expr
-          e = node(Operation.new(e, sub, :concat))
+        arr = [e]
+        while e = or_expr
+          arr << e
         end
-        e
+        arr.size == 1 ? arr.first : node(List.new(arr, :space), line)
       end
 
       production :or_expr, :and_expr, :or
@@ -280,7 +293,7 @@ RUBY
           c = assert_tok(:const)
           var = Script::Variable.new(c.value)
           if tok = (try_tok(:colon) || try_tok(:single_eq))
-            val = assert_expr(:concat)
+            val = assert_expr(:space)
 
             if tok.type == :single_eq
               val.context = :equals
@@ -427,8 +440,8 @@ RUBY
         @lexer.expected!(EXPR_NAMES[:default])
       end
 
-      def node(node)
-        node.line = @lexer.line
+      def node(node, line = @lexer.line)
+        node.line = line
         node
       end
     end

data/lib/sass/scss/parser.rb

@@ -98,8 +98,8 @@ module Sass
         node << comment
       end
 
-      DIRECTIVES = Set[:mixin, :include, :debug, :warn, :for, :while, :if, :extend, :import,
-        :media, :charset]
+      DIRECTIVES = Set[:mixin, :include, :debug, :warn, :for, :each, :while, :if,
+        :extend, :import, :media, :charset]
 
       def directive
         return unless tok(/@/)
@@ -169,6 +169,18 @@ module Sass
         block(node(Sass::Tree::ForNode.new(var, from, to, exclusive)), :directive)
       end
 
+      def each_directive
+        tok!(/\$/)
+        var = tok! IDENT
+        ss
+
+        tok!(/in/)
+        list = sass_script(:parse)
+        ss
+
+        block(node(Sass::Tree::EachNode.new(var, list)), :directive)
+      end
+
       def while_directive
         expr = sass_script(:parse)
         ss

data/lib/sass/tree/each_node.rb

@@ -0,0 +1,54 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A dynamic node representing a Sass `@each` loop.
+  #
+  # @see Sass::Tree
+  class EachNode < Node
+    # @param var [String] The name of the loop variable
+    # @param list [Script::Node] The parse tree for the list
+    def initialize(var, list)
+      @var = var
+      @list = list
+      super()
+    end
+
+    protected
+
+    # @see Node#to_src
+    def to_src(tabs, opts, fmt)
+      "#{'  ' * tabs}@each $#{dasherize(@var, opts)} in #{@list.to_sass(opts)}" +
+        children_to_src(tabs, opts, fmt)
+    end
+
+    # Runs the child nodes once for each value in the list.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    # @return [Array<Tree::Node>] The resulting static nodes
+    # @see Sass::Tree
+    def _perform(environment)
+      list = @list.perform(environment)
+
+      children = []
+      environment = Sass::Environment.new(environment)
+      list.to_a.each do |v|
+        environment.set_local_var(@var, v)
+        children += perform_children(environment)
+      end
+      children
+    end
+
+    # Returns an error message if the given child node is invalid,
+    # and false otherwise.
+    #
+    # {ExtendNode}s are valid within {EachNode}s.
+    #
+    # @param child [Tree::Node] A potential child node.
+    # @return [Boolean, String] Whether or not the child node is valid,
+    #   as well as the error message to display if it is invalid
+    def invalid_child?(child)
+      super unless child.is_a?(ExtendNode)
+    end
+  end
+end

data/lib/sass/tree/prop_node.rb

@@ -199,7 +199,7 @@ module Sass::Tree
 
       def val_to_sass_concat(node, opts)
         return node unless node.is_a?(Sass::Script::Operation)
-        return val_to_sass_div(node, opts) unless node.operator == :concat
+        return val_to_sass_div(node, opts) unless node.operator == :space
 
         Sass::Script::Operation.new(
           val_to_sass_div(node.operand1, opts),

data/test/sass/conversion_test.rb

@@ -675,6 +675,26 @@ foo {
 SCSS
   end
 
+  def test_each
+    assert_renders <<SASS, <<SCSS
+a
+  @each $number in 1px 2px 3px 4px
+    b: $number
+
+c
+  @each $str in foo, bar, baz, bang
+    d: $str
+SASS
+a {
+  @each $number in 1px 2px 3px 4px {
+    b: $number; } }
+
+c {
+  @each $str in foo, bar, baz, bang {
+    d: $str; } }
+SCSS
+  end
+
   def test_import
     assert_renders <<SASS, <<SCSS
 @import foo

data/test/sass/engine_test.rb

@@ -1281,6 +1281,29 @@ a
 SASS
   end
 
+  def test_each
+    assert_equal(<<CSS, render(<<SASS))
+a {
+  b: 1px;
+  b: 2px;
+  b: 3px;
+  b: 4px;
+  c: foo;
+  c: bar;
+  c: baz;
+  c: bang;
+  d: blue; }
+CSS
+a
+  @each $number in 1px 2px 3px 4px
+    b: $number
+  @each $str in foo, bar, baz, bang
+    c: $str
+  @each $single in blue
+    d: $single
+SASS
+  end
+
   def test_variable_reassignment
     assert_equal(<<CSS, render(<<SASS))
 a {

data/test/sass/functions_test.rb

@@ -599,6 +599,75 @@ MSG
     assert_error_message("#ff0000 is not a number for `comparable'", "comparable(1px, #f00)")
   end
 
+  def test_length
+    assert_equal("5", evaluate("length(1 2 3 4 5)"))
+    assert_equal("4", evaluate("length((foo, bar, baz, bip))"))
+    assert_equal("3", evaluate("length((foo, bar, baz bip))"))
+    assert_equal("3", evaluate("length((foo, bar, (baz, bip)))"))
+    assert_equal("1", evaluate("length(#f00)"))
+  end
+
+  def test_nth
+    assert_equal("1", evaluate("nth(1 2 3, 1)"))
+    assert_equal("2", evaluate("nth(1 2 3, 2)"))
+    assert_equal("3", evaluate("nth((1, 2, 3), 3)"))
+    assert_equal("foo", evaluate("nth(foo, 1)"))
+    assert_equal("bar baz", evaluate("nth(foo (bar baz) bang, 2)"))
+    assert_error_message("List index 0 must be greater than or equal to 1 for `nth'", "nth(foo, 0)")
+    assert_error_message("List index -10 must be greater than or equal to 1 for `nth'", "nth(foo, -10)")
+    assert_error_message("List index 1.5 must be an integer for `nth'", "nth(foo, 1.5)")
+    assert_error_message("List index is 5 but list is only 4 items long for `nth'", "nth(1 2 3 4, 5)")
+    assert_error_message("List index is 2 but list is only 1 item long for `nth'", "nth(foo, 2)")
+  end
+
+  def test_join
+    assert_equal("1 2 3", evaluate("join(1 2, 3)"))
+    assert_equal("1 2 3", evaluate("join(1, 2 3)"))
+    assert_equal("1 2 3 4", evaluate("join(1 2, 3 4)"))
+    assert_equal("true", evaluate("(1 2 3 4) == join(1 2, 3 4)"))
+    assert_equal("false", evaluate("(1 2 (3 4)) == join(1 2, 3 4)"))
+    assert_equal("1, 2, 3", evaluate("join((1, 2), 3)"))
+    assert_equal("1, 2, 3", evaluate("join(1, (2, 3))"))
+    assert_equal("1, 2, 3, 4", evaluate("join((1, 2), (3, 4))"))
+    assert_equal("true", evaluate("(1, 2, 3, 4) == join((1, 2), (3, 4))"))
+    assert_equal("false", evaluate("(1, 2, (3, 4)) == join((1, 2), (3, 4))"))
+
+    assert_equal("1 2", evaluate("join(1, 2)"))
+    assert_equal("1 2 3 4", evaluate("join(1 2, (3, 4))"))
+    assert_equal("1, 2, 3, 4", evaluate("join((1, 2), 3 4)"))
+
+    assert_equal("1 2", evaluate("join(1, 2, auto)"))
+    assert_equal("1, 2, 3, 4", evaluate("join(1 2, 3 4, comma)"))
+    assert_equal("1 2 3 4", evaluate("join((1, 2), (3, 4), space)"))
+    assert_equal("1, 2", evaluate("join(1, 2, comma)"))
+
+    assert_error_message("Separator name must be space, comma, or auto for `join'", "join(1, 2, baboon)")
+  end
+
+  def test_append
+    assert_equal("1 2 3", evaluate("append(1 2, 3)"))
+    assert_equal("1 2 3 4", evaluate("append(1 2, 3 4)"))
+    assert_equal("false", evaluate("(1 2 3 4) == append(1 2, 3 4)"))
+    assert_equal("true", evaluate("(1 2 (3 4)) == append(1 2, 3 4)"))
+    assert_equal("1, 2, 3", evaluate("append((1, 2), 3)"))
+    assert_equal("1, 2, 3, 4", evaluate("append((1, 2), (3, 4))"))
+    assert_equal("false", evaluate("(1, 2, 3, 4) == append((1, 2), (3, 4))"))
+    assert_equal("true", evaluate("(1, 2, (3, 4)) == append((1, 2), (3, 4))"))
+
+    assert_equal("1 2", evaluate("append(1, 2)"))
+    assert_equal("1 2 3, 4", evaluate("append(1 2, (3, 4))"))
+    assert_equal("true", evaluate("(1 2 (3, 4)) == append(1 2, (3, 4))"))
+    assert_equal("1, 2, 3 4", evaluate("append((1, 2), 3 4)"))
+    assert_equal("true", evaluate("(1, 2, 3 4) == append((1, 2), 3 4)"))
+
+    assert_equal("1 2", evaluate("append(1, 2, auto)"))
+    assert_equal("1, 2, 3 4", evaluate("append(1 2, 3 4, comma)"))
+    assert_equal("1 2 3, 4", evaluate("append((1, 2), (3, 4), space)"))
+    assert_equal("1, 2", evaluate("append(1, 2, comma)"))
+
+    assert_error_message("Separator name must be space, comma, or auto for `append'", "append(1, 2, baboon)")
+  end
+
   def test_keyword_args_rgb
     assert_equal(%Q{white}, evaluate("rgb($red: 255, $green: 255, $blue: 255)"))
   end

data/test/sass/script_conversion_test.rb

@@ -82,28 +82,6 @@ WARN
     assert_renders "$foo !important"
   end
 
-  def test_comma_operator
-    assert_renders "$foo, $bar $baz"
-    assert_renders "$foo $bar, $baz"
-
-    assert_renders "($foo, $bar) $baz"
-    assert_renders "$foo ($bar, $baz)"
-
-    assert_equal "$foo, $bar $baz", render("$foo, ($bar $baz)")
-    assert_equal "$foo $bar, $baz", render("($foo $bar), $baz")
-  end
-
-  def test_concat_operator
-    assert_renders "$foo $bar or $baz"
-    assert_renders "$foo or $bar $baz"
-
-    assert_renders "($foo $bar) or $baz"
-    assert_renders "$foo or ($bar $baz)"
-
-    assert_equal "$foo $bar or $baz", render("$foo ($bar or $baz)")
-    assert_equal "$foo or $bar $baz", render("($foo or $bar) $baz")
-  end
-
   def self.test_precedence(outer, inner)
     op_outer = Sass::Script::Lexer::OPERATORS_REVERSE[outer]
     op_inner = Sass::Script::Lexer::OPERATORS_REVERSE[inner]
@@ -146,7 +124,7 @@ RUBY
   def self.separator_for(op_name)
     case op_name
     when :comma; ", "
-    when :concat; " "
+    when :space; " "
     else; " #{Sass::Script::Lexer::OPERATORS_REVERSE[op_name]} "
     end
   end
@@ -182,8 +160,6 @@ RUBY
   test_precedence :plus, :div
   test_precedence :plus, :mod
 
-  assert_associative :comma, :concat
-  assert_associative :concat, :or
   assert_associative :plus, :minus
   assert_associative :times, :div
   assert_associative :times, :mod
@@ -196,6 +172,32 @@ RUBY
   assert_non_associative :lt, :lte
   assert_non_associative :lte, :gt
 
+  def test_comma_precedence
+    assert_renders "$foo, $bar, $baz"
+
+    assert_renders "$foo ($bar, $baz)"
+    assert_renders "($foo, $bar) $baz"
+
+    assert_equal "$foo, $bar $baz", render("$foo, ($bar $baz)")
+    assert_equal "$foo $bar, $baz", render("($foo $bar), $baz")
+
+    assert_equal "$foo, ($bar, $baz)", render("$foo, ($bar, $baz)")
+    assert_equal "($foo, $bar), $baz", render("($foo, $bar), $baz")
+  end
+
+  def test_space_precedence
+    assert_renders "$foo $bar $baz"
+
+    assert_renders "$foo or ($bar $baz)"
+    assert_renders "($foo $bar) or $baz"
+
+    assert_equal "$foo $bar or $baz", render("$foo ($bar or $baz)")
+    assert_equal "$foo or $bar $baz", render("($foo or $bar) $baz")
+
+    assert_equal "$foo ($bar $baz)", render("$foo ($bar $baz)")
+    assert_equal "($foo $bar) $baz", render("($foo $bar) $baz")
+  end
+
   def test_unary_op
     assert_renders "-12px"
     assert_renders '/"foo"'

data/test/sass/script_test.rb

@@ -103,7 +103,6 @@ class SassScriptTest < Test::Unit::TestCase
 
   def test_implicit_strings
     assert_equal Sass::Script::String.new("foo"), eval("foo")
-    assert_equal Sass::Script::String.new("foo bar"), eval("foo bar")
     assert_equal Sass::Script::String.new("foo/bar"), eval("foo/bar")
   end
 
@@ -235,6 +234,10 @@ SASS
   def test_ruby_equality
     assert_equal eval('"foo"'), eval('"foo"')
     assert_equal eval('1'), eval('1.0')
+    assert_equal eval('1 2 3.0'), eval('1 2 3')
+    assert_equal eval('1, 2, 3.0'), eval('1, 2, 3')
+    assert_equal eval('(1 2), (3, 4), (5 6)'), eval('(1 2), (3, 4), (5 6)')
+    assert_not_equal eval('1, 2, 3'), eval('1 2 3')
     assert_not_equal eval('1'), eval('"1"')
   end
 
@@ -313,6 +316,14 @@ SASS
     assert_equal "true", resolve("false != true")
     assert_equal "false", resolve("1em == 1px")
     assert_equal "false", resolve("12 != 12")
+    assert_equal "true", resolve("(foo bar baz) == (foo bar baz)")
+    assert_equal "true", resolve("(foo, bar, baz) == (foo, bar, baz)")
+    assert_equal "true", resolve('((1 2), (3, 4), (5 6)) == ((1 2), (3, 4), (5 6))')
+    assert_equal "true", resolve('((1 2), (3 4)) == (1 2, 3 4)')
+    assert_equal "false", resolve('((1 2) 3) == (1 2 3)')
+    assert_equal "false", resolve('(1 (2 3)) == (1 2 3)')
+    assert_equal "false", resolve('((1, 2) (3, 4)) == (1, 2 3, 4)')
+    assert_equal "false", resolve('(1 2 3) == (1, 2, 3)')
   end
 
   def test_operation_precedence

data/test/sass/scss/scss_test.rb

@@ -235,6 +235,33 @@ $i: 1;
 SCSS
   end
 
+  def test_each_directive
+    assert_equal <<CSS, render(<<SCSS)
+a {
+  b: 1px;
+  b: 2px;
+  b: 3px;
+  b: 4px; }
+
+c {
+  d: foo;
+  d: bar;
+  d: baz;
+  d: bang; }
+CSS
+a {
+  @each $number in 1px 2px 3px 4px {
+    b: $number;
+  }
+}
+c {
+  @each $str in foo, bar, baz, bang {
+    d: $str;
+  }
+}
+SCSS
+  end
+
   def test_css_import_directive
     assert_equal "@import url(foo.css);\n", render('@import "foo.css";')
     assert_equal "@import url(foo.css);\n", render("@import 'foo.css';")

data/test/sass/templates/script.sass

@@ -9,7 +9,7 @@ $esc: 10\+12
 $str: Hello\!
 $qstr: "Quo\"ted\"!"
 $hstr: Hyph-en\!
-$concat: #{5 + 4} hi there
+$space: #{5 + 4} hi there
 $percent: 11%
 $complex: 1px/1em
 
@@ -22,7 +22,7 @@ $complex: 1px/1em
   :color $main_text
   :short-color #123
   :named-color olive
-  :con "foo" bar ($concat "boom")
+  :con "foo" bar ($space "boom")
   :con2 "noquo" quo
   #sidebar
     :background-color $color

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  version: 3.1.0.alpha.23
+  version: 3.1.0.alpha.24
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-31 00:00:00 -04:00
+date: 2010-11-10 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -87,6 +87,7 @@ files:
 - lib/sass/script/string_interpolation.rb
 - lib/sass/script/unary_operation.rb
 - lib/sass/script/variable.rb
+- lib/sass/script/list.rb
 - lib/sass/scss.rb
 - lib/sass/scss/css_parser.rb
 - lib/sass/scss/parser.rb
@@ -102,6 +103,7 @@ files:
 - lib/sass/selector/simple.rb
 - lib/sass/selector/simple_sequence.rb
 - lib/sass/shared.rb
+- lib/sass/tree/charset_node.rb
 - lib/sass/tree/comment_node.rb
 - lib/sass/tree/debug_node.rb
 - lib/sass/tree/directive_node.rb
@@ -118,7 +120,7 @@ files:
 - lib/sass/tree/variable_node.rb
 - lib/sass/tree/warn_node.rb
 - lib/sass/tree/while_node.rb
-- lib/sass/tree/charset_node.rb
+- lib/sass/tree/each_node.rb
 - lib/sass/util.rb
 - lib/sass/util/subset_map.rb
 - lib/sass/version.rb
@@ -180,6 +182,9 @@ files:
 - test/sass/results/compressed.css
 - test/sass/results/expanded.css
 - test/sass/results/import.css
+- test/sass/results/import_charset.css
+- test/sass/results/import_charset_1_8.css
+- test/sass/results/import_charset_ibm866.css
 - test/sass/results/line_numbers.css
 - test/sass/results/mixins.css
 - test/sass/results/multiline.css
@@ -194,15 +199,14 @@ files:
 - test/sass/results/units.css
 - test/sass/results/warn.css
 - test/sass/results/warn_imported.css
-- test/sass/results/import_charset.css
-- test/sass/results/import_charset_1_8.css
-- test/sass/results/import_charset_ibm866.css
 - test/sass/script_conversion_test.rb
 - test/sass/script_test.rb
 - test/sass/scss/css_test.rb
 - test/sass/scss/rx_test.rb
 - test/sass/scss/scss_test.rb
 - test/sass/scss/test_helper.rb
+- test/sass/templates/_imported_charset_ibm866.sass
+- test/sass/templates/_imported_charset_utf8.sass
 - test/sass/templates/_partial.sass
 - test/sass/templates/alt.sass
 - test/sass/templates/basic.sass
@@ -215,6 +219,9 @@ files:
 - test/sass/templates/compressed.sass
 - test/sass/templates/expanded.sass
 - test/sass/templates/import.sass
+- test/sass/templates/import_charset.sass
+- test/sass/templates/import_charset_1_8.sass
+- test/sass/templates/import_charset_ibm866.sass
 - test/sass/templates/importee.less
 - test/sass/templates/importee.sass
 - test/sass/templates/line_numbers.sass
@@ -238,11 +245,6 @@ files:
 - test/sass/templates/units.sass
 - test/sass/templates/warn.sass
 - test/sass/templates/warn_imported.sass
-- test/sass/templates/_imported_charset_ibm866.sass
-- test/sass/templates/_imported_charset_utf8.sass
-- test/sass/templates/import_charset.sass
-- test/sass/templates/import_charset_1_8.sass
-- test/sass/templates/import_charset_ibm866.sass
 - test/sass/test_helper.rb
 - test/sass/util/subset_map_test.rb
 - test/sass/util_test.rb