sass 3.1.0.alpha.41 → 3.1.0.alpha.42

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-3.1.0.alpha.41
+3.1.0.alpha.42

data/VERSION

@@ -1 +1 @@
-3.1.0.alpha.41
+3.1.0.alpha.42

data/lib/sass/cache_stores.rb

@@ -0,0 +1,14 @@
+require 'stringio'
+
+module Sass
+  # Sass cache stores are in charge of storing cached information,
+  # especially parse trees for Sass documents.
+  #
+  # User-created importers must inherit from {CacheStores::Base}.
+  module CacheStores
+  end
+end
+
+require 'sass/cache_stores/base'
+require 'sass/cache_stores/filesystem'
+require 'sass/cache_stores/memory'

data/lib/sass/cache_stores/active_support.rb

@@ -0,0 +1,28 @@
+module Sass
+  module CacheStores
+    # A cache store that wraps an ActiveSupport cache store.
+    # This is useful for integrating with an app that uses ActiveSupport,
+    # or for taking advantage of the wide variety of ActiveSupport cache backends.
+    #
+    # This is automatically used within Rails.
+    class ActiveSupport < Base
+      # @param store [::ActiveSupport::Cache::Store] The cache store to wrap.
+      def initialize(store)
+        @store = store
+      end
+
+      # @see Base#_retrieve
+      def _retrieve(key, version, sha)
+        return unless val = @store.fetch('_sass/' + key)
+        return unless val[:version] == version
+        return unless val[:sha] == sha
+        return val[:contents]
+      end
+
+      # @see Base#_store
+      def _store(key, version, sha, contents)
+        @store.write('_sass/' + key, :version => version, :sha => sha, :contents => contents)
+      end
+    end
+  end
+end

data/lib/sass/cache_stores/base.rb

@@ -0,0 +1,84 @@
+module Sass
+  module CacheStores
+    # An abstract base class for backends for the Sass cache.
+    # Any key-value store can act as such a backend;
+    # it just needs to implement the
+    # \{#_store} and \{#_retrieve} methods.
+    #
+    # To use a cache store with Sass,
+    # use the {file:SASS_REFERENCE.md#cache_store-option `:cache_store` option}.
+    #
+    # @abstract
+    class Base
+      # Store cached contents for later retrieval
+      # Must be implemented by all CacheStore subclasses
+      #
+      # Note: cache contents contain binary data.
+      #
+      # @param key [String] The key to store the contents under
+      # @param version [String] The current sass version.
+      #                Cached contents must not be retrieved across different versions of sass.
+      # @param sha [String] The sha of the sass source.
+      #                Cached contents must not be retrieved if the sha has changed.
+      # @param contents [String] The contents to store.
+      def _store(key, version, sha, contents)
+        raise "#{self.class} must implement #_store."
+      end
+
+      # Retrieved cached contents.
+      # Must be implemented by all subclasses.
+      # 
+      # Note: if the key exists but the sha or version have changed,
+      # then the key may be deleted by the cache store, if it wants to do so.
+      #
+      # @param key [String] The key to retrieve
+      # @param version [String] The current sass version.
+      #                Cached contents must not be retrieved across different versions of sass.
+      # @param sha [String] The sha of the sass source.
+      #                Cached contents must not be retrieved if the sha has changed.
+      # @return [String] The contents that were previously stored.
+      # @return [NilClass] when the cache key is not found or the version or sha have changed.
+      def _retrieve(key, version, sha)
+        raise "#{self.class} must implement #_retrieve."
+      end
+
+      # Store a {Sass::Tree::RootNode}.
+      #
+      # @param key [String] The key to store it under.
+      # @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))
+      end
+
+      # Retrieve a {Sass::Tree::RootNode}.
+      #
+      # @param key [String] The key the root element was stored under.
+      # @param sha [String] The checksum of the root element's content.
+      # @return [Object] The cached object.
+      def retrieve(key, sha)
+        contents = _retrieve(key, Sass::VERSION, sha)
+        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
+
+      # Return the key for the sass file.
+      #
+      # The `(sass_dirname, sass_basename)` pair
+      # should uniquely identify the Sass document,
+      # but otherwise there are no restrictions on their content.
+      #
+      # @param sass_dirname [String]
+      #   The fully-expanded location of the Sass file.
+      #   This corresponds to the directory name on a filesystem.
+      # @param sass_basename [String] The name of the Sass file that is being referenced.
+      #   This corresponds to the basename on a filesystem.
+      def key(sass_dirname, sass_basename)
+        dir = Digest::SHA1.hexdigest(sass_dirname)
+        filename = "#{sass_basename}c"
+        "#{dir}/#{filename}"
+      end
+    end
+  end
+end

