sprockets 2.6.0 → 4.2.2

data/lib/sprockets/cache.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+require 'logger'
+require 'sprockets/digest_utils'
+
+module Sprockets
+  # Public: Wrapper interface to backend cache stores. Ensures a consistent API
+  # even when the backend uses get/set or read/write.
+  #
+  # Public cache interface
+  #
+  # Always assign the backend store instance to Environment#cache=.
+  #
+  #     environment.cache = Sprockets::Cache::MemoryStore.new(1000)
+  #
+  # Environment#cache will always return a wrapped Cache interface. See the
+  # methods marked public on this class.
+  #
+  #
+  # Backend cache interface
+  #
+  # The Backend cache store must implement two methods.
+  #
+  # get(key)
+  #
+  #   key - An opaque String with a length less than 250 characters.
+  #
+  #   Returns an JSON serializable object.
+  #
+  # set(key, value)
+  #
+  #   Will only be called once per key. Setting a key "foo" with value "bar",
+  #   then later key "foo" with value "baz" is an undefined behavior.
+  #
+  #   key   - An opaque String with a length less than 250 characters.
+  #   value - A JSON serializable object.
+  #
+  #   Returns argument value.
+  #
+  # clear(options)
+  #
+  #   Clear the entire cache. Be careful with this method since it could
+  #   affect other processes if shared cache is being used.
+  #
+  #   The options hash is passed to the underlying cache implementation.
+  class Cache
+    # Builtin cache stores.
+    autoload :FileStore,   'sprockets/cache/file_store'
+    autoload :MemoryStore, 'sprockets/cache/memory_store'
+    autoload :NullStore,   'sprockets/cache/null_store'
+
+    # Internal: Cache key version for this class. Rarely should have to change
+    # unless the cache format radically changes. Will be bump on major version
+    # releases though.
+    VERSION = '4.0.0'
+
+    def self.default_logger
+      logger = Logger.new($stderr)
+      logger.level = Logger::FATAL
+      logger
+    end
+
+    # Internal: Wrap a backend cache store.
+    #
+    # Always assign a backend cache store instance to Environment#cache= and
+    # use Environment#cache to retrieve a wrapped interface.
+    #
+    # cache - A compatible backend cache store instance.
+    def initialize(cache = nil, logger = self.class.default_logger)
+      @cache_wrapper = get_cache_wrapper(cache)
+      @fetch_cache   = Cache::MemoryStore.new(1024)
+      @logger        = logger
+    end
+
+    # Public: Prefer API to retrieve and set values in the cache store.
+    #
+    # key   - JSON serializable key
+    # block -
+    #   Must return a consistent JSON serializable object for the given key.
+    #
+    # Examples
+    #
+    #   cache.fetch("foo") { "bar" }
+    #
+    # Returns a JSON serializable object.
+    def fetch(key)
+      start = Time.now.to_f
+      expanded_key = expand_key(key)
+      value = @fetch_cache.get(expanded_key)
+      if value.nil?
+        value = @cache_wrapper.get(expanded_key)
+        if value.nil?
+          value = yield
+          @cache_wrapper.set(expanded_key, value)
+          @logger.debug do
+            ms = "(#{((Time.now.to_f - start) * 1000).to_i}ms)"
+            "Sprockets Cache miss #{peek_key(key)}  #{ms}"
+          end
+        end
+        @fetch_cache.set(expanded_key, value)
+      end
+      value
+    end
+
+    # Public: Low level API to retrieve item directly from the backend cache
+    # store.
+    #
+    # This API may be used publicly, but may have undefined behavior
+    # depending on the backend store being used. Prefer the
+    # Cache#fetch API over using this.
+    #
+    # key   - JSON serializable key
+    # local - Check local cache first (default: false)
+    #
+    # Returns a JSON serializable object or nil if there was a cache miss.
+    def get(key, local = false)
+      expanded_key = expand_key(key)
+
+      if local && value = @fetch_cache.get(expanded_key)
+        return value
+      end
+
+      value = @cache_wrapper.get(expanded_key)
+      @fetch_cache.set(expanded_key, value) if local
+
+      value
+    end
+
+    # Public: Low level API to set item directly to the backend cache store.
+    #
+    # This API may be used publicly, but may have undefined behavior
+    # depending on the backend store being used. Prefer the
+    # Cache#fetch API over using this.
+    #
+    # key   - JSON serializable key
+    # value - A consistent JSON serializable object for the given key. Setting
+    #         a different value for the given key has undefined behavior.
+    # local - Set on local cache (default: false)
+    #
+    # Returns the value argument.
+    def set(key, value, local = false)
+      expanded_key = expand_key(key)
+      @fetch_cache.set(expanded_key, value) if local
+      @cache_wrapper.set(expanded_key, value)
+    end
+
+    # Public: Pretty inspect
+    #
+    # Returns String.
+    def inspect
+      "#<#{self.class} local=#{@fetch_cache.inspect} store=#{@cache_wrapper.cache.inspect}>"
+    end
+
+    # Public: Clear cache
+    #
+    # Returns truthy on success, potentially raises exception on failure
+    def clear(options=nil)
+      @cache_wrapper.clear
+      @fetch_cache.clear
+    end
+
+    private
+      # Internal: Expand object cache key into a short String key.
+      #
+      # The String should be under 250 characters so its compatible with
+      # Memcache.
+      #
+      # key - JSON serializable key
+      #
+      # Returns a String with a length less than 250 characters.
+      def expand_key(key)
+        digest_key = DigestUtils.pack_urlsafe_base64digest(DigestUtils.digest(key))
+        namespace = digest_key[0, 2]
+        "sprockets/v#{VERSION}/#{namespace}/#{digest_key}"
+      end
+
+      PEEK_SIZE = 100
+
+      # Internal: Show first 100 characters of cache key for logging purposes.
+      #
+      # Returns a String with a length less than 100 characters.
+      def peek_key(key)
+        case key
+        when Integer
+          key.to_s
+        when String
+          key[0, PEEK_SIZE].inspect
+        when Array
+          str = []
+          key.each { |k| str << peek_key(k) }
+          str.join(':')[0, PEEK_SIZE]
+        else
+          peek_key(DigestUtils.pack_urlsafe_base64digest(DigestUtils.digest(key)))
+        end
+      end
+
+      def get_cache_wrapper(cache)
+        if cache.is_a?(Cache)
+          cache
+
+        # `Cache#get(key)` for Memcache
+        elsif cache.respond_to?(:get)
+          GetWrapper.new(cache)
+
+        # `Cache#[key]` so `Hash` can be used
+        elsif cache.respond_to?(:[])
+          HashWrapper.new(cache)
+
+        # `Cache#read(key)` for `ActiveSupport::Cache` support
+        elsif cache.respond_to?(:read)
+          ReadWriteWrapper.new(cache)
+
+        else
+          cache = Sprockets::Cache::NullStore.new
+          GetWrapper.new(cache)
+        end
+      end
+
+      class Wrapper < Struct.new(:cache)
+      end
+
+      class GetWrapper < Wrapper
+        def get(key)
+          cache.get(key)
+        end
+
+        def set(key, value)
+          cache.set(key, value)
+        end
+
+        def clear(options=nil)
+          # dalli has a #flush method so try it
+          if cache.respond_to?(:flush)
+            cache.flush(options)
+          else
+            cache.clear(options)
+          end
+          true
+        end
+      end
+
+      class HashWrapper < Wrapper
+        def get(key)
+          cache[key]
+        end
+
+        def set(key, value)
+          cache[key] = value
+        end
+
+        def clear(options=nil)
+          cache.clear
+          true
+        end
+      end
+
+      class ReadWriteWrapper < Wrapper
+        def get(key)
+          cache.read(key)
+        end
+
+        def set(key, value)
+          cache.write(key, value)
+        end
+
+        def clear(options=nil)
+          cache.clear(options)
+          true
+        end
+      end
+  end
+end

