sprockets 4.0.1

data/lib/sprockets/base.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+require 'sprockets/asset'
+require 'sprockets/bower'
+require 'sprockets/cache'
+require 'sprockets/configuration'
+require 'sprockets/digest_utils'
+require 'sprockets/errors'
+require 'sprockets/loader'
+require 'sprockets/npm'
+require 'sprockets/path_dependency_utils'
+require 'sprockets/path_digest_utils'
+require 'sprockets/path_utils'
+require 'sprockets/resolve'
+require 'sprockets/server'
+require 'sprockets/source_map_utils'
+require 'sprockets/uri_tar'
+
+module Sprockets
+
+  class DoubleLinkError < Sprockets::Error
+    def initialize(parent_filename:, logical_path:, last_filename:, filename:)
+      super <<~MSG
+        Multiple files with the same output path cannot be linked (#{logical_path.inspect})
+        In #{parent_filename.inspect} these files were linked:
+          - #{last_filename}
+          - #{filename}
+      MSG
+    end
+  end
+
+  # `Base` class for `Environment` and `CachedEnvironment`.
+  class Base
+    include PathUtils, PathDependencyUtils, PathDigestUtils, DigestUtils, SourceMapUtils
+    include Configuration
+    include Server
+    include Resolve, Loader
+    include Bower
+    include Npm
+
+    # Get persistent cache store
+    attr_reader :cache
+
+    # Set persistent cache store
+    #
+    # The cache store must implement a pair of getters and
+    # setters. Either `get(key)`/`set(key, value)`,
+    # `[key]`/`[key]=value`, `read(key)`/`write(key, value)`.
+    def cache=(cache)
+      @cache = Cache.new(cache, logger)
+    end
+
+    # Return an `CachedEnvironment`. Must be implemented by the subclass.
+    def cached
+      raise NotImplementedError
+    end
+    alias_method :index, :cached
+
+    # Internal: Compute digest for path.
+    #
+    # path - String filename or directory path.
+    #
+    # Returns a String digest or nil.
+    def file_digest(path)
+      if stat = self.stat(path)
+        # Caveat: Digests are cached by the path's current mtime. Its possible
+        # for a files contents to have changed and its mtime to have been
+        # negligently reset thus appearing as if the file hasn't changed on
+        # disk. Also, the mtime is only read to the nearest second. It's
+        # also possible the file was updated more than once in a given second.
+        key = UnloadedAsset.new(path, self).file_digest_key(stat.mtime.to_i)
+        cache.fetch(key) do
+          self.stat_digest(path, stat)
+        end
+      end
+    end
+
+    # Find asset by logical path or expanded path.
+    def find_asset(*args, **options)
+      uri, _ = resolve(*args, **options)
+      if uri
+        load(uri)
+      end
+    end
+
+    def find_all_linked_assets(*args)
+      return to_enum(__method__, *args) unless block_given?
+
+      parent_asset = asset = find_asset(*args)
+      return unless asset
+
+      yield asset
+      stack = asset.links.to_a
+      linked_paths = {}
+
+      while uri = stack.shift
+        yield asset = load(uri)
+
+        last_filename = linked_paths[asset.logical_path]
+        if last_filename && last_filename != asset.filename
+          raise DoubleLinkError.new(
+            parent_filename: parent_asset.filename,
+            last_filename:   last_filename,
+            logical_path:    asset.logical_path,
+            filename:        asset.filename
+          )
+        end
+        linked_paths[asset.logical_path] = asset.filename
+        stack = asset.links.to_a + stack
+      end
+
+      nil
+    end
+
+    # Preferred `find_asset` shorthand.
+    #
+    #     environment['application.js']
+    #
+    def [](*args, **options)
+      find_asset(*args, **options)
+    end
+
+    # Find asset by logical path or expanded path.
+    #
+    # If the asset is not found an error will be raised.
+    def find_asset!(*args)
+      uri, _ = resolve!(*args)
+      if uri
+        load(uri)
+      end
+    end
+
+    # Pretty inspect
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)} " +
+        "root=#{root.to_s.inspect}, " +
+        "paths=#{paths.inspect}>"
+    end
+
+    def compress_from_root(uri)
+      URITar.new(uri, self).compress
+    end
+
+    def expand_from_root(uri)
+      URITar.new(uri, self).expand
+    end
+  end
+end