data/lib/sass/cache_stores/filesystem.rb

@@ -0,0 +1,56 @@
+module Sass
+  module CacheStores
+    # A backend for the Sass cache using the filesystem.
+    class Filesystem < Base
+      # The directory where the cached files will be stored.
+      #
+      # @return [String]
+      attr_accessor :cache_location
+
+      # @param cache_location [String] see \{#cache\_location}
+      def initialize(cache_location)
+        @cache_location = cache_location
+      end
+
+      # @see Base#\_retrieve
+      def _retrieve(key, version, sha)
+        return unless File.readable?(path_to(key))
+        contents = nil
+        File.open(path_to(key), "rb") do |f|
+          if f.readline("\n").strip == version && f.readline("\n").strip == sha
+            return f.read
+          end
+        end
+        File.unlink path_to(key)
+        nil
+      rescue EOFError, TypeError, ArgumentError => e
+        Sass::Util.sass_warn "Warning. Error encountered while reading cache #{path_to(key)}: #{e}"
+      end
+
+      # @see Base#\_store
+      def _store(key, version, sha, contents)
+        return unless File.writable?(File.dirname(@cache_location))
+        return if File.exists?(@cache_location) && !File.writable?(@cache_location)
+        compiled_filename = path_to(key)
+        return if File.exists?(File.dirname(compiled_filename)) && !File.writable?(File.dirname(compiled_filename))
+        return if File.exists?(compiled_filename) && !File.writable?(compiled_filename)
+        FileUtils.mkdir_p(File.dirname(compiled_filename))
+        File.open(compiled_filename, "wb") do |f|
+          f.puts(version)
+          f.puts(sha)
+          f.write(contents)
+        end
+      end
+
+      private
+
+      # Returns the path to a file for the given key.
+      #
+      # @param key [String]
+      # @return [String] The path to the cache file.
+      def path_to(key)
+        File.join(cache_location, key)
+      end
+    end
+  end
+end

data/lib/sass/cache_stores/memory.rb

@@ -0,0 +1,51 @@
+module Sass
+  module CacheStores
+    # A backend for the Sass cache using in-process memory.
+    class Memory < Base
+      # Since the {Memory} store is stored in the Sass tree's options hash,
+      # when the options get serialized as part of serializing the tree,
+      # you get crazy exponential growth in the size of the cached objects
+      # unless you don't dump the cache.
+      #
+      # @private
+      def _dump(depth)
+        ""
+      end
+
+      # If we deserialize this class, just make a new empty one.
+      #
+      # @private
+      def self._load(repr)
+        Memory.new
+      end
+
+      # Create a new, empty cache store.
+      def initialize
+        @contents = {}
+      end
+
+      # @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
+          return @contents[key][:contents]
+        end
+      end
+      
+      # @see Base#_store
+      def _store(key, version, sha, contents)
+        @contents[key] = {
+          :version => version,
+          :sha => sha,
+          :contents => contents
+        }
+      end
+      
+      # Destructively clear the cache.
+      def reset!
+        @contents = {}
+      end
+    end
+  end
+end

data/lib/sass/cache_stores/null.rb

@@ -0,0 +1,25 @@
+module Sass
+  module CacheStores
+    # Doesn't store anything, but records what things it should have stored.
+    # This doesn't currently have any use except for testing and debugging.
+    #
+    # @private
+    class Null < Base
+      def initialize
+        @keys = {}
+      end
+
+      def _retrieve(key, version, sha)
+        nil
+      end
+      
+      def _store(key, version, sha, contents)
+        @keys[key] = true
+      end
+      
+      def was_set?(key)
+        @keys[key]
+      end
+    end
+  end
+end

data/lib/sass/engine.rb

@@ -1,7 +1,7 @@
 require 'strscan'
 require 'set'
 require 'digest/sha1'
-require 'sass/cache_store'
+require 'sass/cache_stores'
 require 'sass/tree/node'
 require 'sass/tree/root_node'
 require 'sass/tree/rule_node'
@@ -156,7 +156,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::FileCacheStore.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]

data/lib/sass/plugin/configuration.rb