data/lib/sprockets/cached_environment.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require 'sprockets/base'
+
+module Sprockets
+  # `CachedEnvironment` is a special cached version of `Environment`.
+  #
+  # The exception is that all of its file system methods are cached
+  # for the instances lifetime. This makes `CachedEnvironment` much faster. This
+  # behavior is ideal in production environments where the file system
+  # is immutable.
+  #
+  # `CachedEnvironment` should not be initialized directly. Instead use
+  # `Environment#cached`.
+  class CachedEnvironment < Base
+    def initialize(environment)
+      initialize_configuration(environment)
+
+      @cache   = environment.cache
+      @stats   = Concurrent::Map.new
+      @entries = Concurrent::Map.new
+      @uris    = Concurrent::Map.new
+      @processor_cache_keys = Concurrent::Map.new
+      @resolved_dependencies = Concurrent::Map.new
+    end
+
+    # No-op return self as cached environment.
+    def cached
+      self
+    end
+    alias_method :index, :cached
+
+    # Internal: Cache Environment#entries
+    def entries(path)
+      @entries.fetch_or_store(path) { super(path) }
+    end
+
+    # Internal: Cache Environment#stat
+    def stat(path)
+      @stats.fetch_or_store(path) { super(path) }
+    end
+
+    # Internal: Cache Environment#load
+    def load(uri)
+      @uris.fetch_or_store(uri) { super(uri) }
+    end
+
+    # Internal: Cache Environment#processor_cache_key
+    def processor_cache_key(str)
+      @processor_cache_keys.fetch_or_store(str) { super(str) }
+    end
+
+    # Internal: Cache Environment#resolve_dependency
+    def resolve_dependency(str)
+      @resolved_dependencies.fetch_or_store(str) { super(str) }
+    end
+
+    private
+      # Cache is immutable, any methods that try to change the runtime config
+      # should bomb.
+      def config=(config)
+        raise RuntimeError, "can't modify immutable cached environment"
+      end
+  end
+end

