sprockets 2.3.2 → 3.0.0

data/lib/sprockets/base.rb

@@ -1,89 +1,24 @@
-require 'sprockets/asset_attributes'
-require 'sprockets/bundled_asset'
-require 'sprockets/caching'
-require 'sprockets/processed_asset'
-require 'sprockets/processing'
+require 'sprockets/asset'
+require 'sprockets/bower'
+require 'sprockets/cache'
+require 'sprockets/configuration'
+require 'sprockets/digest_utils'
+require 'sprockets/errors'
+require 'sprockets/loader'
+require 'sprockets/path_digest_utils'
+require 'sprockets/path_dependency_utils'
+require 'sprockets/path_utils'
+require 'sprockets/resolve'
 require 'sprockets/server'
-require 'sprockets/static_asset'
-require 'sprockets/trail'
-require 'pathname'
 
 module Sprockets
-  # `Base` class for `Environment` and `Index`.
+  # `Base` class for `Environment` and `Cached`.
   class Base
-    include Caching, Processing, Server, Trail
-
-    # Returns a `Digest` implementation class.
-    #
-    # Defaults to `Digest::MD5`.
-    attr_reader :digest_class
-
-    # Assign a `Digest` implementation class. This maybe any Ruby
-    # `Digest::` implementation such as `Digest::MD5` or
-    # `Digest::SHA1`.
-    #
-    #     environment.digest_class = Digest::SHA1
-    #
-    def digest_class=(klass)
-      expire_index!
-      @digest_class = klass
-    end
-
-    # 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)
-      expire_index!
-      @version = version
-    end
-
-    # Returns a `Digest` instance for the `Environment`.
-    #
-    # This value serves two purposes. If two `Environment`s have the
-    # same digest value they can be treated as equal. This is more
-    # useful for comparing environment states between processes rather
-    # than in the same. Two equal `Environment`s can share the same
-    # cached assets.
-    #
-    # The value also provides a seed digest for all `Asset`
-    # digests. Any change in the environment digest will affect all of
-    # its assets.
-    def digest
-      # Compute the initial digest using the implementation class. The
-      # Sprockets release version and custom environment version are
-      # mixed in. So any new releases will affect all your assets.
-      @digest ||= digest_class.new.update(VERSION).update(version.to_s)
-
-      # Returned a dupped copy so the caller can safely mutate it with `.update`
-      @digest.dup
-    end
-
-    # Get and set `Logger` instance.
-    attr_accessor :logger
-
-    # 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
+    include PathUtils, PathDependencyUtils, PathDigestUtils, DigestUtils
+    include Configuration
+    include Server
+    include Resolve, Loader
+    include Bower
 
     # Get persistent cache store
     attr_reader :cache
@@ -94,79 +29,56 @@ module Sprockets
     # setters. Either `get(key)`/`set(key, value)`,
     # `[key]`/`[key]=value`, `read(key)`/`write(key, value)`.
     def cache=(cache)
-      expire_index!
-      @cache = cache
+      @cache = Cache.new(cache, logger)
     end
 
-    # Return an `Index`. Must be implemented by the subclass.
-    def index
+    # Return an `Cached`. Must be implemented by the subclass.
+    def cached
       raise NotImplementedError
     end
+    alias_method :index, :cached
 
-    if defined? Encoding.default_external
-      # Define `default_external_encoding` accessor on 1.9.
-      # Defaults to UTF-8.
-      attr_accessor :default_external_encoding
-    end
-
-    # Works like `Dir.entries`.
-    #
-    # Subclasses may cache this method.
-    def entries(pathname)
-      trail.entries(pathname)
-    end
-
-    # Works like `File.stat`.
+    # Internal: Compute digest for path.
     #
-    # Subclasses may cache this method.
-    def stat(path)
-      trail.stat(path)
-    end
-
-    # Read and compute digest of filename.
+    # path - String filename or directory path.
     #
