sass 3.1.0.alpha.210 → 3.1.0.alpha.212

data/REVISION

@@ -1 +1 @@
-d759347f1299f579d7b5dc2f0f5f30b895168c38
+ebf9e326dafba548aef36fe36945d97a9dd590d9

data/VERSION

@@ -1 +1 @@
-3.1.0.alpha.210
+3.1.0.alpha.212

data/lib/sass/cache_stores.rb

@@ -12,3 +12,4 @@ end
 require 'sass/cache_stores/base'
 require 'sass/cache_stores/filesystem'
 require 'sass/cache_stores/memory'
+require 'sass/cache_stores/chain'

data/lib/sass/cache_stores/base.rb

@@ -48,7 +48,7 @@ module Sass
       # @param sha [String] The checksum for the contents that are being stored.
       # @param obj [Object] The object to cache.
       def store(key, sha, root)
-        _store(key, Sass::VERSION, sha, Sass::Util.dump(root))
+        _store(key, Sass::VERSION, sha, Marshal.dump(root))
       end
 
       # Retrieve a {Sass::Tree::RootNode}.
@@ -58,7 +58,7 @@ module Sass
       # @return [Object] The cached object.
       def retrieve(key, sha)
         contents = _retrieve(key, Sass::VERSION, sha)
-        Sass::Util.load(contents) if contents
+        Marshal.load(contents) if contents
       rescue EOFError, TypeError, ArgumentError => e
         Sass::Util.sass_warn "Warning. Error encountered while reading cache #{path_to(key)}: #{e}"
       end

data/lib/sass/cache_stores/chain.rb

@@ -0,0 +1,33 @@
+module Sass
+  module CacheStores
+    # A meta-cache that chains multiple caches together.
+    # Specifically:
+    #
+    # * All `#store`s are passed to all caches.
+    # * `#retrieve`s are passed to each cache until one has a hit.
+    # * When one cache has a hit, the value is `#store`d in all earlier caches.
+    class Chain < Base
+      # Create a new cache chaining the given caches.
+      #
+      # @param caches [Array<Sass::CacheStores::Base>] The caches to chain.
+      def initialize(*caches)
+        @caches = caches
+      end
+
+      # @see Base#store
+      def store(key, sha, obj)
+        @caches.each {|c| c.store(key, sha, obj)}
+      end
+
+      # @see Base#retrieve
+      def retrieve(key, sha)
+        @caches.each_with_index do |c, i|
+          next unless obj = c.retrieve(key, sha)
+          @caches[0...i].each {|c| c.store(key, sha, obj)}
+          return obj
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/sass/cache_stores/memory.rb

@@ -24,22 +24,18 @@ module Sass
         @contents = {}
       end
 
-      # @see Base#_retrieve
-      def _retrieve(key, version, sha)
+      # @see Base#retrieve
+      def retrieve(key, sha)
         if @contents.has_key?(key)
-          return unless @contents[key][:version] == version
           return unless @contents[key][:sha] == sha
-          return @contents[key][:contents]
+          obj = @contents[key][:obj]
+          obj.respond_to?(:deep_copy) ? obj.deep_copy : obj.dup
         end
       end
-      
-      # @see Base#_store
-      def _store(key, version, sha, contents)
-        @contents[key] = {
-          :version => version,
-          :sha => sha,
-          :contents => contents
-        }
+
+      # @see Base#store
+      def store(key, sha, obj)
+        @contents[key] = {:sha => sha, :obj => obj}
       end
       
       # Destructively clear the cache.

data/lib/sass/engine.rb

@@ -164,7 +164,8 @@ module Sass
       # Tracks the original filename of the top-level Sass file
       options[:original_filename] = options[:original_filename] || options[:filename]
 
-      options[:cache_store] ||= Sass::CacheStores::Filesystem.new(options[:cache_location])
+      options[:cache_store] ||= Sass::CacheStores::Chain.new(
+        Sass::CacheStores::Memory.new, Sass::CacheStores::Filesystem.new(options[:cache_location]))
       # Support both, because the docs said one and the other actually worked
       # for quite a long time.
       options[:line_comments] ||= options[:line_numbers]
@@ -333,7 +334,15 @@ module Sass
       end
 
       root.options = @options
-      @options[:cache_store].store(key, sha, root) if @options[:cache] && key && sha
+      if @options[:cache] && key && sha
+        begin
+          old_options = root.options
+          root.options = {:importer => root.options[:importer]}
+          @options[:cache_store].store(key, sha, root)
+        ensure
+          root.options = old_options
+        end
+      end
       root
     rescue SyntaxError => e
       e.modify_backtrace(:filename => @options[:filename], :line => @line)

data/lib/sass/script/functions.rb

@@ -90,9 +90,15 @@ module Sass::Script
   #
   # ## Other Color Functions
   #
-  # \{#adjust adjust($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
+  # \{#adjust adjust-color($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
   # : Increase or decrease any of the components of a color.
   #
+  # \{#scale_color scale-color($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
+  # : Fluidly scale one or more components of a color.
+  #
+  # \{#change_color change-color($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
+  # : Changes one or more properties of a color.
+  #
   # ## String Functions
   #
   # \{#unquote unquote($string)}
@@ -729,9 +735,9 @@ module Sass::Script
     # and HSL properties (`$hue`, `$saturation`, `$value`) at the same time.
     #
     # @example
-    #   adjust(#102030, $blue: 5) => #102035
-    #   adjust(#102030, $red: -5, $blue: 5) => #0b2035
-    #   adjust(hsl(25, 100%, 80%), $lightness: -30%, $alpha: -0.4) => hsla(25, 100%, 50%, 0.6)
+    #   adjust-color(#102030, $blue: 5) => #102035
+    #   adjust-color(#102030, $red: -5, $blue: 5) => #0b2035
+    #   adjust-color(hsl(25, 100%, 80%), $lightness: -30%, $alpha: -0.4) => hsla(25, 100%, 50%, 0.6)
     # @param color [Color]
     # @param red [Number]
     # @param green [Number]
