sass 3.3.0.alpha.231 → 3.3.0.alpha.243

data/lib/sass/script/value.rb

@@ -8,3 +8,4 @@ require 'sass/script/value/bool'
 require 'sass/script/value/null'
 require 'sass/script/value/list'
 require 'sass/script/value/arg_list'
+require 'sass/script/value/map'

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

@@ -158,6 +158,18 @@ MSG
       Sass::Script::Value::String.new("/#{self.to_s}")
     end
 
+    # Returns the hash code of this value. Two objects' hash codes should be
+    # equal if the objects are equal.
+    #
+    # @return [Fixnum] The hash code.
+    def hash
+      value.hash
+    end
+
+    def eql?(other)
+      self == other
+    end
+
     # @return [String] A readable representation of the value
     def inspect
       value.inspect
@@ -185,14 +197,30 @@ MSG
     # @raise [Sass::SyntaxError] if this value isn't an integer
     def assert_int!; to_i; end
 
+    # Returns the separator for this value. For non-list-like values or the
+    # empty list, this will be `nil`. For lists or maps, it will be `:space` or
+    # `:comma`.
+    #
+    # @return [Symbol]
+    def separator; nil; end
+
     # Returns the value of this value as a list.
     # Single values are considered the same as single-element lists.
     #
-    # @return [Array<Value>] The of this value as a list
+    # @return [Array<Value>] This value as a list
     def to_a
       [self]
     end
 
+    # Returns the value of this value as a hash. Most values don't have hash
+    # representations, but [Map]s and empty [List]s do.
+    #
+    # @return [Hash<Value, Value>] This value as a hash
+    # @raise [Sass::SyntaxError] if this value doesn't have a hash representation
+    def to_h
+      raise Sass::SyntaxError.new("#{self.inspect} is not a map.")
+    end
+
     # Returns the string representation of this value
     # as it would be output to the CSS document.
     #

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

@@ -356,6 +356,10 @@ module Sass::Script::Value
         other.is_a?(Color) && rgb == other.rgb && alpha == other.alpha)
     end
 
+    def hash
+      [rgb, alpha].hash
+    end
+
     # Returns a copy of this color with one or more channels changed.
     # RGB or HSL colors may be changed, but not both at once.
     #

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

@@ -36,6 +36,10 @@ module Sass::Script::Value
         self.separator == other.separator)
     end
 
+    def hash
+      @hash ||= [value, separator].hash
+    end
+
     # @see Value#to_s
     def to_s(opts = {})
       raise Sass::SyntaxError.new("() isn't a valid CSS value.") if value.empty?
@@ -48,7 +52,8 @@ module Sass::Script::Value
       precedence = Sass::Script::Parser.precedence_of(separator)
       value.reject {|e| e.is_a?(Null)}.map do |v|
         if v.is_a?(List) && Sass::Script::Parser.precedence_of(v.separator) <= precedence ||
-            separator == :space && v.is_a?(UnaryOperation) && (v.operator == :minus || v.operator == :plus)
+            separator == :space && v.is_a?(Sass::Script::Tree::UnaryOperation) &&
+            (v.operator == :minus || v.operator == :plus)
           "(#{v.to_sass(opts)})"
         else
           v.to_sass(opts)
@@ -56,6 +61,27 @@ module Sass::Script::Value
       end.join(sep_str(nil))
     end
 
+    # @see Value#to_h
+    def to_h
+      return Sass::Util.ordered_hash if value.empty?
+      return @map ||= Sass::Util.to_hash(value.map {|e| e.to_a}) if is_pseudo_map?
+      super
+    end
+
+    # Returns whether a warning still needs to be printed for this list being used as a map.
+    #
+    # @return [Boolean]
+    def needs_map_warning?
+      !@value.empty? && !@map
+    end
+
+    # Returns whether this is a list of pairs that can be used as a map.
+    #
+    # @return [Boolean]
+    def is_pseudo_map?
+      @is_pseudo_map ||= value.all? {|e| e.is_a?(Sass::Script::Value::List) && e.to_a.length == 2}
+    end
+
     # @see Value#inspect
     def inspect
       "(#{value.map {|e| e.inspect}.join(sep_str(nil))})"

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