-    # Subclasses may cache this method.
+    # Returns a String digest or nil.
     def file_digest(path)
       if stat = self.stat(path)
-        # If its a file, digest the contents
-        if stat.file?
-          digest.file(path.to_s)
-
-        # If its a directive, digest the list of filenames
-        elsif stat.directory?
-          contents = self.entries(path).join(',')
-          digest.update(contents)
+        # 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. Its
+        # also possible the file was updated more than once in a given second.
+        cache.fetch("file_digest:#{path}:#{stat.mtime.to_i}") do
+          self.stat_digest(path, stat)
         end
       end
     end
 
-    # Internal. Return a `AssetAttributes` for `path`.
-    def attributes_for(path)
-      AssetAttributes.new(self, path)
+    # Find asset by logical path or expanded path.
+    def find_asset(path, options = {})
+      uri, _ = resolve(path, options.merge(compat: false))
+      if uri
+        load(uri)
+      end
     end
 
-    # Internal. Return content type of `path`.
-    def content_type_of(path)
-      attributes_for(path).content_type
-    end
+    def find_all_linked_assets(path, options = {})
+      return to_enum(__method__, path, options) unless block_given?
 
-    # Find asset by logical path or expanded path.
-    def find_asset(path, options = {})
-      logical_path = path
-      pathname     = Pathname.new(path)
+      asset = find_asset(path, options)
+      return unless asset
 
-      if pathname.absolute?
-        return unless stat(pathname)
-        logical_path = attributes_for(pathname).logical_path
-      else
-        begin
-          pathname = resolve(logical_path)
-        rescue FileNotFound
-          return nil
-        end
+      yield asset
+      stack = asset.links.to_a
+
+      while uri = stack.shift
+        yield asset = load(uri)
+        stack = asset.links.to_a + stack
       end
 
-      build_asset(logical_path, pathname, options)
+      nil
     end
 
     # Preferred `find_asset` shorthand.
@@ -177,131 +89,11 @@ module Sprockets
       find_asset(*args)
     end
 
-    def each_entry(root, &block)
-      return to_enum(__method__, root) unless block_given?
-      root = Pathname.new(root) unless root.is_a?(Pathname)
-
-      paths = []
-      entries(root).sort.each do |filename|
-        path = root.join(filename)
-        paths << path
-
-        if stat(path).directory?
-          each_entry(path) do |subpath|
-            paths << subpath
-          end
-        end
-      end
-
-      paths.sort_by(&:to_s).each(&block)
-
-      nil
-    end
-
-    def each_file
-      return to_enum(__method__) unless block_given?
-      paths.each do |root|
-        each_entry(root) do |path|
-          if !stat(path).directory?
-            yield path
-          end
-        end
-      end
-      nil
-    end
-
-    def each_logical_path(*args)
-      return to_enum(__method__, *args) unless block_given?
-      filters = args.flatten
-      files = {}
-      each_file do |filename|
-        if logical_path = logical_path_for_filename(filename, filters)
-          yield logical_path unless files[logical_path]
-          files[logical_path] = true
-        end
-      end
-      nil
-    end
-
     # Pretty inspect
     def inspect
       "#<#{self.class}:0x#{object_id.to_s(16)} " +
         "root=#{root.to_s.inspect}, " +
-        "paths=#{paths.inspect}, " +
-        "digest=#{digest.to_s.inspect}" +
-        ">"
+        "paths=#{paths.inspect}>"
     end