@@ -746,7 +752,7 @@ module Sass::Script
     #   if any keyword argument is not in the legal range,
     #   if an unexpected keyword argument is given,
     #   or if both HSL and RGB properties are given.
-    def adjust(color, kwargs)
+    def adjust_color(color, kwargs)
       assert_type color, :Color
       with = Sass::Util.map_hash({
           "red" => [-255..255, ""],
@@ -775,7 +781,7 @@ module Sass::Script
 
       color.with(with)
     end
-    declare :adjust, [:color], :var_kwargs => true
+    declare :adjust_color, [:color], :var_kwargs => true
 
     # Scales one or more properties of a color by a percentage value.
     # Unlike \{#adjust}, which changes a color's properties by fixed amounts,
@@ -783,13 +789,13 @@ module Sass::Script
     # That means that lightening an already-light color with \{#scale}
     # won't change the lightness much,
     # but lightening a dark color by the same amount will change it more dramatically.
-    # This has the benefit of making `scale($color, ...)` have a similar effect
+    # This has the benefit of making `scale-color($color, ...)` have a similar effect
     # regardless of what `$color` is.
     #
     # For example, the lightness of a color can be anywhere between 0 and 100.
-    # If `scale($color, $lightness: 40%)` is called, the resulting color's lightness
+    # If `scale-color($color, $lightness: 40%)` is called, the resulting color's lightness
     # will be 40% of the way between its original lightness and 100.
-    # If `scale($color, $lightness: -40%)` is called instead,
+    # If `scale-color($color, $lightness: -40%)` is called instead,
     # the lightness will be 40% of the way between the original and 0.
     #
     # This can change the red, green, blue, saturation, value, and alpha properties.
@@ -801,9 +807,9 @@ module Sass::Script
     # and HSL properties (`$saturation`, `$value`) at the same time.
     #
     # @example
-    #   scale(hsl(120, 70, 80), $lightness: 50%) => hsl(120, 70, 90)
-    #   scale(rgb(200, 150, 170), $green: -40%, $blue: 70%) => rgb(200, 90, 229)
-    #   scale(hsl(200, 70, 80), $saturation: -90%, $alpha: -30%) => hsla(200, 7, 80, 0.7)
+    #   scale-color(hsl(120, 70, 80), $lightness: 50%) => hsl(120, 70, 90)
+    #   scale-color(rgb(200, 150, 170), $green: -40%, $blue: 70%) => rgb(200, 90, 229)
+    #   scale-color(hsl(200, 70, 80), $saturation: -90%, $alpha: -30%) => hsla(200, 7, 80, 0.7)
     # @param color [Color]
     # @param red [Number]
     # @param green [Number]
@@ -816,7 +822,7 @@ module Sass::Script
     #   if any keyword argument is not a percentage between 0% and 100%,
     #   if an unexpected keyword argument is given,
     #   or if both HSL and RGB properties are given.
-    def scale(color, kwargs)
+    def scale_color(color, kwargs)
       assert_type color, :Color
       with = Sass::Util.map_hash({
           "red" => 255,
@@ -848,10 +854,10 @@ module Sass::Script
 
       color.with(with)
     end
-    declare :scale, [:color], :var_kwargs => true
+    declare :scale_color, [:color], :var_kwargs => true
 
-    # Sets one or more properties of a color.
-    # This can set the red, green, blue, hue, saturation, value, and alpha properties.
+    # Changes one or more properties of a color.
+    # This can change the red, green, blue, hue, saturation, value, and alpha properties.
     # The properties are specified as keyword arguments,
     # and replace the color's current value for that property.
     #
@@ -864,9 +870,9 @@ module Sass::Script
     # and HSL properties (`$hue`, `$saturation`, `$value`) at the same time.
     #
     # @example
-    #   set(#102030, $blue: 5) => #102005
-    #   set(#102030, $red: 120, $blue: 5) => #782005
-    #   set(hsl(25, 100%, 80%), $lightness: 40%, $alpha: 0.8) => hsla(25, 100%, 40%, 0.8)
+    #   change-color(#102030, $blue: 5) => #102005
+    #   change-color(#102030, $red: 120, $blue: 5) => #782005
+    #   change-color(hsl(25, 100%, 80%), $lightness: 40%, $alpha: 0.8) => hsla(25, 100%, 40%, 0.8)
     # @param color [Color]
     # @param red [Number]
     # @param green [Number]
@@ -881,7 +887,7 @@ module Sass::Script
     #   if any keyword argument is not in the legal range,
     #   if an unexpected keyword argument is given,
     #   or if both HSL and RGB properties are given.
-    def set(color, kwargs)
+    def change_color(color, kwargs)
       assert_type color, :Color
       with = Sass::Util.map_hash(%w[red green blue hue saturation lightness alpha]) do |name, max|
         next unless val = kwargs.delete(name)
@@ -896,7 +902,7 @@ module Sass::Script
 
       color.with(with)
     end
-    declare :set, [:color], :var_kwargs => true
+    declare :change_color, [:color], :var_kwargs => true
 
     # Mixes together two colors.
     # Specifically, takes the average of each of the RGB components,

data/lib/sass/tree/if_node.rb

@@ -41,23 +41,22 @@ module Sass::Tree
       self.else.options = options if self.else
     end
 
-    # @see Node#_around_dump
-    def _around_dump
-      old_else = @else
-      old_last_else = @last_else
-      @else = Sass::Util.dump(@else)
-      @last_else = (self == @last_else ? nil : Sass::Util.dump(@last_else))
-      super
-    ensure
-      @else = old_else
-      @last_else = old_last_else
+    def _dump(f)
+      Marshal.dump([self.expr, self.else])
     end
 
-    # @see Node#_after_load
-    def _after_load
-      super
-      @else = Sass::Util.load(@else)
-      @last_else = (@last_else ? Sass::Util.load(@last_else) : self)
+    def self._load(data)
+      expr, else_ = Marshal.load(data)
+      node = IfNode.new(expr)
+      node.else = else_
+      node
+    end
+
+    # @see Node#deep_copy
+    def deep_copy
+      node = super
+      node.else = self.else.deep_copy if self.else
+      node
     end
   end
 end

data/lib/sass/tree/node.rb

@@ -180,29 +180,14 @@ module Sass
         Sass::Tree::Visitors::Convert.visit(self, options, :scss)
       end
 
-      # Names of options that are saved when the node is serialized and cached.
-      SAVED_OPTIONS = [:importer]
-
-      # Ensures that only {SAVED_OPTIONS} get saved.
-      def _around_dump
-        old_options = @options
-        old_children = @children
-        @options = {}
-        SAVED_OPTIONS.each do |opt|
-          @options[opt] = old_options[opt]
-        end
-        @options = Sass::Util.dump(@options)
-        @children = Sass::Util.dump(@children)
-        yield
-      ensure
-        @options = old_options
-        @children = old_children
-      end
-
-      # Ensures that only {SAVED_OPTIONS} get saved.
-      def _after_load
-        @options = Sass::Util.load(@options)
-        @children = Sass::Util.load(@children)
+      # Return a deep clone of this node.
+      # The child nodes are cloned, but options are not.
+      #
+      # @return [Node]
+      def deep_copy
+        node = dup
+        node.children = children.map {|c| c.deep_copy}
+        node
       end
 
       protected

data/lib/sass/util.rb

@@ -270,47 +270,6 @@ module Sass
       version_gt(v1, v2) || !version_gt(v2, v1)
     end
 
-    # A wrapper for `Marshal.dump` that calls `#_before_dump` on the object
-    # before dumping it, `#_after_dump` afterwards.
-    # It also calls `#_around_dump` and passes it a block in which the object is dumped.
-    #
-    # If any of these methods are undefined, they are not called.
-    #
-    # This will recursively call itself on members of arrays and hashes,
-    # but not of user-defined objects.
-    # This means that user-defined objects that need their members' `#_before_dump` etc. methods called
-    # must call `Haml::Util.dump` and `Haml::Util.load` manually on those members.
-    #
-    # @param obj [Object] The object to dump.
-    # @return [String] The dumped data.
-    def dump(obj)
-      obj._before_dump if obj.respond_to?(:_before_dump)
-      return convert_and_dump(obj) unless obj.respond_to?(:_around_dump)
-      res = nil
-      obj._around_dump {res = convert_and_dump(obj)}
-      res
-    ensure
-      obj._after_dump if obj.respond_to?(:_after_dump)
-    end
-
-    # A wrapper for `Marshal.load` that calls `#_after_load` on the object
-    # after loading it, if it's defined.
-    #
-    # @param data [String] The data to load.
-    # @return [Object] The loaded object.
-    def load(data)
-      obj = Marshal.load(data)
-
-      if obj.is_a?(Array)
-        obj = obj.map {|e| Sass::Util.load(e)}
-      elsif obj.is_a?(Hash)
-        obj = map_hash(obj) {|k, v| [Sass::Util.load(k), Sass::Util.load(v)]}
-      end
-
-      obj._after_load if obj.respond_to?(:_after_load)
-      obj
-    end
-
     # Throws a NotImplementedError for an abstract method.
     #
     # @param obj [Object] `self`
@@ -706,14 +665,5 @@ MSG
       return lcs_backtrace(c, x, y, i, j-1, &block) if c[i][j-1] > c[i-1][j]
       return lcs_backtrace(c, x, y, i-1, j, &block)
     end
-
-    def convert_and_dump(obj)
-      if obj.is_a?(Array)
-        obj = obj.map {|e| dump(e)}
-      elsif obj.is_a?(Hash)
-        obj = map_hash(obj) {|k, v| [dump(k), dump(v)]}
-      end
-      Marshal.dump(obj)
-    end
   end
 end

data/test/sass/functions_test.rb

@@ -461,274 +461,274 @@ class SassFunctionTest < Test::Unit::TestCase
     assert_error_message("\"foo\" is not a number for `adjust-hue'", "adjust-hue(#fff, \"foo\")")
   end
 
-  def test_adjust
+  def test_adjust_color
     # HSL
     assert_equal(evaluate("hsl(180, 30, 90)"),
-      evaluate("adjust(hsl(120, 30, 90), $hue: 60deg)"))
+      evaluate("adjust-color(hsl(120, 30, 90), $hue: 60deg)"))
     assert_equal(evaluate("hsl(120, 50, 90)"),
-      evaluate("adjust(hsl(120, 30, 90), $saturation: 20%)"))
+      evaluate("adjust-color(hsl(120, 30, 90), $saturation: 20%)"))
     assert_equal(evaluate("hsl(120, 30, 60)"),
-      evaluate("adjust(hsl(120, 30, 90), $lightness: -30%)"))
+      evaluate("adjust-color(hsl(120, 30, 90), $lightness: -30%)"))
     # RGB
     assert_equal(evaluate("rgb(15, 20, 30)"),
-      evaluate("adjust(rgb(10, 20, 30), $red: 5)"))
+      evaluate("adjust-color(rgb(10, 20, 30), $red: 5)"))
     assert_equal(evaluate("rgb(10, 15, 30)"),
-      evaluate("adjust(rgb(10, 20, 30), $green: -5)"))
+      evaluate("adjust-color(rgb(10, 20, 30), $green: -5)"))
     assert_equal(evaluate("rgb(10, 20, 40)"),
-      evaluate("adjust(rgb(10, 20, 30), $blue: 10)"))
+      evaluate("adjust-color(rgb(10, 20, 30), $blue: 10)"))
     # Alpha
     assert_equal(evaluate("hsla(120, 30, 90, 0.65)"),
-      evaluate("adjust(hsl(120, 30, 90), $alpha: -0.35)"))
+      evaluate("adjust-color(hsl(120, 30, 90), $alpha: -0.35)"))
     assert_equal(evaluate("rgba(10, 20, 30, 0.9)"),
-      evaluate("adjust(rgba(10, 20, 30, 0.4), $alpha: 0.5)"))
+      evaluate("adjust-color(rgba(10, 20, 30, 0.4), $alpha: 0.5)"))
 
     # HSL composability
     assert_equal(evaluate("hsl(180, 20, 90)"),
-      evaluate("adjust(hsl(120, 30, 90), $hue: 60deg, $saturation: -10%)"))
+      evaluate("adjust-color(hsl(120, 30, 90), $hue: 60deg, $saturation: -10%)"))
     assert_equal(evaluate("hsl(180, 20, 95)"),
-      evaluate("adjust(hsl(120, 30, 90), $hue: 60deg, $saturation: -10%, $lightness: 5%)"))
+      evaluate("adjust-color(hsl(120, 30, 90), $hue: 60deg, $saturation: -10%, $lightness: 5%)"))
     assert_equal(evaluate("hsla(120, 20, 95, 0.3)"),
-      evaluate("adjust(hsl(120, 30, 90), $saturation: -10%, $lightness: 5%, $alpha: -0.7)"))
+      evaluate("adjust-color(hsl(120, 30, 90), $saturation: -10%, $lightness: 5%, $alpha: -0.7)"))
 
     # RGB composability
     assert_equal(evaluate("rgb(15, 20, 29)"),
-      evaluate("adjust(rgb(10, 20, 30), $red: 5, $blue: -1)"))
+      evaluate("adjust-color(rgb(10, 20, 30), $red: 5, $blue: -1)"))
     assert_equal(evaluate("rgb(15, 45, 29)"),
-      evaluate("adjust(rgb(10, 20, 30), $red: 5, $green: 25, $blue: -1)"))
+      evaluate("adjust-color(rgb(10, 20, 30), $red: 5, $green: 25, $blue: -1)"))
     assert_equal(evaluate("rgba(10, 25, 29, 0.7)"),
-      evaluate("adjust(rgb(10, 20, 30), $green: 5, $blue: -1, $alpha: -0.3)"))
+      evaluate("adjust-color(rgb(10, 20, 30), $green: 5, $blue: -1, $alpha: -0.3)"))
 
     # HSL range restriction
     assert_equal(evaluate("hsl(120, 30, 90)"),
-      evaluate("adjust(hsl(120, 30, 90), $hue: 720deg)"))
+      evaluate("adjust-color(hsl(120, 30, 90), $hue: 720deg)"))
     assert_equal(evaluate("hsl(120, 0, 90)"),
-      evaluate("adjust(hsl(120, 30, 90), $saturation: -90%)"))
+      evaluate("adjust-color(hsl(120, 30, 90), $saturation: -90%)"))
     assert_equal(evaluate("hsl(120, 30, 100)"),
-      evaluate("adjust(hsl(120, 30, 90), $lightness: 30%)"))
+      evaluate("adjust-color(hsl(120, 30, 90), $lightness: 30%)"))
 
     # RGB range restriction
     assert_equal(evaluate("rgb(255, 20, 30)"),
-      evaluate("adjust(rgb(10, 20, 30), $red: 250)"))
+      evaluate("adjust-color(rgb(10, 20, 30), $red: 250)"))
     assert_equal(evaluate("rgb(10, 0, 30)"),
-      evaluate("adjust(rgb(10, 20, 30), $green: -30)"))
+      evaluate("adjust-color(rgb(10, 20, 30), $green: -30)"))
     assert_equal(evaluate("rgb(10, 20, 0)"),
-      evaluate("adjust(rgb(10, 20, 30), $blue: -40)"))
+      evaluate("adjust-color(rgb(10, 20, 30), $blue: -40)"))
   end
 