@@ -0,0 +1,70 @@
+module Sass::Script::Value
+  # A SassScript object representing a map from keys to values. Both keys and
+  # values can be any SassScript object.
+  class Map < Base
+    # The Ruby hash containing the contents of this map.
+    #
+    # @return [Hash<Node, Node>]
+    attr_reader :value
+    alias_method :to_h, :value
+
+    # Creates a new map.
+    #
+    # @param hash [Hash<Node, Node>]
+    def initialize(hash)
+      super(Sass::Util.ordered_hash(hash))
+    end
+
+    # @see Value#options=
+    def options=(options)
+      super
+      value.each do |k, v|
+        k.options = options
+        v.options = options
+      end
+    end
+
+    # @see Value#separator
+    def separator
+      :comma unless value.empty?
+    end
+
+    # @see Value#to_a
+    def to_a
+      value.map do |k, v|
+        list = List.new([k, v], :space)
+        list.options = options
+        list
+      end
+    end
+
+    # @see Value#eq
+    def eq(other)
+      Bool.new(other.is_a?(Map) && self.value == other.value)
+    end
+
+    def hash
+      @hash ||= value.hash
+    end
+
+    # @see Value#to_s
+    def to_s(opts = {})
+      raise Sass::SyntaxError.new("#{inspect} isn't a valid CSS value.")
+    end
+
+    def to_sass(opts = {})
+      return "()" if value.empty?
+
+      to_sass = lambda do |value|
+        if value.is_a?(Map) || (value.is_a?(List) && value.separator == :comma)
+          "(#{value.to_sass(opts)})"
+        else
+          value.to_sass(opts)
+        end
+      end
+
+      "(#{value.map {|(k, v)| "#{to_sass[k]}: #{to_sass[v]}"}.join(', ')})"
+    end
+    alias_method :inspect, :to_sass
+  end
+end

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

@@ -206,6 +206,18 @@ module Sass::Script::Value
       Bool.new(this.value == other.value)
     end
 
+    def hash
+      [value, numerator_units, denominator_units].hash
+    end
+
+    # Hash-equality works differently than `==` equality for numbers.
+    # Hash-equality must be transitive, so it just compares the exact value,
+    # numerator units, and denominator units.
+    def eql?(other)
+      self.value == other.value && self.numerator_units == other.numerator_units &&
+        self.denominator_units == other.denominator_units
+    end
+
     # The SassScript `>` operation.
     #
     # @param other [Number] The right-hand side of the operator

data/lib/sass/scss/parser.rb

@@ -263,14 +263,20 @@ module Sass
 
       def each_directive(start_pos)
         tok!(/\$/)
-        var = tok! IDENT
+        vars = [tok!(IDENT)]
         ss
+        while tok(/,/)
+          ss
+          tok!(/\$/)
+          vars << tok!(IDENT)
+          ss
+        end
 
         tok!(/in/)
         list = sass_script(:parse)
         ss
 
-        block(node(Sass::Tree::EachNode.new(var, list), start_pos), :directive)
+        block(node(Sass::Tree::EachNode.new(vars, list), start_pos), :directive)
       end
 
       def while_directive(start_pos)

data/lib/sass/stack.rb

@@ -98,6 +98,15 @@ module Sass
       with_frame(filename, line, :mixin, name) {yield}
     end
 
+    def to_s
+      Sass::Util.enum_with_index(Sass::Util.enum_cons(frames.reverse + [nil], 2)).
+          map do |(frame, caller), i|
+        "#{i == 0 ? "on" : "from"} line #{frame.line}" +
+          " of #{frame.filename || "an unknown file"}" +
+          (caller && caller.name ? ", in `#{caller.name}'" : "")
+      end.join("\n")
+    end
+
     private
 
     def with_frame(filename, line, type, name = nil)

data/lib/sass/tree/each_node.rb

@@ -5,18 +5,18 @@ module Sass::Tree
   #
   # @see Sass::Tree
   class EachNode < Node