-
-    protected
-      # Clear index after mutating state. Must be implemented by the subclass.
-      def expire_index!
-        raise NotImplementedError
-      end
-
-      def build_asset(logical_path, pathname, options)
-        pathname = Pathname.new(pathname)
-
-        # If there are any processors to run on the pathname, use
-        # `BundledAsset`. Otherwise use `StaticAsset` and treat is as binary.
-        if attributes_for(pathname).processors.any?
-          if options[:bundle] == false
-            circular_call_protection(pathname.to_s) do
-              ProcessedAsset.new(index, logical_path, pathname)
-            end
-          else
-            BundledAsset.new(index, logical_path, pathname)
-          end
-        else
-          StaticAsset.new(index, logical_path, pathname)
-        end
-      end
-
-      def cache_key_for(path, options)
-        "#{path}:#{options[:bundle] ? '1' : '0'}"
-      end
-
-      def circular_call_protection(path)
-        reset = Thread.current[:sprockets_circular_calls].nil?
-        calls = Thread.current[:sprockets_circular_calls] ||= Set.new
-        if calls.include?(path)
-          raise CircularDependencyError, "#{path} has already been required"
-        end
-        calls << path
-        yield
-      ensure
-        Thread.current[:sprockets_circular_calls] = nil if reset
-      end
-
-      def logical_path_for_filename(filename, filters)
-        logical_path = attributes_for(filename).logical_path.to_s
-
-        if matches_filter(filters, logical_path)
-          return logical_path
-        end
-
-        # If filename is an index file, retest with alias
-        if File.basename(logical_path)[/[^\.]+/, 0] == 'index'
-          path = logical_path.sub(/\/index\./, '.')
-          if matches_filter(filters, path)
-            return path
-          end
-        end
-
-        nil
-      end
-
-      def matches_filter(filters, filename)
-        return true if filters.empty?
-
-        filters.any? do |filter|
-          if filter.is_a?(Regexp)
-            filter.match(filename)
-          elsif filter.respond_to?(:call)
-            filter.call(filename)
-          else
-            File.fnmatch(filter.to_s, filename)
-          end
-        end
-      end
   end
 end

data/lib/sprockets/bower.rb

@@ -0,0 +1,58 @@
+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('/')
+        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|
+              candidates << path
+            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,65 @@
+require 'set'
+require 'sprockets/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]
+      dependencies = Set.new(input[:metadata][:dependencies])
+
+      processed_uri, deps = env.resolve(input[:filename], accept: type, pipeline: :self, compat: false)
+      dependencies.merge(deps)
+
+      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)
+      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(assets, reducers).merge(dependencies: dependencies, included: assets.map(&:uri))
+    end
+
+    # Internal: Run bundle reducers on set of Assets producing a reduced
+    # metadata Hash.
+    #
+    # assets - Array of Assets
+    # reducers - Array of [initial, reducer_proc] pairs
+    #
+    # Returns reduced asset metadata Hash.
+    def self.process_bundle_reducers(assets, reducers)
+      initial = {}
+      reducers.each do |k, (v, _)|
+        initial[k] = v if !v.nil?
+      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/file_store.rb

@@ -1,32 +1,183 @@
-require 'digest/md5'
 require 'fileutils'
-require 'pathname'
+require 'logger'
+require 'sprockets/encoding_utils'
+require 'sprockets/path_utils'
+require 'zlib'
 
 module Sprockets
-  module Cache
-    # A simple file system cache store.
+  class Cache
+    # Public: A file system cache store that automatically cleans up old keys.
+    #
+    # Assign the instance to the Environment#cache.
     #
     #     environment.cache = Sprockets::Cache::FileStore.new("/tmp")
     #
+    # See Also
+    #
+    #   ActiveSupport::Cache::FileStore
+    #
     class FileStore
-      def initialize(root)
-        @root = Pathname.new(root)
+      # Internal: Default key limit for store.
+      DEFAULT_MAX_SIZE = 25 * 1024 * 1024
+
+      # Internal: Default standard error fatal logger.
+      #
+      # Returns a Logger.
+      def self.default_logger
+        logger = Logger.new($stderr)
+        logger.level = Logger::FATAL
+        logger
       end
 