-  def test_adjust_tests_types
-    assert_error_message("\"foo\" is not a color for `adjust'", "adjust(foo, $hue: 10)")
+  def test_adjust_color_tests_types
+    assert_error_message("\"foo\" is not a color for `adjust-color'", "adjust-color(foo, $hue: 10)")
     # HSL
-    assert_error_message("$hue: \"foo\" is not a number for `adjust'",
-      "adjust(blue, $hue: foo)")
-    assert_error_message("$saturation: \"foo\" is not a number for `adjust'",
-      "adjust(blue, $saturation: foo)")
-    assert_error_message("$lightness: \"foo\" is not a number for `adjust'",
-      "adjust(blue, $lightness: foo)")
+    assert_error_message("$hue: \"foo\" is not a number for `adjust-color'",
+      "adjust-color(blue, $hue: foo)")
+    assert_error_message("$saturation: \"foo\" is not a number for `adjust-color'",
+      "adjust-color(blue, $saturation: foo)")
+    assert_error_message("$lightness: \"foo\" is not a number for `adjust-color'",
+      "adjust-color(blue, $lightness: foo)")
     # RGB
-    assert_error_message("$red: \"foo\" is not a number for `adjust'",
-      "adjust(blue, $red: foo)")
-    assert_error_message("$green: \"foo\" is not a number for `adjust'",
-      "adjust(blue, $green: foo)")
-    assert_error_message("$blue: \"foo\" is not a number for `adjust'",
-      "adjust(blue, $blue: foo)")
+    assert_error_message("$red: \"foo\" is not a number for `adjust-color'",
+      "adjust-color(blue, $red: foo)")
+    assert_error_message("$green: \"foo\" is not a number for `adjust-color'",
+      "adjust-color(blue, $green: foo)")
+    assert_error_message("$blue: \"foo\" is not a number for `adjust-color'",
+      "adjust-color(blue, $blue: foo)")
     # Alpha
