sass 3.3.0.alpha.218 → 3.3.0.alpha.222

data/REVISION

@@ -1 +1 @@
-85f7ca624f2fb7d19320e107d518d3376952bf16
+0ef77dc0e3cff821aadca09aca98cac46354093d

data/VERSION

@@ -1 +1 @@
-3.3.0.alpha.218
+3.3.0.alpha.222

data/VERSION_DATE

@@ -1 +1 @@
-27 July 2013 01:12:19 GMT
+30 July 2013 17:39:38 GMT

data/lib/sass/script/parser.rb

@@ -88,7 +88,7 @@ module Sass
       def parse_mixin_include_arglist
         args, keywords = [], {}
         if try_tok(:lparen)
-          args, keywords, splat = mixin_arglist || [[], {}]
+          args, keywords, splat = mixin_arglist
           assert_tok(:rparen)
         end
         assert_done
@@ -343,7 +343,7 @@ RUBY
 
       def funcall
         return raw unless tok = try_tok(:funcall)
-        args, keywords, splat = fn_arglist || [[], {}]
+        args, keywords, splat = fn_arglist
         assert_tok(:rparen)
         node(Script::Tree::Funcall.new(tok.value, args, keywords, splat),
           tok.source_range.start_pos, source_position)
@@ -388,10 +388,11 @@ RUBY
       end
 
       def arglist(subexpr, description)
-        return unless e = send(subexpr)
-
         args = []
-        keywords = {}
+        keywords = Sass::Util::NormalizedMap.new
+
+        return [args, keywords] unless e = send(subexpr)
+
         loop do
           if @lexer.peek && @lexer.peek.type == :colon
             name = e
@@ -399,11 +400,11 @@ RUBY
             assert_tok(:colon)
             value = assert_expr(subexpr, description)
 
-            if keywords[name.underscored_name]
+            if keywords[name.name]
               raise SyntaxError.new("Keyword argument \"#{name.to_sass}\" passed more than once")
             end
 
-            keywords[name.underscored_name] = value
+            keywords[name.name] = value
           else
             if !keywords.empty?
               raise SyntaxError.new("Positional arguments must come before keyword arguments.")
@@ -419,7 +420,6 @@ RUBY
       end
 
       def raw
-        start_pos = source_position
         return special_fun unless tok = try_tok(:raw)
         literal_node(Script::Value::String.new(tok.value), tok.source_range)
       end

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

@@ -1,4 +1,5 @@
 require 'sass/script/functions'
+require 'sass/util/normalized_map'
 
 module Sass::Script::Tree
   # A SassScript parse node representing a function call.
@@ -29,8 +30,8 @@ module Sass::Script::Tree
 
     # @param name [String] See \{#name}
     # @param args [Array<Node>] See \{#args}
+    # @param keywords [Sass::Util::NormalizedMap<Node>] See \{#keywords}
     # @param splat [Node] See \{#splat}
-    # @param keywords [{String => Node}] See \{#keywords}
     def initialize(name, args, keywords, splat)
       @name = name
       @args = args
@@ -42,7 +43,7 @@ module Sass::Script::Tree
     # @return [String] A string representation of the function call
     def inspect
       args = @args.map {|a| a.inspect}.join(', ')
-      keywords = Sass::Util.hash_to_a(@keywords).
+      keywords = Sass::Util.hash_to_a(@keywords.as_stored).
           map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
       if self.splat
         splat = (args.empty? && keywords.empty?) ? "" : ", "
@@ -60,7 +61,7 @@ module Sass::Script::Tree
       end
 
       args = @args.map(&arg_to_sass).join(', ')
-      keywords = Sass::Util.hash_to_a(@keywords).
+      keywords = Sass::Util.hash_to_a(@keywords.as_stored).
         map {|k, v| "$#{dasherize(k, opts)}: #{arg_to_sass[v]}"}.join(', ')
       if self.splat
         splat = (args.empty? && keywords.empty?) ? "" : ", "