@@ -31,7 +31,7 @@ module Sass
       # @return [{Symbol => Object}]
       def options
         @options ||= default_options.dup
-        @options[:cache_store] ||= Sass::FileCacheStore.new(@options[:cache_location])
+        @options[:cache_store] ||= Sass::CacheStores::Filesystem.new(@options[:cache_location])
         @options
       end
 

data/lib/sass/plugin/rails.rb

@@ -4,6 +4,7 @@ unless defined?(Sass::RAILS_LOADED)
   module Sass::Plugin::Configuration
     # Different default options in a rails envirionment.
     def default_options
+      return @default_options if @default_options
       opts = {
         :quiet             => Sass::Util.rails_env != "production",
         :full_exception    => Sass::Util.rails_env != "production",
@@ -11,7 +12,10 @@ unless defined?(Sass::RAILS_LOADED)
       }
 
       if Sass::Util.ap_geq?('3.1.0.beta')
-        opts.merge!(:load_paths => [])
+        require 'sass/importers/rails'
+        require 'sass/cache_stores/active_support'
+        opts.merge!(:load_paths => [Sass::Importers::Rails.new])
+        opts.merge!(:cache_store => Sass::CacheStores::ActiveSupport.new(Rails.cache)) if Rails.cache
       else
         opts.merge!(
           :always_update      => false,
@@ -20,7 +24,7 @@ unless defined?(Sass::RAILS_LOADED)
           :always_check      => Sass::Util.rails_env == "development")
       end
 
-      @default_options ||= opts.freeze
+      @default_options = opts.freeze
     end
   end
 
@@ -29,7 +33,6 @@ unless defined?(Sass::RAILS_LOADED)
   # Disable this for now, until we figure out how to get Rails
   # to pass in the view.
   if Sass::Util.ap_geq?('3.1.0.beta')
-    require 'sass/importers/rails'
     class Sass::Plugin::TemplateHandler
       attr_reader :syntax
 
@@ -45,8 +48,7 @@ unless defined?(Sass::RAILS_LOADED)
             :syntax => @syntax,
             :filename => template.virtual_path,
             :_rails_lookup_context => view.lookup_context,
-            :importer => Sass::Importers::Rails.new,
-            :load_paths => [Sass::Importers::Rails.new] + Sass::Plugin.engine_options[:load_paths]))
+            :importer => Sass::Importers::Rails.new))
 
         template.data[:sass_importers] = engine.dependencies.map do |e|
           [e.options[:filename], e.options[:importer]]

data/test/sass/cache_test.rb

@@ -14,13 +14,13 @@ class CacheTest < Test::Unit::TestCase
   end
 
   def test_file_cache_writes_a_file
-    file_store = Sass::FileCacheStore.new(@@cache_dir)
+    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
     file_store.store("asdf/foo.scssc", "fakesha1", root_node)
     assert File.exists?("#{@@cache_dir}/asdf/foo.scssc")
   end
 
   def test_file_cache_reads_a_file
-    file_store = Sass::FileCacheStore.new(@@cache_dir)
+    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
     assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
     file_store.store("asdf/foo.scssc", "fakesha1", root_node)
     assert File.exists?("#{@@cache_dir}/asdf/foo.scssc")
@@ -28,13 +28,13 @@ class CacheTest < Test::Unit::TestCase
   end
 
   def test_file_cache_miss_returns_nil
-    file_store = Sass::FileCacheStore.new(@@cache_dir)
+    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
     assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
     assert_nil file_store.retrieve("asdf/foo.scssc", "fakesha1")
   end
 
   def test_sha_change_invalidates_cache_and_cleans_up
-    file_store = Sass::FileCacheStore.new(@@cache_dir)
+    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
     assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
     file_store.store("asdf/foo.scssc", "fakesha1", root_node)
     assert File.exists?("#{@@cache_dir}/asdf/foo.scssc")
@@ -43,7 +43,7 @@ class CacheTest < Test::Unit::TestCase
   end
 
   def test_version_change_invalidates_cache_and_cleans_up
-    file_store = Sass::FileCacheStore.new(@@cache_dir)
+    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
     assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
     file_store.store("asdf/foo.scssc", "fakesha1", root_node)
     assert File.exists?("#{@@cache_dir}/asdf/foo.scssc")
@@ -58,7 +58,7 @@ class CacheTest < Test::Unit::TestCase
   end
 
   def test_arbitrary_objects_can_go_into_cache