-    assert_error_message("$alpha: \"foo\" is not a number for `adjust'",
-      "adjust(blue, $alpha: foo)")
+    assert_error_message("$alpha: \"foo\" is not a number for `adjust-color'",
+      "adjust-color(blue, $alpha: foo)")
   end
 
-  def test_adjust_tests_arg_range
+  def test_adjust_color_tests_arg_range
     # HSL
-    assert_error_message("$saturation: Amount 101% must be between -100% and 100% for `adjust'",
-      "adjust(blue, $saturation: 101%)")
-    assert_error_message("$saturation: Amount -101% must be between -100% and 100% for `adjust'",
-      "adjust(blue, $saturation: -101%)")
-    assert_error_message("$lightness: Amount 101% must be between -100% and 100% for `adjust'",
-      "adjust(blue, $lightness: 101%)")
-    assert_error_message("$lightness: Amount -101% must be between -100% and 100% for `adjust'",
-      "adjust(blue, $lightness: -101%)")
+    assert_error_message("$saturation: Amount 101% must be between -100% and 100% for `adjust-color'",
+      "adjust-color(blue, $saturation: 101%)")
+    assert_error_message("$saturation: Amount -101% must be between -100% and 100% for `adjust-color'",
+      "adjust-color(blue, $saturation: -101%)")
+    assert_error_message("$lightness: Amount 101% must be between -100% and 100% for `adjust-color'",
+      "adjust-color(blue, $lightness: 101%)")
+    assert_error_message("$lightness: Amount -101% must be between -100% and 100% for `adjust-color'",
+      "adjust-color(blue, $lightness: -101%)")
     # RGB