-      # Lookup value in cache
-      def [](key)
-        pathname = @root.join(key)
-        pathname.exist? ? pathname.open('rb') { |f| Marshal.load(f) } : nil
+      # Public: Initialize the cache store.
+      #
+      # root     - A String path to a directory to persist cached values to.
+      # max_size - A Integer of the maximum number of keys the store will hold.
+      #            (default: 1000).
+      def initialize(root, max_size = DEFAULT_MAX_SIZE, logger = self.class.default_logger)
+        @root     = root
+        @size     = find_caches.inject(0) { |n, (_, stat)| n + stat.size }
+        @max_size = max_size
+        @gc_size  = max_size * 0.75
+        @logger   = logger
       end
 
-      # Save value to cache
-      def []=(key, value)
+      # 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)
+        path = File.join(@root, "#{key}.cache")
+
+        value = safe_open(path) do |f|
+          begin
+            EncodingUtils.unmarshaled_deflated(f.read, Zlib::MAX_WBITS)
+          rescue Exception => e
+            @logger.error do
+              "#{self.class}[#{path}] could not be unmarshaled: " +
+                "#{e.class}: #{e.message}"
+            end
+            nil
+          end
+        end
+
+        if value
+          FileUtils.touch(path)
+          value
+        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)
+        path = File.join(@root, "#{key}.cache")
+
         # Ensure directory exists
-        FileUtils.mkdir_p @root.join(key).dirname
+        FileUtils.mkdir_p File.dirname(path)
+
+        # Check if cache exists before writing
+        exists = File.exist?(path)
+
+        # Serialize value
+        marshaled = Marshal.dump(value)
+
+        # Compress if larger than 4KB
+        if marshaled.bytesize > 4 * 1024
+          deflater = Zlib::Deflate.new(
+            Zlib::BEST_COMPRESSION,
+            Zlib::MAX_WBITS,
+            Zlib::MAX_MEM_LEVEL,
+            Zlib::DEFAULT_STRATEGY
+          )
+          deflater << marshaled
+          raw = deflater.finish
+        else
+          raw = marshaled
+        end
+
+        # Write data
+        PathUtils.atomic_write(path) do |f|
+          f.write(raw)
+          @size += f.size unless exists
+        end
+
+        # GC if necessary
+        gc! if @size > @max_size
 
-        @root.join(key).open('w') { |f| Marshal.dump(value, f)}
         value
       end
+
+      # Public: Pretty inspect
+      #
+      # Returns String.
+      def inspect
+        "#<#{self.class} size=#{@size}/#{@max_size}>"
+      end
+
+      private
+        # Internal: Get all cache files along with stats.
+        #
+        # Returns an Array of [String filename, File::Stat] pairs sorted by
+        # mtime.
+        def find_caches
+          Dir.glob(File.join(@root, '**/*.cache')).reduce([]) { |stats, filename|
+            stat = safe_stat(filename)
+            # stat maybe nil if file was removed between the time we called
+            # dir.glob and the next stat
+            stats << [filename, stat] if stat
+            stats
+          }.sort_by { |_, stat| stat.mtime.to_i }
+        end
+
+        def compute_size(caches)
+          caches.inject(0) { |sum, (_, stat)| sum + stat.size }
+        end
+
+        def safe_stat(fn)
+          File.stat(fn)
+        rescue Errno::ENOENT
+          nil
+        end
+
+        def safe_open(path, &block)
+          if File.exist?(path)
+            File.open(path, 'rb', &block)
+          end
+        rescue Errno::ENOENT
+        end
+
+        def gc!
+          start_time = Time.now
+
+          caches = find_caches
+          size = compute_size(caches)
+
+          delete_caches, keep_caches = caches.partition { |filename, stat|
+            deleted = size > @gc_size
+            size -= stat.size
+            deleted
+          }
+
+          return if delete_caches.empty?
+
+          FileUtils.remove(delete_caches.map(&:first), force: true)
+          @size = compute_size(keep_caches)
+
+          @logger.warn do
+            secs = Time.now.to_f - start_time.to_f
+            "#{self.class}[#{@root}] garbage collected " +
+              "#{delete_caches.size} files (#{(secs * 1000).to_i}ms)"
+          end
+        end
     end
   end
 end