-    cache = Sass::InMemoryCacheStore.new
+    cache = Sass::CacheStores::Memory.new
     an_object = {:foo => :bar}
     cache.store("an_object", "", an_object)
     assert_equal an_object, cache.retrieve("an_object", "")
@@ -71,4 +71,4 @@ class CacheTest < Test::Unit::TestCase
       div { @include color(red); }
     SCSS
   end
-end
+end

data/test/sass/plugin_test.rb

@@ -13,7 +13,7 @@ class SassPluginTest < Test::Unit::TestCase
   @@templates += %w[import_charset import_charset_ibm866] unless Sass::Util.ruby1_8?
   @@templates << 'import_charset_1_8' if Sass::Util.ruby1_8?
 
-  @@cache_store = Sass::InMemoryCacheStore.new
+  @@cache_store = Sass::CacheStores::Memory.new
 
   def setup
     FileUtils.mkdir_p tempfile_loc

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  version: 3.1.0.alpha.41
+  version: 3.1.0.alpha.42
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -57,7 +57,6 @@ files:
 - lib/sass/plugin.rb
 - lib/sass/script.rb
 - lib/sass/selector.rb
-- lib/sass/cache_store.rb
 - lib/sass/plugin/configuration.rb
 - lib/sass/plugin/merb.rb
 - lib/sass/plugin/generic.rb
@@ -126,6 +125,12 @@ files:
 - lib/sass/util.rb
 - lib/sass/util/subset_map.rb
 - lib/sass/version.rb
+- lib/sass/cache_stores.rb
+- lib/sass/cache_stores/active_support.rb
+- lib/sass/cache_stores/base.rb
+- lib/sass/cache_stores/filesystem.rb
+- lib/sass/cache_stores/memory.rb
+- lib/sass/cache_stores/null.rb
 - vendor/fssm/LICENSE
 - vendor/fssm/README.markdown
 - vendor/fssm/Rakefile

data/lib/sass/cache_store.rb

