sprockets 2.12.5 → 3.0.0.beta.1

data/lib/sprockets/cache/memory_store.rb

@@ -0,0 +1,66 @@
+module Sprockets
+  class Cache
+    # Public: Basic in memory LRU cache.
+    #
+    # Assign the instance to the Environment#cache.
+    #
+    #     environment.cache = Sprockets::Cache::MemoryStore.new(1000)
+    #
+    # See Also
+    #
+    #   ActiveSupport::Cache::MemoryStore
+    #
+    class MemoryStore
+      # Internal: Default key limit for store.
+      DEFAULT_MAX_SIZE = 1000
+
+      # Public: Initialize the cache store.
+      #
+      # max_size - A Integer of the maximum number of keys the store will hold.
+      #            (default: 1000).
+      def initialize(max_size = DEFAULT_MAX_SIZE)
+        @max_size = max_size
+        @cache = {}
+      end
+
+      # Public: Retrieve value from cache.
+      #
+      # This API should not be used directly, but via the Cache wrapper API.
+      #
+      # key - String cache key.
+      #
+      # Returns Object or nil or the value is not set.
+      def get(key)
+        exists = true
+        value = @cache.delete(key) { exists = false }
+        if exists
+          @cache[key] = value
+        else
+          nil
+        end
+      end
+
+      # Public: Set a key and value in the cache.
+      #
+      # This API should not be used directly, but via the Cache wrapper API.
+      #
+      # key   - String cache key.
+      # value - Object value.
+      #
+      # Returns Object value.
+      def set(key, value)
+        @cache.delete(key)
+        @cache[key] = value
+        @cache.shift if @cache.size > @max_size
+        value
+      end
+
+      # Public: Pretty inspect
+      #
+      # Returns String.
+      def inspect
+        "#<#{self.class} size=#{@cache.size}/#{@max_size}>"
+      end
+    end
+  end
+end

data/lib/sprockets/cache/null_store.rb

@@ -0,0 +1,46 @@
+module Sprockets
+  class Cache
+    # Public: A compatible cache store that doesn't store anything. Used by
+    # default when no Environment#cache is configured.
+    #
+    # Assign the instance to the Environment#cache.
+    #
+    #     environment.cache = Sprockets::Cache::NullStore.new
+    #
+    # See Also
+    #
+    #   ActiveSupport::Cache::NullStore
+    #
+    class NullStore
+      # Public: Simulate a cache miss.
+      #
+      # This API should not be used directly, but via the Cache wrapper API.
+      #
+      # key - String cache key.
+      #
+      # Returns nil.
+      def get(key)
+        nil
+      end
+
+      # Public: Simulate setting a value in the cache.
+      #
+      # This API should not be used directly, but via the Cache wrapper API.
+      #
+      # key   - String cache key.
+      # value - Object value.
+      #
+      # Returns Object value.
+      def set(key, value)
+        value
+      end
+
+      # Public: Pretty inspect
+      #
+      # Returns String.
+      def inspect
+        "#<#{self.class}>"
+      end
+    end
+  end
+end

data/lib/sprockets/cached_environment.rb

@@ -0,0 +1,103 @@
+require 'sprockets/base'
+
+module Sprockets
+  # `Cached` is a special cached version of `Environment`.
+  #
+  # The expection is that all of its file system methods are cached
+  # for the instances lifetime. This makes `Cached` much faster. This
+  # behavior is ideal in production environments where the file system
+  # is immutable.
+  #
+  # `Cached` should not be initialized directly. Instead use
+  # `Environment#cached`.
+  class CachedEnvironment < Base
+    def initialize(environment)
+      initialize_configuration(environment)
+
+      @cache      = environment.cache
+      @stats      = Hash.new { |h, k| h[k] = _stat(k) }
+      @entries    = Hash.new { |h, k| h[k] = _entries(k) }
+      @hexdigests = Hash.new { |h, k| h[k] = _file_hexdigest(k) }
+    end
+
+    # No-op return self as cached environment.
+    def cached
+      self
+    end
+    alias_method :index, :cached
+
+    # Internal: Cache Environment#entries
+    alias_method :_entries, :entries
+    def entries(path)
+      @entries[path]
+    end
+
+    # Internal: Cache Environment#stat
+    alias_method :_stat, :stat
+    def stat(path)
+      @stats[path]
+    end
+
+    # Internal: Cache Environment#file_hexdigest
+    alias_method :_file_hexdigest, :file_hexdigest
+    def file_hexdigest(path)
+      @hexdigests[path]
+    end
+
+    protected
+      def asset_dependency_graph_cache_key(uri)
+        filename, _ = AssetURI.parse(uri)
+        [
+          'asset-uri-dep-graph',
+          VERSION,
+          self.version,
+          self.paths,
+          uri,
+          file_hexdigest(filename)
+        ]
+      end
+
+      def asset_digest_uri_cache_key(uri)
+        [
+          'asset-digest-uri',
+          VERSION,
+          self.version,
+          uri
+        ]
+      end
+
+      def build_asset_by_digest_uri(uri)
+        cache.fetch(asset_digest_uri_cache_key(uri)) do
+          super
+        end
+      end
+
+      def build_asset_by_uri(uri)
+        dep_graph_key = asset_dependency_graph_cache_key(uri)
+
+        dependency_paths, dependency_digest, digest_uri = cache._get(dep_graph_key)
+        if dependency_paths && dependency_digest && digest_uri
+          if dependencies_hexdigest(dependency_paths) == dependency_digest
+            if asset = cache._get(asset_digest_uri_cache_key(digest_uri))
+              return asset
+            end
+          end
+        end
+
+        asset = super
+
+        dependency_digest, dependency_paths = asset[:metadata].values_at(:dependency_digest, :dependency_paths)
+        cache._set(dep_graph_key, [dependency_paths, dependency_digest, asset[:uri]])
+        cache.fetch(asset_digest_uri_cache_key(asset[:uri])) { asset }
+
+        asset
+      end
+
+    private
+      # Cache is immutable, any methods that try to clear the cache
+      # should bomb.
+      def mutate_config(*args)
+        raise RuntimeError, "can't modify immutable cached environment"
+      end
+  end
+end