-    assert_error_message("$red: Amount 256 must be between -255 and 255 for `adjust'",
-      "adjust(blue, $red: 256)")
-    assert_error_message("$red: Amount -256 must be between -255 and 255 for `adjust'",
-      "adjust(blue, $red: -256)")
-    assert_error_message("$green: Amount 256 must be between -255 and 255 for `adjust'",
-      "adjust(blue, $green: 256)")
-    assert_error_message("$green: Amount -256 must be between -255 and 255 for `adjust'",
-      "adjust(blue, $green: -256)")
-    assert_error_message("$blue: Amount 256 must be between -255 and 255 for `adjust'",
-      "adjust(blue, $blue: 256)")
-    assert_error_message("$blue: Amount -256 must be between -255 and 255 for `adjust'",
-      "adjust(blue, $blue: -256)")
+    assert_error_message("$red: Amount 256 must be between -255 and 255 for `adjust-color'",
+      "adjust-color(blue, $red: 256)")
+    assert_error_message("$red: Amount -256 must be between -255 and 255 for `adjust-color'",
+      "adjust-color(blue, $red: -256)")
+    assert_error_message("$green: Amount 256 must be between -255 and 255 for `adjust-color'",
+      "adjust-color(blue, $green: 256)")
+    assert_error_message("$green: Amount -256 must be between -255 and 255 for `adjust-color'",
+      "adjust-color(blue, $green: -256)")
+    assert_error_message("$blue: Amount 256 must be between -255 and 255 for `adjust-color'",
+      "adjust-color(blue, $blue: 256)")
+    assert_error_message("$blue: Amount -256 must be between -255 and 255 for `adjust-color'",
+      "adjust-color(blue, $blue: -256)")
     # Alpha