@@ -1,208 +0,0 @@
-require 'stringio'
-
-module Sass
-  # An abstract base class for backends for the Sass cache.
-  # Any key-value store can act as such a backend;
-  # it just needs to implement the
-  # \{#_store} and \{#_retrieve} methods.
-  #
-  # To use a cache store with Sass,
-  # use the {file:SASS_REFERENCE.md#cache_store-option `:cache_store` option}.
-  class CacheStore
-    # Store cached contents for later retrieval
-    # Must be implemented by all CacheStore subclasses
-    #
-    # Note: cache contents contain binary data.
-    #
-    # @param key [String] The key to store the contents under
-    # @param version [String] The current sass version.
-    #                Cached contents must not be retrieved across different versions of sass.
-    # @param sha [String] The sha of the sass source.
-    #                Cached contents must not be retrieved if the sha has changed.
-    # @param contents [String] The contents to store.
-    def _store(key, version, sha, contents)
-      raise "#{self.class} must implement #_store."
-    end
-
-    # Retrieved cached contents.
-    # Must be implemented by all subclasses.
-    # 
-    # Note: if the key exists but the sha or version have changed,
-    # then the key may be deleted by the cache store, if it wants to do so.
-    #
-    # @param key [String] The key to retrieve
-    # @param version [String] The current sass version.
-    #                Cached contents must not be retrieved across different versions of sass.
-    # @param sha [String] The sha of the sass source.
-    #                Cached contents must not be retrieved if the sha has changed.
-    # @return [String] The contents that were previously stored.
-    # @return [NilClass] when the cache key is not found or the version or sha have changed.
-    def _retrieve(key, version, sha)
-      raise "#{self.class} must implement #_retrieve."
-    end
-
-    # Store a {Sass::Tree::RootNode}.
-    #
-    # @param key [String] The key to store it under.
-    # @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))
-    end
-
-    # Retrieve a {Sass::Tree::RootNode}.
-    #
-    # @param key [String] The key the root element was stored under.
-    # @param sha [String] The checksum of the root element's content.
-    # @return [Object] The cached object.
-    def retrieve(key, sha)
-      contents = _retrieve(key, Sass::VERSION, sha)
-      Sass::Util.load(contents) if contents
-    rescue EOFError, TypeError, ArgumentError => e
-      raise
-      Sass::Util.sass_warn "Warning. Error encountered while reading cache #{path_to(key)}: #{e}"
-    end
-
-    # Return the key for the sass file.
-    #
-    # The `(sass_dirname, sass_basename)` pair
-    # should uniquely identify the Sass document,
-    # but otherwise there are no restrictions on their content.
-    #
-    # @param sass_dirname [String]
-    #   The fully-expanded location of the Sass file.
-    #   This corresponds to the directory name on a filesystem.
-    # @param sass_basename [String] The name of the Sass file that is being referenced.
-    #   This corresponds to the basename on a filesystem.
-    def key(sass_dirname, sass_basename)
-      dir = Digest::SHA1.hexdigest(sass_dirname)
-      filename = "#{sass_basename}c"
-      "#{dir}/#{filename}"
-    end
-  end
-
-  # A backend for the Sass cache using the filesystem.
-  class FileCacheStore < CacheStore
-    # The directory where the cached files will be stored.
-    #
-    # @return [String]
-    attr_accessor :cache_location
-
-    # Create a new FileCacheStore.
-    #
-    # @param cache_location [String] see \{#cache\_location}
-    def initialize(cache_location)
-      @cache_location = cache_location
-    end
-
-    # @see {CacheStore#\_retrieve\_}
-    def _retrieve(key, version, sha)
-      return unless File.readable?(path_to(key))
-      contents = nil
-      File.open(path_to(key), "rb") do |f|
-        if f.readline("\n").strip == version && f.readline("\n").strip == sha
-          return f.read
-        end
-      end
-      File.unlink path_to(key)
-      nil
-    rescue EOFError, TypeError, ArgumentError => e
-      Sass::Util.sass_warn "Warning. Error encountered while reading cache #{path_to(key)}: #{e}"
-    end
-
-    # @see {CacheStore#\_store\_}
-    def _store(key, version, sha, contents)
-      return unless File.writable?(File.dirname(@cache_location))
-      return if File.exists?(@cache_location) && !File.writable?(@cache_location)
-      compiled_filename = path_to(key)
-      return if File.exists?(File.dirname(compiled_filename)) && !File.writable?(File.dirname(compiled_filename))
-      return if File.exists?(compiled_filename) && !File.writable?(compiled_filename)
-      FileUtils.mkdir_p(File.dirname(compiled_filename))
-      File.open(compiled_filename, "wb") do |f|
-        f.puts(version)
-        f.puts(sha)
-        f.write(contents)
-      end
-    end
-
-    private
-
-    # Returns the path to a file for the given key.
-    #
-    # @param key [String]
-    # @return [String] The path to the cache file.
-    def path_to(key)
-      File.join(cache_location, key)
-    end
-  end
-
-  # A backend for the Sass cache using in-process memory.
-  class InMemoryCacheStore < CacheStore
-    # Since the {InMemoryCacheStore} is stored in the Sass tree's options hash,
-    # when the options get serialized as part of serializing the tree,
-    # you get crazy exponential growth in the size of the cached objects
-    # unless you don't dump the cache.
-    #
-    # @private
-    def _dump(depth)
-      ""
-    end
-
-    # If we deserialize this class, just make a new empty one.
-    #
-    # @private
-    def self._load(repr)
-      InMemoryCacheStore.new
-    end
-
-    # Create a new, empty cache store.
-    def initialize
-      @contents = {}
-    end
-
-    # @see CacheStore#_retrieve
-    def _retrieve(key, version, sha)
-      if @contents.has_key?(key)
-        return unless @contents[key][:version] == version
-        return unless @contents[key][:sha] == sha
-        return @contents[key][:contents]
-      end
-    end
-    
-    # @see CacheStore#_store
-    def _store(key, version, sha, contents)
-      @contents[key] = {
-        :version => version,
-        :sha => sha,
-        :contents => contents
-      }
-    end
-    
-    # Destructively clear the cache.
-    def reset!
-      @contents = {}
-    end
-  end
-
-  # Doesn't store anything, but records what things it should have stored.
-  # This doesn't currently have any use except for testing and debugging.
-  #
-  # @private
-  class NullCacheStore < CacheStore
-    def initialize
-      @keys = {}
-    end
-
-    def _retrieve(key, version, sha)
-      nil
-    end
-    
-    def _store(key, version, sha, contents)
-      @keys[key] = true
-    end
-    
-    def was_set?(key)
-      @keys[key]
-    end
-  end
-end