data/lib/sprockets/closure_compressor.rb

@@ -1,22 +1,40 @@
-require 'tilt'
+require 'closure-compiler'
 
 module Sprockets
-  class ClosureCompressor < Tilt::Template
-    self.default_mime_type = 'application/javascript'
+  # Public: Closure Compiler minifier.
+  #
+  # To accept the default options
+  #
+  #     environment.register_bundle_processor 'application/javascript',
+  #       Sprockets::ClosureCompressor
+  #
+  # Or to pass options to the Closure::Compiler class.
+  #
+  #     environment.register_bundle_processor 'application/javascript',
+  #       Sprockets::ClosureCompressor.new({ ... })
+  #
+  class ClosureCompressor
+    VERSION = '1'
 
-    def self.engine_initialized?
-      defined?(::Closure::Compiler)
+    def self.call(*args)
+      new.call(*args)
     end
 
-    def initialize_engine
-      require_template_library 'closure-compiler'
+    def initialize(options = {})
+      @compiler = ::Closure::Compiler.new(options)
+      @cache_key = [
+        'ClosureCompressor',
+        ::Closure::VERSION,
+        ::Closure::COMPILER_VERSION,
+        VERSION,
+        options
+      ]
     end
 
-    def prepare
-    end
-
-    def evaluate(context, locals, &block)
-      Closure::Compiler.new.compile(data)
+    def call(input)
+      input[:cache].fetch(@cache_key + [input[:data]]) do
+        @compiler.compile(input[:data])
+      end
     end
   end
 end

data/lib/sprockets/coffee_script_template.rb

@@ -0,0 +1,23 @@
+require 'coffee_script'
+
+module Sprockets
+  # Template engine class for the CoffeeScript compiler.
+  # Depends on the `coffee-script` and `coffee-script-source` gems.
+  #
+  # For more infomation see:
+  #
+  #   https://github.com/josh/ruby-coffee-script
+  #
+  module CoffeeScriptTemplate
+    VERSION = '1'
+    SOURCE_VERSION = ::CoffeeScript::Source.version
+
+    def self.call(input)
+      data = input[:data]
+      key  = ['CoffeeScriptTemplate', SOURCE_VERSION, VERSION, data]
+      input[:cache].fetch(key) do
+        ::CoffeeScript.compile(data)
+      end
+    end
+  end
+end

data/lib/sprockets/compressing.rb

@@ -1,37 +1,35 @@
 module Sprockets
   # `Compressing` is an internal mixin whose public methods are exposed on
-  # the `Environment` and `Index` classes.
+  # the `Environment` and `CachedEnvironment` classes.
   module Compressing
-    def compressors
-      deep_copy_hash(@compressors)
-    end
+    attr_reader :compressors
 
     def register_compressor(mime_type, sym, klass)
-      @compressors[mime_type][sym] = klass
+      mutate_hash_config(:compressors, mime_type) do |compressors|
+        compressors[sym] = klass
+        compressors
+      end
     end
 
     # Return CSS compressor or nil if none is set
     def css_compressor
-      @css_compressor if defined? @css_compressor
+      if defined? @css_compressor
+        unwrap_processor(@css_compressor)
+      end
     end
 
     # Assign a compressor to run on `text/css` assets.
     #
     # The compressor object must respond to `compress`.
     def css_compressor=(compressor)
-      unregister_bundle_processor 'text/css', css_compressor if css_compressor
+      unregister_bundle_processor 'text/css', @css_compressor if defined? @css_compressor
       @css_compressor = nil
       return unless compressor
 
       if compressor.is_a?(Symbol)