-    assert_error_message("$alpha: Amount 1.1 must be between -1 and 1 for `adjust'",
-      "adjust(blue, $alpha: 1.1)")
-    assert_error_message("$alpha: Amount -1.1 must be between -1 and 1 for `adjust'",
-      "adjust(blue, $alpha: -1.1)")
-  end
-
-  def test_adjust_argument_errors
-    assert_error_message("Unknown argument $hoo (260deg) for `adjust'",
-      "adjust(blue, $hoo: 260deg)")
-    assert_error_message("Cannot specify HSL and RGB values for a color at the same time for `adjust'",
-      "adjust(blue, $hue: 120deg, $red: 10)");
-    assert_error_message("10px is not a keyword argument for `adjust'",
-      "adjust(blue, 10px)")
-    assert_error_message("10px is not a keyword argument for `adjust'",
-      "adjust(blue, 10px, 20px)")
-    assert_error_message("10px is not a keyword argument for `adjust'",
-      "adjust(blue, 10px, $hue: 180deg)")
-  end
-
-  def test_scale
+    assert_error_message("$alpha: Amount 1.1 must be between -1 and 1 for `adjust-color'",
+      "adjust-color(blue, $alpha: 1.1)")
+    assert_error_message("$alpha: Amount -1.1 must be between -1 and 1 for `adjust-color'",
+      "adjust-color(blue, $alpha: -1.1)")
+  end
+
+  def test_adjust_color_argument_errors
+    assert_error_message("Unknown argument $hoo (260deg) for `adjust-color'",
+      "adjust-color(blue, $hoo: 260deg)")
+    assert_error_message("Cannot specify HSL and RGB values for a color at the same time for `adjust-color'",
+      "adjust-color(blue, $hue: 120deg, $red: 10)");
+    assert_error_message("10px is not a keyword argument for `adjust_color'",
+      "adjust-color(blue, 10px)")
+    assert_error_message("10px is not a keyword argument for `adjust_color'",
+      "adjust-color(blue, 10px, 20px)")
+    assert_error_message("10px is not a keyword argument for `adjust_color'",
+      "adjust-color(blue, 10px, $hue: 180deg)")
+  end
+
+  def test_scale_color
     # HSL
     assert_equal(evaluate("hsl(120, 51, 90)"),
-      evaluate("scale(hsl(120, 30, 90), $saturation: 30%)"))
+      evaluate("scale-color(hsl(120, 30, 90), $saturation: 30%)"))
     assert_equal(evaluate("hsl(120, 30, 76.5)"),
-      evaluate("scale(hsl(120, 30, 90), $lightness: -15%)"))
+      evaluate("scale-color(hsl(120, 30, 90), $lightness: -15%)"))
     # RGB
     assert_equal(evaluate("rgb(157, 20, 30)"),
-      evaluate("scale(rgb(10, 20, 30), $red: 60%)"))
+      evaluate("scale-color(rgb(10, 20, 30), $red: 60%)"))
     assert_equal(evaluate("rgb(10, 38.8, 30)"),
-      evaluate("scale(rgb(10, 20, 30), $green: 8%)"))
+      evaluate("scale-color(rgb(10, 20, 30), $green: 8%)"))
     assert_equal(evaluate("rgb(10, 20, 20)"),
-      evaluate("scale(rgb(10, 20, 30), $blue: -(1/3)*100%)"))
+      evaluate("scale-color(rgb(10, 20, 30), $blue: -(1/3)*100%)"))
     # Alpha
     assert_equal(evaluate("hsla(120, 30, 90, 0.86)"),
-      evaluate("scale(hsl(120, 30, 90), $alpha: -14%)"))
+      evaluate("scale-color(hsl(120, 30, 90), $alpha: -14%)"))
     assert_equal(evaluate("rgba(10, 20, 30, 0.82)"),
-      evaluate("scale(rgba(10, 20, 30, 0.8), $alpha: 10%)"))
+      evaluate("scale-color(rgba(10, 20, 30, 0.8), $alpha: 10%)"))
 
     # HSL composability
     assert_equal(evaluate("hsl(120, 51, 76.5)"),
-      evaluate("scale(hsl(120, 30, 90), $saturation: 30%, $lightness: -15%)"))
+      evaluate("scale-color(hsl(120, 30, 90), $saturation: 30%, $lightness: -15%)"))
     assert_equal(evaluate("hsla(120, 51, 90, 0.2)"),
-      evaluate("scale(hsl(120, 30, 90), $saturation: 30%, $alpha: -80%)"))
+      evaluate("scale-color(hsl(120, 30, 90), $saturation: 30%, $alpha: -80%)"))
 
     # RGB composability
     assert_equal(evaluate("rgb(157, 38.8, 30)"),
-      evaluate("scale(rgb(10, 20, 30), $red: 60%, $green: 8%)"))
+      evaluate("scale-color(rgb(10, 20, 30), $red: 60%, $green: 8%)"))
     assert_equal(evaluate("rgb(157, 38.8, 20)"),
-      evaluate("scale(rgb(10, 20, 30), $red: 60%, $green: 8%, $blue: -(1/3)*100%)"))
+      evaluate("scale-color(rgb(10, 20, 30), $red: 60%, $green: 8%, $blue: -(1/3)*100%)"))
     assert_equal(evaluate("rgba(10, 38.8, 20, 0.55)"),
-      evaluate("scale(rgba(10, 20, 30, 0.5), $green: 8%, $blue: -(1/3)*100%, $alpha: 10%)"))
+      evaluate("scale-color(rgba(10, 20, 30, 0.5), $green: 8%, $blue: -(1/3)*100%, $alpha: 10%)"))
 
     # Extremes
     assert_equal(evaluate("hsl(120, 100, 90)"),
-      evaluate("scale(hsl(120, 30, 90), $saturation: 100%)"))
+      evaluate("scale-color(hsl(120, 30, 90), $saturation: 100%)"))
     assert_equal(evaluate("hsl(120, 30, 90)"),
-      evaluate("scale(hsl(120, 30, 90), $saturation: 0%)"))
+      evaluate("scale-color(hsl(120, 30, 90), $saturation: 0%)"))
     assert_equal(evaluate("hsl(120, 0, 90)"),
-      evaluate("scale(hsl(120, 30, 90), $saturation: -100%)"))
+      evaluate("scale-color(hsl(120, 30, 90), $saturation: -100%)"))
   end
 
-  def test_scale_tests_types
-    assert_error_message("\"foo\" is not a color for `scale'", "scale(foo, $red: 10%)")
+  def test_scale_color_tests_types
+    assert_error_message("\"foo\" is not a color for `scale-color'", "scale-color(foo, $red: 10%)")
     # HSL
-    assert_error_message("$saturation: \"foo\" is not a number for `scale'",
-      "scale(blue, $saturation: foo)")
-    assert_error_message("$lightness: \"foo\" is not a number for `scale'",
-      "scale(blue, $lightness: foo)")
+    assert_error_message("$saturation: \"foo\" is not a number for `scale-color'",
+      "scale-color(blue, $saturation: foo)")
+    assert_error_message("$lightness: \"foo\" is not a number for `scale-color'",
+      "scale-color(blue, $lightness: foo)")
     # RGB
-    assert_error_message("$red: \"foo\" is not a number for `scale'",
-      "scale(blue, $red: foo)")
-    assert_error_message("$green: \"foo\" is not a number for `scale'",
-      "scale(blue, $green: foo)")
-    assert_error_message("$blue: \"foo\" is not a number for `scale'",
-      "scale(blue, $blue: foo)")
+    assert_error_message("$red: \"foo\" is not a number for `scale-color'",
+      "scale-color(blue, $red: foo)")
+    assert_error_message("$green: \"foo\" is not a number for `scale-color'",
+      "scale-color(blue, $green: foo)")
+    assert_error_message("$blue: \"foo\" is not a number for `scale-color'",
+      "scale-color(blue, $blue: foo)")
     # Alpha
-    assert_error_message("$alpha: \"foo\" is not a number for `scale'",
-      "scale(blue, $alpha: foo)")
+    assert_error_message("$alpha: \"foo\" is not a number for `scale-color'",
+      "scale-color(blue, $alpha: foo)")
   end
 
-  def test_scale_argument_errors
+  def test_scale_color_argument_errors
     # Range