@@ -83,7 +84,9 @@ module Sass::Script::Tree
     def deep_copy
       node = dup
       node.instance_variable_set('@args', args.map {|a| a.deep_copy})
-      node.instance_variable_set('@keywords', Hash[keywords.map {|k, v| [k, v.deep_copy]}])
+      copied_keywords = Sass::Util::NormalizedMap.new
+      @keywords.as_stored.each {|k,v| copied_keywords[k] = v.deep_copy}
+      node.instance_variable_set('@keywords', copied_keywords)
       node
     end
 

data/lib/sass/util.rb

@@ -30,6 +30,36 @@ module Sass
       File.join(Sass::ROOT_DIR, file)
     end
 
+    # Converts a hash or a list of pairs into an order-preserving hash.
+    #
+    # On Ruby 1.8.7, this uses the orderedhash gem to simulate an
+    # order-preserving hash. On Ruby 1.9 and up, it just uses the native Hash
+    # class, since that preserves the order itself.
+    #
+    # @overload ordered_hash(hash)
+    #   @param hash [Hash] a normal hash to convert to an ordered hash
+    #   @return [Hash]
+    # @overload ordered_hash(*pairs)
+    #   @example
+    #     ordered_hash([:foo, "bar"], [:baz, "bang"])
+    #       #=> {:foo => "bar", :baz => "bang"}
+    #     ordered_hash #=> {}
+    #   @param pairs [Array<(Object, Object)>] the list of key/value pairs for
+    #     the hash.
+    #   @return [Hash]
+    def ordered_hash(*pairs_or_hash)
+      require 'sass/util/ordered_hash' if ruby1_8?
+
+      if pairs_or_hash.length == 1 && pairs_or_hash.first.is_a?(Hash)
+        hash = pairs_or_hash.first
+        return hash unless ruby1_8?
+        return OrderedHash.new.merge hash
+      end
+
+      return Hash[pairs_or_hash] unless ruby1_8?
+      return OrderedHash[*flatten(pairs_or_hash, 1)]
+    end
+
     # Converts an array of `[key, value]` pairs to a hash.
     #
     # @example
@@ -38,7 +68,7 @@ module Sass
     # @param arr [Array<(Object, Object)>] An array of pairs
     # @return [Hash] A hash
     def to_hash(arr)
-      Hash[arr.compact]
+      ordered_hash(*arr.compact)
     end
 
     # Maps the keys in a hash according to a block.
@@ -1008,3 +1038,4 @@ MSG
 end
 
 require 'sass/util/multibyte_string_scanner'
+require 'sass/util/normalized_map'

data/lib/sass/util/normalized_map.rb

@@ -0,0 +1,65 @@
+require 'delegate'
+require 'sass/util'
+
+module Sass
+  module Util
+    # A hash that normalizes its string keys while still allowing you to get back
+    # to the original keys that were stored. If several different values normalize
+    # to the same value, whichever is stored last wins.
+    require 'sass/util/ordered_hash' if ruby1_8?
+    class NormalizedMap < DelegateClass(ruby1_8? ? OrderedHash : Hash)
+      # Create a normalized map
+      def initialize
+        @key_strings = {}
+        @map = Util.ruby1_8? ? OrderedHash.new : {}
+
+        # We delegate all hash methods that are not overridden here to @map.
+        super(@map)
+      end
+
+      # Specifies how to transform the key.
+      #
+      # This can be overridden to create other normalization behaviors.
+      def normalize(key)
+        key.tr("-", "_")
+      end
+
+      # @private
+      def []=(k, v)
+        normalized = normalize(k)
+        super(normalized, v)
+        @key_strings[normalized] = k
+      end
+
+      # @private
+      def [](k)
+        super(normalize(k))
+      end
+
+      # @private
+      def has_key?(k)
+        super(normalize(k))
+      end
+
+      # @private
+      def delete(k)
+        normalized = normalize(k)
+        @key_strings.delete(normalized)
+        super(normalized)
+      end
+
+      # @return [Hash] Hash with the keys as they were stored (before normalization).
+      def as_stored
+        Sass::Util.map_keys(@map) {|k| @key_strings[k]}
+      end
+
+      # this is magically invoked by ruby, not sure why DelegateClass doesn't take care of it.
+      # @private
+      def initialize_dup(other)
+        super
+        @map = other.instance_variable_get("@map").dup
+        __setobj__(@map)
+      end
+    end
+  end
+end