-        compressor = compressors['text/css'][compressor] || raise(Error, "unknown compressor: #{compressor}")
-      end
-
-      if compressor.respond_to?(:compress)
-        klass = Class.new(Processor) do
-          @name = "css_compressor"
-          @processor = proc { |context, data| compressor.compress(data) }
-        end
+        @css_compressor = klass = compressors['text/css'][compressor] || raise(Error, "unknown compressor: #{compressor}")
+      elsif compressor.respond_to?(:compress)
+        klass = LegacyProcProcessor.new(:css_compressor, proc { |context, data| compressor.compress(data) })
         @css_compressor = :css_compressor
       else
         @css_compressor = klass = compressor
@@ -42,26 +40,23 @@ module Sprockets
 
     # Return JS compressor or nil if none is set
     def js_compressor
-      @js_compressor if defined? @js_compressor
+      if defined? @js_compressor
+        unwrap_processor(@js_compressor)
+      end
     end
 
     # Assign a compressor to run on `application/javascript` assets.
     #
     # The compressor object must respond to `compress`.
     def js_compressor=(compressor)
-      unregister_bundle_processor 'application/javascript', js_compressor if js_compressor
+      unregister_bundle_processor 'application/javascript', @js_compressor if defined? @js_compressor
       @js_compressor = nil
       return unless compressor
 
       if compressor.is_a?(Symbol)
-        compressor = compressors['application/javascript'][compressor] || raise(Error, "unknown compressor: #{compressor}")
-      end
-
-      if compressor.respond_to?(:compress)
-        klass = Class.new(Processor) do
-          @name = "js_compressor"
-          @processor = proc { |context, data| compressor.compress(data) }
-        end
+        @js_compressor = klass = compressors['application/javascript'][compressor] || raise(Error, "unknown compressor: #{compressor}")
+      elsif compressor.respond_to?(:compress)
+        klass = LegacyProcProcessor.new(:js_compressor, proc { |context, data| compressor.compress(data) })
         @js_compressor = :js_compressor
       else
         @js_compressor = klass = compressor

data/lib/sprockets/configuration.rb

@@ -0,0 +1,95 @@
+require 'sprockets/compressing'
+require 'sprockets/engines'
+require 'sprockets/mime'
+require 'sprockets/paths'
+require 'sprockets/processing'
+require 'sprockets/transformers'
+
+module Sprockets
+  module Configuration
+    include Paths, Mime, Engines, Transformers, Processing, Compressing
+
+    def initialize_configuration(parent)
+      @logger            = parent.logger
+      @version           = parent.version
+      @digest_class      = parent.digest_class
+      @context_class     = Class.new(parent.context_class)
+      @root              = parent.root
+      @paths             = parent.paths
+      @mime_types        = parent.mime_types
+      @mime_exts         = parent.mime_exts
+      @encodings         = parent.encodings
+      @engines           = parent.engines
+      @engine_mime_types = parent.engine_mime_types
+      @transformers      = parent.transformers
+      @preprocessors     = parent.preprocessors
+      @postprocessors    = parent.postprocessors
+      @bundle_reducers   = parent.bundle_reducers
+      @bundle_processors = parent.bundle_processors
+      @compressors       = parent.compressors
+    end
+
+    # Get and set `Logger` instance.
+    attr_accessor :logger
+
+    # The `Environment#version` is a custom value used for manually
+    # expiring all asset caches.
+    #
+    # Sprockets is able to track most file and directory changes and
+    # will take care of expiring the cache for you. However, its
+    # impossible to know when any custom helpers change that you mix
+    # into the `Context`.
+    #
+    # It would be wise to increment this value anytime you make a
+    # configuration change to the `Environment` object.
+    attr_reader :version
+
+    # Assign an environment version.
+    #
+    #     environment.version = '2.0'
+    #
+    def version=(version)
+      mutate_config(:version) { version.dup }
+    end
+
+    # Returns a `Digest` implementation class.
+    #
+    # Defaults to `Digest::SHA1`.
+    attr_reader :digest_class
+
+    # Assign a `Digest` implementation class. This maybe any Ruby
+    # `Digest::` implementation such as `Digest::SHA1` or
+    # `Digest::MD5`.
+    #
+    #     environment.digest_class = Digest::MD5
+    #
+    def digest_class=(klass)
+      @digest_class = klass
+    end
+
+    # Deprecated: Get `Context` class.
+    #
+    # This class maybe mutated and mixed in with custom helpers.
+    #
+    #     environment.context_class.instance_eval do
+    #       include MyHelpers
+    #       def asset_url; end
+    #     end
+    #
+    attr_reader :context_class
+
+    private
+      def mutate_config(sym)
+        obj = yield self.instance_variable_get("@#{sym}").dup
+        self.instance_variable_set("@#{sym}", obj.freeze)
+      end
+
+      def mutate_hash_config(sym, key)
+        mutate_config(sym) do |hash|
+          obj = yield hash[key].dup
+          hash[key] = obj.freeze
+          hash
+        end
+      end
+  end
+end