-    # The name of the loop variable.
-    # @return [String]
-    attr_reader :var
+    # The names of the loop variables.
+    # @return [Array<String>]
+    attr_reader :vars
 
     # The parse tree for the list.
     # @return [Script::Tree::Node]
     attr_accessor :list
 
-    # @param var [String] The name of the loop variable
+    # @param vars [Array<String>] The names of the loop variables
     # @param list [Script::Tree::Node] The parse tree for the list
-    def initialize(var, list)
-      @var = var
+    def initialize(vars, list)
+      @vars = vars
       @list = list
       super()
     end

data/lib/sass/tree/rule_node.rb

@@ -58,7 +58,7 @@ module Sass::Tree
     # This is only readable in a CSS tree as it is written during the perform step
     # and only when the :trace_selectors option is set.
     #
-    # @return [Array<String>]
+    # @return [String]
     attr_accessor :stack_trace
 
     # @param rule [Array<String, Sass::Script::Tree::Node>]

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

@@ -104,7 +104,8 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_each(node)
-    "#{tab_str}@each $#{dasherize(node.var)} in #{node.list.to_sass(@options)}#{yield}"
+    vars = node.vars.map {|var| "$#{dasherize(var)}"}.join(", ")
+    "#{tab_str}@each #{vars} in #{node.list.to_sass(@options)}#{yield}"
   end
 
   def visit_extend(node)

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

@@ -91,12 +91,12 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
   def initialize(env)
     @environment = env
-    @stack = Sass::Stack.new
   end
 
   # If an exception is raised, this adds proper metadata to the backtrace.
   def visit(node)
-    @stack.with_base(node.filename, node.line) {super(node.dup)}
+    return super(node.dup) unless @environment
+    @environment.stack.with_base(node.filename, node.line) {super(node.dup)}
   rescue Sass::SyntaxError => e
     e.modify_backtrace(:filename => node.filename, :line => node.line)
     raise e
@@ -155,8 +155,14 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     list = node.list.perform(@environment)
 
     with_environment Sass::Environment.new(@environment) do
-      list.to_a.map do |v|
-        @environment.set_local_var(node.var, v)
+      list.to_a.map do |value|
+        if node.vars.length == 1
+          @environment.set_local_var(node.vars.first, value)
+        else
+          node.vars.zip(value.to_a) do |(var, sub_value)|
+            @environment.set_local_var(var, sub_value || Sass::Script::Value::Null.new)
+          end
+        end
         node.children.map {|c| visit(c)}
       end.flatten
     end
@@ -220,12 +226,12 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
       return resolved_node
     end
     file = node.imported_file
-    if @stack.frames.any? {|f| f.is_import? && f.filename == file.options[:filename]}
+    if @environment.stack.frames.any? {|f| f.is_import? && f.filename == file.options[:filename]}
       handle_import_loop!(node)
     end
 
     begin
-      @stack.with_import(node.filename, node.line) do
+      @environment.stack.with_import(node.filename, node.line) do
         root = file.to_tree
         Sass::Tree::Visitors::CheckNesting.visit(root)
         node.children = root.children.map {|c| visit(c)}.flatten
@@ -249,10 +255,10 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Runs a mixin.
   def visit_mixin(node)
     include_loop = true
-    handle_include_loop!(node) if @stack.frames.any? {|f| f.is_mixin? && f.name == node.name}
+    handle_include_loop!(node) if @environment.stack.frames.any? {|f| f.is_mixin? && f.name == node.name}
     include_loop = false
 
-    @stack.with_mixin(node.filename, node.line, node.name) do
+    @environment.stack.with_mixin(node.filename, node.line, node.name) do
       raise Sass::SyntaxError.new("Undefined mixin '#{node.name}'.") unless mixin = @environment.mixin(node.name)
 
       if node.children.any? && !mixin.has_content
@@ -282,7 +288,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
   def visit_content(node)
     return [] unless content = @environment.content
-    @stack.with_mixin(node.filename, node.line, '@content') do
+    @environment.stack.with_mixin(node.filename, node.line, '@content') do
       trace_node = Sass::Tree::TraceNode.from_node('@content', node)
       with_environment(@environment.caller) {trace_node.children = content.map {|c| visit(c.dup)}.flatten}
       trace_node