data/lib/sass/util/ordered_hash.rb

@@ -0,0 +1,186 @@
+# Copyright (c) 2005-2013 David Heinemeier Hansson
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# This class was copied from an old version of ActiveSupport.
+class OrderedHash < ::Hash
+  # In MRI the Hash class is core and written in C. In particular, methods are
+  # programmed with explicit C function calls and polymorphism is not honored.
+  #
+  # For example, []= is crucial in this implementation to maintain the @keys
+  # array but hash.c invokes rb_hash_aset() originally. This prevents method
+  # reuse through inheritance and forces us to reimplement stuff.
+  #
+  # For instance, we cannot use the inherited #merge! because albeit the algorithm
+  # itself would work, our []= is not being called at all by the C code.
+
+  def initialize(*args, &block)
+    super
+    @keys = []
+  end
+
+  def self.[](*args)
+    ordered_hash = new
+
+    if (args.length == 1 && args.first.is_a?(Array))
+      args.first.each do |key_value_pair|
+        next unless (key_value_pair.is_a?(Array))
+        ordered_hash[key_value_pair[0]] = key_value_pair[1]
+      end
+
+      return ordered_hash
+    end
+
+    unless (args.size % 2 == 0)
+      raise ArgumentError.new("odd number of arguments for Hash")
+    end
+
+    args.each_with_index do |val, ind|
+      next if (ind % 2 != 0)
+      ordered_hash[val] = args[ind + 1]
+    end
+
+    ordered_hash
+  end
+
+  def initialize_copy(other)
+    super
+    # make a deep copy of keys
+    @keys = other.keys
+  end
+
+  def []=(key, value)
+    @keys << key unless has_key?(key)
+    super
+  end
+
+  def delete(key)
+    if has_key? key
+      index = @keys.index(key)
+      @keys.delete_at index
+    end
+    super
+  end
+
+  def delete_if
+    super
+    sync_keys!
+    self
+  end
+
+  def reject!
+    super
+    sync_keys!
+    self
+  end
+
+  def reject(&block)
+    dup.reject!(&block)
+  end
+
+  def keys
+    @keys.dup
+  end
+
+  def values
+    @keys.collect { |key| self[key] }
+  end
+
+  def to_hash
+    self
+  end
+
+  def to_a
+    @keys.map { |key| [ key, self[key] ] }
+  end
+
+  def each_key
+    return to_enum(:each_key) unless block_given?
+    @keys.each { |key| yield key }
+    self
+  end
+
+  def each_value
+    return to_enum(:each_value) unless block_given?
+    @keys.each { |key| yield self[key]}
+    self
+  end
+
+  def each
+    return to_enum(:each) unless block_given?
+    @keys.each {|key| yield [key, self[key]]}
+    self
+  end
+
+  def each_pair
+    return to_enum(:each_pair) unless block_given?
+    @keys.each {|key| yield key, self[key]}
+    self
+  end
+
+  alias_method :select, :find_all
+
+  def clear
+    super
+    @keys.clear
+    self
+  end
+
+  def shift
+    k = @keys.first
+    v = delete(k)
+    [k, v]
+  end
+
+  def merge!(other_hash)
+    if block_given?
+      other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
+    else
+      other_hash.each { |k, v| self[k] = v }
+    end
+    self
+  end
+
+  alias_method :update, :merge!
+
+  def merge(other_hash, &block)
+    dup.merge!(other_hash, &block)
+  end
+
+  # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
+  def replace(other)
+    super
+    @keys = other.keys
+    self
+  end
+
+  def invert
+    OrderedHash[self.to_a.map!{|key_value_pair| key_value_pair.reverse}]
+  end
+
+  def inspect
+    "#<OrderedHash #{super}>"
+  end
+
+  private
+    def sync_keys!
+      @keys.delete_if {|k| !has_key?(k)}
+    end
+end