data/lib/sprockets/closure_compressor.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+require 'sprockets/autoload'
+require 'sprockets/digest_utils'
+
+module Sprockets
+  # 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'
+
+    # Public: Return singleton instance with default options.
+    #
+    # Returns ClosureCompressor object.
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.call(input)
+      instance.call(input)
+    end
+
+    def self.cache_key
+      instance.cache_key
+    end
+
+    attr_reader :cache_key
+
+    def initialize(options = {})
+      @options = options
+      @cache_key = "#{self.class.name}:#{Autoload::Closure::VERSION}:#{Autoload::Closure::COMPILER_VERSION}:#{VERSION}:#{DigestUtils.digest(options)}".freeze
+    end
+
+    def call(input)
+      @compiler ||= Autoload::Closure::Compiler.new(@options)
+      @compiler.compile(input[:data])
+    end
+  end
+end

data/lib/sprockets/coffee_script_processor.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require 'sprockets/autoload'
+require 'sprockets/source_map_utils'
+
+module Sprockets
+  # Processor engine class for the CoffeeScript compiler.
+  # Depends on the `coffee-script` and `coffee-script-source` gems.
+  #
+  # For more information see:
+  #
+  #   https://github.com/rails/ruby-coffee-script
+  #
+  module CoffeeScriptProcessor
+    VERSION = '2'
+
+    def self.cache_key
+      @cache_key ||= "#{name}:#{Autoload::CoffeeScript::Source.version}:#{VERSION}".freeze
+    end
+
+    def self.call(input)
+      data = input[:data]
+
+      js, map = input[:cache].fetch([self.cache_key, data, input[:filename]]) do
+        result = Autoload::CoffeeScript.compile(
+          data,
+          sourceMap: "v3",
+          sourceFiles: [File.basename(input[:filename])],
+          generatedFile: input[:filename]
+        )
+        [result['js'], JSON.parse(result['v3SourceMap'])]
+      end
+
+      map = SourceMapUtils.format_source_map(map, input)
+      map = SourceMapUtils.combine_source_maps(input[:metadata][:map], map)
+
+      { data: js, map: map }
+    end
+  end
+end