-    assert_error_message("$saturation: Amount 101% must be between -100% and 100% for `scale'",
-      "scale(blue, $saturation: 101%)")
-    assert_error_message("$red: Amount -101% must be between -100% and 100% for `scale'",
-      "scale(blue, $red: -101%)")
-    assert_error_message("$alpha: Amount -101% must be between -100% and 100% for `scale'",
-      "scale(blue, $alpha: -101%)")
+    assert_error_message("$saturation: Amount 101% must be between -100% and 100% for `scale-color'",
+      "scale-color(blue, $saturation: 101%)")
+    assert_error_message("$red: Amount -101% must be between -100% and 100% for `scale-color'",
+      "scale-color(blue, $red: -101%)")
+    assert_error_message("$alpha: Amount -101% must be between -100% and 100% for `scale-color'",
+      "scale-color(blue, $alpha: -101%)")
 
     # Unit
-    assert_error_message("$saturation: Amount 80 must be a % (e.g. 80%) for `scale'",
-      "scale(blue, $saturation: 80)")
-    assert_error_message("$alpha: Amount 0.5 must be a % (e.g. 0.5%) for `scale'",
-      "scale(blue, $alpha: 0.5)")
+    assert_error_message("$saturation: Amount 80 must be a % (e.g. 80%) for `scale-color'",
+      "scale-color(blue, $saturation: 80)")
+    assert_error_message("$alpha: Amount 0.5 must be a % (e.g. 0.5%) for `scale-color'",
+      "scale-color(blue, $alpha: 0.5)")
 
     # Unknown argument
-    assert_error_message("Unknown argument $hue (80%) for `scale'", "scale(blue, $hue: 80%)")
+    assert_error_message("Unknown argument $hue (80%) for `scale-color'", "scale-color(blue, $hue: 80%)")
 
     # Non-keyword arg
-    assert_error_message("10px is not a keyword argument for `scale'", "scale(blue, 10px)")
+    assert_error_message("10px is not a keyword argument for `scale_color'", "scale-color(blue, 10px)")
 
     # HSL/RGB
-    assert_error_message("Cannot specify HSL and RGB values for a color at the same time for `scale'",
-      "scale(blue, $lightness: 10%, $red: 20%)");
+    assert_error_message("Cannot specify HSL and RGB values for a color at the same time for `scale-color'",
+      "scale-color(blue, $lightness: 10%, $red: 20%)");
   end
 
-  def test_set
+  def test_change_color
     # HSL
     assert_equal(evaluate("hsl(195, 30, 90)"),
-      evaluate("set(hsl(120, 30, 90), $hue: 195deg)"))
+      evaluate("change-color(hsl(120, 30, 90), $hue: 195deg)"))
     assert_equal(evaluate("hsl(120, 50, 90)"),
-      evaluate("set(hsl(120, 30, 90), $saturation: 50%)"))
+      evaluate("change-color(hsl(120, 30, 90), $saturation: 50%)"))
     assert_equal(evaluate("hsl(120, 30, 40)"),
-      evaluate("set(hsl(120, 30, 90), $lightness: 40%)"))
+      evaluate("change-color(hsl(120, 30, 90), $lightness: 40%)"))
     # RGB
     assert_equal(evaluate("rgb(123, 20, 30)"),
-      evaluate("set(rgb(10, 20, 30), $red: 123)"))
+      evaluate("change-color(rgb(10, 20, 30), $red: 123)"))
     assert_equal(evaluate("rgb(10, 234, 30)"),
-      evaluate("set(rgb(10, 20, 30), $green: 234)"))
+      evaluate("change-color(rgb(10, 20, 30), $green: 234)"))
     assert_equal(evaluate("rgb(10, 20, 198)"),
-      evaluate("set(rgb(10, 20, 30), $blue: 198)"))
+      evaluate("change-color(rgb(10, 20, 30), $blue: 198)"))
     # Alpha
     assert_equal(evaluate("rgba(10, 20, 30, 0.76)"),
-      evaluate("set(rgb(10, 20, 30), $alpha: 0.76)"))
+      evaluate("change-color(rgb(10, 20, 30), $alpha: 0.76)"))
 
     # HSL composability
     assert_equal(evaluate("hsl(56, 30, 47)"),
-      evaluate("set(hsl(120, 30, 90), $hue: 56deg, $lightness: 47%)"))
+      evaluate("change-color(hsl(120, 30, 90), $hue: 56deg, $lightness: 47%)"))
     assert_equal(evaluate("hsla(56, 30, 47, 0.9)"),
-      evaluate("set(hsl(120, 30, 90), $hue: 56deg, $lightness: 47%, $alpha: 0.9)"))
+      evaluate("change-color(hsl(120, 30, 90), $hue: 56deg, $lightness: 47%, $alpha: 0.9)"))
   end
 
-  def test_set_tests_types
-    assert_error_message("\"foo\" is not a color for `set'", "set(foo, $red: 10%)")
+  def test_change_color_tests_types
+    assert_error_message("\"foo\" is not a color for `change-color'", "change-color(foo, $red: 10%)")
     # HSL
-    assert_error_message("$saturation: \"foo\" is not a number for `set'",
-      "set(blue, $saturation: foo)")
-    assert_error_message("$lightness: \"foo\" is not a number for `set'",
-      "set(blue, $lightness: foo)")
+    assert_error_message("$saturation: \"foo\" is not a number for `change-color'",
+      "change-color(blue, $saturation: foo)")
+    assert_error_message("$lightness: \"foo\" is not a number for `change-color'",
+      "change-color(blue, $lightness: foo)")
     # RGB
