sass 3.1.0.alpha.212 → 3.1.0.alpha.214

data/REVISION

@@ -1 +1 @@
-ebf9e326dafba548aef36fe36945d97a9dd590d9
+e18890b4746317cad3919e6461554eb0415b12fc

data/VERSION

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

data/lib/sass/cache_stores.rb

@@ -12,4 +12,3 @@ 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, Marshal.dump(root))
+        _store(key, Sass::VERSION, sha, Sass::Util.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)
-        Marshal.load(contents) if contents
+        Sass::Util.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/memory.rb

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

data/lib/sass/engine.rb

@@ -164,8 +164,7 @@ 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::Chain.new(
-        Sass::CacheStores::Memory.new, Sass::CacheStores::Filesystem.new(options[:cache_location]))
+      options[:cache_store] ||= 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]
@@ -334,15 +333,7 @@ module Sass
       end
 
       root.options = @options
-      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
+      @options[:cache_store].store(key, sha, root) if @options[:cache] && key && sha
       root
     rescue SyntaxError => e
       e.modify_backtrace(:filename => @options[:filename], :line => @line)

data/lib/sass/script/functions.rb

@@ -93,12 +93,12 @@ module Sass::Script
   # \{#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.
   #
+  # \{#scale_color scale-color($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
+  # : Scales one or more properties of a color by a percentage value.
+  #
   # ## String Functions
   #
   # \{#unquote unquote($string)}

data/lib/sass/tree/if_node.rb

@@ -41,22 +41,23 @@ module Sass::Tree
       self.else.options = options if self.else
     end
 
-    def _dump(f)
-      Marshal.dump([self.expr, self.else])
-    end
-
-    def self._load(data)
-      expr, else_ = Marshal.load(data)
-      node = IfNode.new(expr)
-      node.else = else_
-      node
+    # @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
     end
 
-    # @see Node#deep_copy
-    def deep_copy
-      node = super
-      node.else = self.else.deep_copy if self.else
-      node
+    # @see Node#_after_load
+    def _after_load
+      super
+      @else = Sass::Util.load(@else)
+      @last_else = (@last_else ? Sass::Util.load(@last_else) : self)
     end
   end
 end

data/lib/sass/tree/node.rb

@@ -180,14 +180,29 @@ module Sass
         Sass::Tree::Visitors::Convert.visit(self, options, :scss)
       end
 
-      # 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
+      # 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)
       end
 
       protected

data/lib/sass/util.rb

@@ -270,6 +270,47 @@ 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`
@@ -665,5 +706,14 @@ 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/importer_test.rb

@@ -5,6 +5,8 @@ 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
@@ -29,6 +31,13 @@ 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
@@ -79,4 +88,17 @@ 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,6 +5,19 @@ 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
@@ -240,6 +253,14 @@ 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.212
+  version: 3.1.0.alpha.214
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-13 00:00:00 -05:00
+date: 2010-12-31 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -63,7 +63,6 @@ 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

data/lib/sass/cache_stores/chain.rb

@@ -1,33 +0,0 @@
-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