data/lib/sprockets/bower.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+require 'json'
+
+module Sprockets
+  module Bower
+    # Internal: All supported bower.json files.
+    #
+    # https://github.com/bower/json/blob/0.4.0/lib/json.js#L7
+    POSSIBLE_BOWER_JSONS = ['bower.json', 'component.json', '.bower.json']
+
+    # Internal: Override resolve_alternates to install bower.json behavior.
+    #
+    # load_path    - String environment path
+    # logical_path - String path relative to base
+    #
+    # Returns candiate filenames.
+    def resolve_alternates(load_path, logical_path)
+      candidates, deps = super
+
+      # bower.json can only be nested one level deep
+      if !logical_path.index('/'.freeze)
+        dirname = File.join(load_path, logical_path)
+
+        if directory?(dirname)
+          filenames = POSSIBLE_BOWER_JSONS.map { |basename| File.join(dirname, basename) }
+          filename  = filenames.detect { |fn| self.file?(fn) }
+
+          if filename
+            deps << build_file_digest_uri(filename)
+            read_bower_main(dirname, filename) do |path|
+              if file?(path)
+                candidates << path
+              end
+            end
+          end
+        end
+      end
+
+      return candidates, deps
+    end
+
+    # Internal: Read bower.json's main directive.
+    #
+    # dirname  - String path to component directory.
+    # filename - String path to bower.json.
+    #
+    # Returns nothing.
+    def read_bower_main(dirname, filename)
+      bower = JSON.parse(File.read(filename), create_additions: false)
+
+      case bower['main']
+      when String
+        yield File.expand_path(bower['main'], dirname)
+      when Array
+        bower['main'].each do |name|
+          yield File.expand_path(name, dirname)
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/bundle.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+require 'set'
+require 'sprockets/utils'
+require 'sprockets/uri_utils'
+
+module Sprockets
+  # Internal: Bundle processor takes a single file asset and prepends all the
+  # `:required` URIs to the contents.
+  #
+  # Uses pipeline metadata:
+  #
+  #   :required - Ordered Set of asset URIs to prepend
+  #   :stubbed  - Set of asset URIs to substract from the required set.
+  #
+  # Also see DirectiveProcessor.
+  class Bundle
+    def self.call(input)
+      env  = input[:environment]
+      type = input[:content_type]
+      input[:links] ||= Set.new
+      dependencies = Set.new(input[:metadata][:dependencies])
+
+      processed_uri, deps = env.resolve(input[:filename], accept: type, pipeline: :self)
+      dependencies.merge(deps)
+
+      # DirectiveProcessor (and any other transformers called here with pipeline=self)
+      primary_asset = env.load(processed_uri)
+      to_load = primary_asset.metadata.delete(:to_load) || Set.new
+      to_link = primary_asset.metadata.delete(:to_link) || Set.new
+
+      to_load.each do |uri|
+        loaded_asset = env.load(uri)
+        dependencies.merge(loaded_asset.metadata[:dependencies])
+        if to_link.include?(uri)
+          primary_metadata = primary_asset.metadata
+          input[:links]            << loaded_asset.uri
+          primary_metadata[:links] << loaded_asset.uri
+        end
+      end
+
+      find_required = proc { |uri| env.load(uri).metadata[:required] }
+      required = Utils.dfs(processed_uri, &find_required)
+      stubbed  = Utils.dfs(env.load(processed_uri).metadata[:stubbed], &find_required)
+      required.subtract(stubbed)
+      dedup(required)
+      assets = required.map { |uri| env.load(uri) }
+
+      (required + stubbed).each do |uri|
+        dependencies.merge(env.load(uri).metadata[:dependencies])
+      end
+
+      reducers = Hash[env.match_mime_type_keys(env.config[:bundle_reducers], type).flat_map(&:to_a)]
+      process_bundle_reducers(input, assets, reducers).merge(dependencies: dependencies, included: assets.map(&:uri))
+    end
+
+    # Internal: Removes uri from required if it's already included as an alias.
+    #
+    # required - Set of required uris
+    #
+    # Returns deduped set of uris
+    def self.dedup(required)
+      dupes = required.reduce([]) do |r, uri|
+        path, params = URIUtils.parse_asset_uri(uri)
+        if (params.delete(:index_alias))
+          r << URIUtils.build_asset_uri(path, params)
+        end
+        r
+      end
+      required.subtract(dupes)
+    end
+
+    # Internal: Run bundle reducers on set of Assets producing a reduced
+    # metadata Hash.
+    #
+    # filename - String bundle filename
+    # assets - Array of Assets
+    # reducers - Array of [initial, reducer_proc] pairs
+    #
+    # Returns reduced asset metadata Hash.
+    def self.process_bundle_reducers(input, assets, reducers)
+      initial = {}
+      reducers.each do |k, (v, _)|
+        if v.respond_to?(:call)
+          initial[k] = v.call(input)
+        elsif !v.nil?
+          initial[k] = v
+        end
+      end
+
+      assets.reduce(initial) do |h, asset|
+        reducers.each do |k, (_, block)|
+          value = k == :data ? asset.source : asset.metadata[k]
+          if h.key?(k)
+            if !value.nil?
+              h[k] = block.call(h[k], value)
+            end
+          else
+            h[k] = value
+          end
+        end
+        h
+      end
+    end
+  end
+end

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 retreive 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