@@ -315,7 +321,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     parser = Sass::SCSS::StaticParser.new(run_interp(node.rule),
       node.filename, node.options[:importer], node.line)
     node.parsed_rules ||= parser.parse_selector
-    node.stack_trace = stack_trace if node.options[:trace_selectors]
+    node.stack_trace = @environment.stack.to_s if node.options[:trace_selectors]
     yield
   end
 
@@ -338,7 +344,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     res = node.expr.perform(@environment)
     res = res.value if res.is_a?(Sass::Script::Value::String)
     msg = "WARNING: #{res}\n         "
-    msg << stack_trace.join("\n         ") << "\n"
+    msg << @environment.stack.to_s.gsub("\n", "\n         ") << "\n"
     Sass::Util.sass_warn msg
     []
   end
@@ -382,15 +388,6 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
   private
 
-  def stack_trace
-    Sass::Util.enum_with_index(Sass::Util.enum_cons(@stack.frames.reverse + [nil], 2)).
-        map do |(frame, caller), i|
-      "#{i == 0 ? "on" : "from"} line #{frame.line}" +
-        " of #{frame.filename || "an unknown file"}" +
-        (caller && caller.name ? ", in `#{caller.name}'" : "")
-    end
-  end
-
   def run_interp_no_strip(text)
     text.map do |r|
       next r if r.is_a?(String)
@@ -408,7 +405,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   def handle_include_loop!(node)
     msg = "An @include loop has been found:"
     content_count = 0
-    mixins = @stack.frames.select {|f| f.is_mixin?}.reverse.map {|f| f.name}.select do |name|
+    mixins = @environment.stack.frames.select {|f| f.is_mixin?}.reverse.map {|f| f.name}.select do |name|
       if name == '@content'
         content_count += 1
         false
@@ -431,7 +428,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
   def handle_import_loop!(node)
     msg = "An @import loop has been found:"
-    files = @stack.frames.select {|f| f.is_import?}.map {|f| f.filename}.compact
+    files = @environment.stack.frames.select {|f| f.is_import?}.map {|f| f.filename}.compact
     if node.filename == node.imported_file.options[:filename]
       raise Sass::SyntaxError.new("#{msg} #{node.filename} imports itself")
     end

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

@@ -280,7 +280,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
           output "\n"
         elsif node.options[:trace_selectors]
           output("#{old_spaces}/* ")
-          output(node.stack_trace.join("\n   #{old_spaces}"))
+          output(node.stack_trace.gsub("\n", "\n   #{old_spaces}"))
           output(" */\n")
         elsif node.options[:line_comments]
           output("#{old_spaces}/* line #{node.line}")

data/test/sass/conversion_test.rb

@@ -747,6 +747,10 @@ a
 c
   @each $str in foo, bar, baz, bang
     d: $str
+
+c
+  @each $key, $value in (foo: 1, bar: 2, baz: 3)
+    \#{$key}: $value
 SASS
 a {
   @each $number in 1px 2px 3px 4px {
@@ -759,6 +763,12 @@ c {
     d: $str;
   }
 }
+
+c {
+  @each $key, $value in (foo: 1, bar: 2, baz: 3) {
+    \#{$key}: $value;
+  }
+}
 SCSS
   end
 

data/test/sass/engine_test.rb

@@ -1646,6 +1646,27 @@ a
 SASS
   end
 
+  def test_destructuring_each
+    assert_equal <<CSS, render(<<SCSS)
+a {
+  foo: 1px;
+  bar: 2px;
+  baz: 3px; }
+
+c {
+  foo: "Value is bar";
+  bar: "Value is baz";
+  bang: "Value is "; }
+CSS
+a
+  @each $name, $number in (foo: 1px, bar: 2px, baz: 3px)
+    \#{$name}: $number
+c
+  @each $key, $value in (foo bar) (bar, baz) bang
+    \#{$key}: "Value is \#{$value}"
+SCSS
+  end
+
   def test_variable_reassignment
     assert_equal(<<CSS, render(<<SASS))
 a {