data/lib/sprockets/compressing.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+require 'sprockets/utils'
+
+module Sprockets
+  # `Compressing` is an internal mixin whose public methods are exposed on
+  # the `Environment` and `CachedEnvironment` classes.
+  module Compressing
+    include Utils
+
+    def compressors
+      config[:compressors]
+    end
+
+    # Public: Register a new compressor `klass` at `sym` for `mime_type`.
+    #
+    # Registering a processor allows it to be looked up by `sym` later when
+    # assigning a JavaScript or CSS compressor.
+    #
+    # Compressors only operate on JavaScript and CSS. If you want to compress a
+    # different type of asset, use a processor instead.
+    #
+    # Examples
+    #
+    #     register_compressor 'text/css', :my_sass, MySassCompressor
+    #     css_compressor = :my_sass
+    #
+    # mime_type - String MIME Type (one of: 'test/css' or 'application/javascript').
+    # sym       - Symbol registration address.
+    # klass     - The compressor class.
+    #
+    # Returns nothing.
+    def register_compressor(mime_type, sym, klass)
+      self.config = hash_reassoc(config, :compressors, mime_type) do |compressors|
+        compressors[sym] = klass
+        compressors
+      end
+    end
+
+    # Return CSS compressor or nil if none is set
+    def css_compressor
+      if defined? @css_compressor
+        @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 defined? @css_compressor
+      @css_compressor = nil
+      return unless compressor
+
+      if compressor.is_a?(Symbol)
+        @css_compressor = klass = config[:compressors]['text/css'][compressor] || raise(Error, "unknown compressor: #{compressor}")
+      elsif compressor.respond_to?(:compress)
+        klass = proc { |input| compressor.compress(input[:data]) }
+        @css_compressor = :css_compressor
+      else
+        @css_compressor = klass = compressor
+      end
+
+      register_bundle_processor 'text/css', klass
+    end
+
+    # Return JS compressor or nil if none is set
+    def js_compressor
+      if defined? @js_compressor
+        @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 defined? @js_compressor
+      @js_compressor = nil
+      return unless compressor
+
+      if compressor.is_a?(Symbol)
+        @js_compressor = klass = config[:compressors]['application/javascript'][compressor] || raise(Error, "unknown compressor: #{compressor}")
+      elsif compressor.respond_to?(:compress)
+        klass = proc { |input| compressor.compress(input[:data]) }
+        @js_compressor = :js_compressor
+      else
+        @js_compressor = klass = compressor
+      end
+
+      register_bundle_processor 'application/javascript', klass
+    end
+
+    # Public: Checks if Gzip is enabled.
+    def gzip?
+      config[:gzip_enabled]
+    end
+
+    # Public: Checks if Gzip is disabled.
+    def skip_gzip?
+      !gzip?
+    end
+
+    # Public: Enable or disable the creation of Gzip files.
+    #
+    # To disable gzip generation set to a falsey value:
+    #
+    #     environment.gzip = false
+    #
+    # To enable set to a truthy value. By default zlib wil
+    # be used to gzip assets. If you have the Zopfli gem
+    # installed you can specify the zopfli algorithm to be used
+    # instead:
+    #
+    #     environment.gzip = :zopfli
+    #
+    def gzip=(gzip)
+      self.config = config.merge(gzip_enabled: gzip).freeze
+
+      case gzip
+      when false, nil
+        self.unregister_exporter Exporters::ZlibExporter
+        self.unregister_exporter Exporters::ZopfliExporter
+      when :zopfli
+        self.unregister_exporter Exporters::ZlibExporter
+        self.register_exporter '*/*', Exporters::ZopfliExporter
+      else
+        self.unregister_exporter Exporters::ZopfliExporter
+        self.register_exporter '*/*', Exporters::ZlibExporter
+      end
+
+      gzip
+    end
+  end
+end

data/lib/sprockets/configuration.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+require 'sprockets/compressing'
+require 'sprockets/dependencies'
+require 'sprockets/mime'
+require 'sprockets/paths'
+require 'sprockets/processing'
+require 'sprockets/exporting'
+require 'sprockets/transformers'
+require 'sprockets/utils'
+
+module Sprockets
+  module Configuration
+    include Paths, Mime, Transformers, Processing, Exporting, Compressing, Dependencies, Utils
+
+    def initialize_configuration(parent)
+      @config = parent.config
+      @logger = parent.logger
+      @context_class = Class.new(parent.context_class)
+    end
+
+    attr_reader :config
+
+    def config=(config)
+      raise TypeError, "can't assign mutable config" unless config.frozen?
+      @config = config
+    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.
+    def version
+      config[:version]
+    end
+
+    # Assign an environment version.
+    #
+    #     environment.version = '2.0'
+    #
+    def version=(version)
+      self.config = hash_reassoc(config, :version) { version.dup }
+    end
+
+    # Public: Returns a `Digest` implementation class.
+    #
+    # Defaults to `Digest::SHA256`.
+    def digest_class
+      config[:digest_class]
+    end
+
+    # Deprecated: Assign a `Digest` implementation class. This maybe any Ruby
+    # `Digest::` implementation such as `Digest::SHA256` or
+    # `Digest::SHA512`.
+    #
+    #     environment.digest_class = Digest::SHA512
+    #
+    def digest_class=(klass)
+      self.config = config.merge(digest_class: klass).freeze
+    end
+
+    # 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
+  end
+end