data/test/sass/conversion_test.rb

@@ -1714,6 +1714,34 @@ foo {
 SCSS
   end
 
+  def test_keyword_arguments
+    assert_renders(<<SASS, <<SCSS, :dasherize => true)
+$foo: foo($dash-ed: 2px)
+SASS
+$foo: foo($dash-ed: 2px);
+SCSS
+    assert_scss_to_sass(<<SASS, <<SCSS, :dasherize => true)
+$foo: foo($dash-ed: 2px)
+SASS
+$foo: foo($dash_ed: 2px);
+SCSS
+    assert_sass_to_scss(<<SCSS, <<SASS, :dasherize => true)
+$foo: foo($dash-ed: 2px);
+SCSS
+$foo: foo($dash_ed: 2px)
+SASS
+    assert_renders(<<SASS, <<SCSS)
+$foo: foo($under_scored: 1px)
+SASS
+$foo: foo($under_scored: 1px);
+SCSS
+    assert_renders(<<SASS, <<SCSS)
+$foo: foo($dash-ed: 2px, $under_scored: 1px)
+SASS
+$foo: foo($dash-ed: 2px, $under_scored: 1px);
+SCSS
+  end
+
   private
 
   def assert_sass_to_sass(sass, options = {})

data/test/sass/util/normalized_map_test.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'sass/util/normalized_map'
+
+class NormalizedMapTest < Test::Unit::TestCase
+  def test_basic_lifecycle
+    m = Sass::Util::NormalizedMap.new
+    m["a-b"] = 1
+    assert_equal ["a_b"], m.keys
+    assert_equal 1, m["a_b"]
+    assert_equal 1, m["a-b"]
+    assert m.has_key?("a_b")
+    assert m.has_key?("a-b")
+    assert_equal({"a-b" => 1}, m.as_stored)
+    assert_equal 1, m.delete("a-b")
+    assert !m.has_key?("a-b")
+    m["a_b"] = 2
+    assert_equal({"a_b" => 2}, m.as_stored)
+  end
+
+  def test_dup
+    m = Sass::Util::NormalizedMap.new
+    m["a-b"] = 1
+    m2 = m.dup
+    m.delete("a-b")
+    assert !m.has_key?("a-b")
+    assert m2.has_key?("a-b")
+  end
+
+end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  hash: 592302777
+  hash: 592302769
   prerelease: 6
   segments: 
   - 3
   - 3
   - 0
   - alpha
-  - 218
-  version: 3.3.0.alpha.218
+  - 222
+  version: 3.3.0.alpha.222
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -19,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-07-26 00:00:00 -04:00
+date: 2013-07-30 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -195,6 +195,8 @@ files:
 - lib/sass/util/multibyte_string_scanner.rb
 - lib/sass/util/subset_map.rb
 - lib/sass/util/test.rb
+- lib/sass/util/normalized_map.rb
+- lib/sass/util/ordered_hash.rb
 - lib/sass/version.rb
 - lib/sass/features.rb
 - bin/sass
@@ -317,6 +319,7 @@ files:
 - test/sass/test_helper.rb
 - test/sass/util/multibyte_string_scanner_test.rb
 - test/sass/util/subset_map_test.rb
+- test/sass/util/normalized_map_test.rb
 - test/sass/source_map_test.rb
 - test/test_helper.rb
 - extra/update_watch.rb
@@ -389,4 +392,5 @@ test_files:
 - test/sass/compiler_test.rb
 - test/sass/util/multibyte_string_scanner_test.rb
 - test/sass/util/subset_map_test.rb
+- test/sass/util/normalized_map_test.rb
 - test/sass/source_map_test.rb