-    assert_error_message("$red: \"foo\" is not a number for `set'", "set(blue, $red: foo)")
-    assert_error_message("$green: \"foo\" is not a number for `set'", "set(blue, $green: foo)")
-    assert_error_message("$blue: \"foo\" is not a number for `set'", "set(blue, $blue: foo)")
+    assert_error_message("$red: \"foo\" is not a number for `change-color'", "change-color(blue, $red: foo)")
+    assert_error_message("$green: \"foo\" is not a number for `change-color'", "change-color(blue, $green: foo)")
+    assert_error_message("$blue: \"foo\" is not a number for `change-color'", "change-color(blue, $blue: foo)")
     # Alpha
-    assert_error_message("$alpha: \"foo\" is not a number for `set'", "set(blue, $alpha: foo)")
+    assert_error_message("$alpha: \"foo\" is not a number for `change-color'", "change-color(blue, $alpha: foo)")
   end
 
-  def test_set_argument_errors
+  def test_change_color_argument_errors
     # Range
-    assert_error_message("Saturation must be between 0 and 100 for `set'",
-      "set(blue, $saturation: 101%)")
-    assert_error_message("Lightness must be between 0 and 100 for `set'",
-      "set(blue, $lightness: 101%)")
-    assert_error_message("Red value must be between 0 and 255 for `set'",
-      "set(blue, $red: -1)")
-    assert_error_message("Green value must be between 0 and 255 for `set'",
-      "set(blue, $green: 256)")
-    assert_error_message("Blue value must be between 0 and 255 for `set'",
-      "set(blue, $blue: 500)")
+    assert_error_message("Saturation must be between 0 and 100 for `change-color'",
+      "change-color(blue, $saturation: 101%)")
+    assert_error_message("Lightness must be between 0 and 100 for `change-color'",
+      "change-color(blue, $lightness: 101%)")
+    assert_error_message("Red value must be between 0 and 255 for `change-color'",
+      "change-color(blue, $red: -1)")
+    assert_error_message("Green value must be between 0 and 255 for `change-color'",
+      "change-color(blue, $green: 256)")
+    assert_error_message("Blue value must be between 0 and 255 for `change-color'",
+      "change-color(blue, $blue: 500)")
 
     # Unknown argument
-    assert_error_message("Unknown argument $hoo (80%) for `set'", "set(blue, $hoo: 80%)")
+    assert_error_message("Unknown argument $hoo (80%) for `change-color'", "change-color(blue, $hoo: 80%)")
 
     # Non-keyword arg
-    assert_error_message("10px is not a keyword argument for `set'", "set(blue, 10px)")
+    assert_error_message("10px is not a keyword argument for `change_color'", "change-color(blue, 10px)")
 
     # HSL/RGB
-    assert_error_message("Cannot specify HSL and RGB values for a color at the same time for `set'",
-      "set(blue, $lightness: 10%, $red: 120)");
+    assert_error_message("Cannot specify HSL and RGB values for a color at the same time for `change-color'",
+      "change-color(blue, $lightness: 10%, $red: 120)");
   end
 
   def test_mix

data/test/sass/importer_test.rb

@@ -5,8 +5,6 @@ require File.dirname(__FILE__) + '/test_helper'
 class ImporterTest < Test::Unit::TestCase
   
   class FruitImporter < Sass::Importers::Base
-    attr_reader :cached
-
     def find(name, context = nil)
       if name =~ %r{fruits/(\w+)(\.s[ac]ss)?}
         fruit = $1
@@ -31,13 +29,6 @@ class ImporterTest < Test::Unit::TestCase
     def key(name, context)
       [self.class.name, name]
     end
-
-    def _around_dump
-      @cached = true
-      yield
-    ensure
-      @cached = false
-    end
   end
 
   # This class proves that you can override the extension scheme for importers
@@ -88,17 +79,4 @@ CSS
   ensure
     FileUtils.rm_rf(absolutize("tmp"))
   end
-
-  def test_caching_importer
-    source = "p\n  foo: bar"
-    importer = FruitImporter.new
-    filename = filename_for_test
-    engine = Sass::Engine.new(source, :filename => filename, :importer => importer)
-    engine.to_tree # Trigger caching
-
-    sha = Digest::SHA1.hexdigest(source)
-    cache = engine.options[:cache_store]
-    cached_tree = cache.retrieve(cache.key(*importer.key(filename, engine.options)), sha)
-    assert cached_tree.options[:importer].cached, "Importer's _around_dump method should have been called"
-  end
 end

data/test/sass/util_test.rb

@@ -5,19 +5,6 @@ require 'pathname'
 class UtilTest < Test::Unit::TestCase
   include Sass::Util
 
-  class Dumpable
-    attr_reader :arr
-    def initialize; @arr = []; end
-    def _before_dump; @arr << :before; end
-    def _after_dump; @arr << :after; end
-    def _around_dump
-      @arr << :around_before
-      yield
-      @arr << :around_after
-    end
-    def _after_load; @arr << :loaded; end
-  end
-
   def test_scope
     assert(File.exist?(scope("Rakefile")))
   end
@@ -253,14 +240,6 @@ class UtilTest < Test::Unit::TestCase
     assert(!version_gt(v2, v1), "Expected #{v2} = #{v1}")
   end
 
-  def test_dump_and_load
-    obj = Dumpable.new
-    data = dump(obj)
-    assert_equal([:before, :around_before, :around_after, :after], obj.arr)
-    obj2 = load(data)
-    assert_equal([:before, :around_before, :loaded], obj2.arr)
-  end
-
   class FooBar
     def foo
       Sass::Util.abstract(self)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  version: 3.1.0.alpha.210
+  version: 3.1.0.alpha.212
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-30 00:00:00 -05:00
+date: 2011-01-13 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -63,6 +63,7 @@ files:
 - lib/sass/cache_stores/filesystem.rb
 - lib/sass/cache_stores/memory.rb
 - lib/sass/cache_stores/null.rb
+- lib/sass/cache_stores/chain.rb
 - lib/sass/plugin/configuration.rb
 - lib/sass/plugin/merb.rb
 - lib/sass/plugin/generic.rb