sprockets 3.0.0.beta.6 → 3.0.0.beta.7

data/lib/sprockets/manifest.rb

@@ -106,50 +106,6 @@ module Sprockets
       @data['files'] ||= {}
     end
 
-    # Deprecated: Compile logical path matching filter into a proc that can be
-    # passed to logical_paths.select(&proc).
-    #
-    #   compile_match_filter(proc { |logical_path|
-    #     File.extname(logical_path) == '.js'
-    #   })
-    #
-    #   compile_match_filter(/application.js/)
-    #
-    #   compile_match_filter("foo/*.js")
-    #
-    # Returns a Proc or raise a TypeError.
-    def self.compile_match_filter(filter)
-      # If the filter is already a proc, great nothing to do.
-      if filter.respond_to?(:call)
-        filter
-      # If the filter is a regexp, wrap it in a proc that tests it against the
-      # logical path.
-      elsif filter.is_a?(Regexp)
-        proc { |logical_path| filter.match(logical_path) }
-      elsif filter.is_a?(String)
-        # If its an absolute path, detect the matching full filename
-        if PathUtils.absolute_path?(filter)
-          proc { |logical_path, filename| filename == filter.to_s }
-        else
-          # Otherwise do an fnmatch against the logical path.
-          proc { |logical_path| File.fnmatch(filter.to_s, logical_path) }
-        end
-      else
-        raise TypeError, "unknown filter type: #{filter.inspect}"
-      end
-    end
-
-    # Deprecated: Filter logical paths in environment. Useful for selecting what
-    # files you want to compile.
-    #
-    # Returns an Enumerator.
-    def filter_logical_paths(*args)
-      filters = args.flatten.map { |arg| self.class.compile_match_filter(arg) }
-      environment.logical_paths.select do |a, b|
-        filters.any? { |f| f.call(a, b) }
-      end
-    end
-
     # Public: Find all assets matching pattern set in environment.
     #
     # Returns Enumerator of Assets.
@@ -162,6 +118,7 @@ module Sprockets
 
       filters = args.flatten.map { |arg| self.class.compile_match_filter(arg) }
 
+      environment = self.environment.cached
       environment.logical_paths do |logical_path, filename|
         if filters.any? { |f| f.call(logical_path, filename) }
           environment.find_all_linked_assets(filename) do |asset|
@@ -173,9 +130,6 @@ module Sprockets
       nil
     end
 
-    # Deprecated alias.
-    alias_method :find_logical_paths, :filter_logical_paths
-
     # Compile and write asset to directory. The asset is written to a
     # fingerprinted filename like
     # `application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js`. An entry is
@@ -240,25 +194,34 @@ module Sprockets
     end
 
     # Cleanup old assets in the compile directory. By default it will
-    # keep the latest version plus 2 backups.
-    def clean(keep = 2)
+    # keep the latest version, 2 backups and any created within the past hour.
+    #
+    # Examples
+    #
+    #   To force only 1 backup to be kept, set count=1 and age=0.
+    #
+    #   To only keep files created within the last 10 minutes, set count=0 and
+    #   age=600.
+    #
+    def clean(count = 2, age = 3600)
       asset_versions = files.group_by { |_, attrs| attrs['logical_path'] }
 
       asset_versions.each do |logical_path, versions|
         current = assets[logical_path]
 
-        backups = versions.reject { |path, _|
+        versions.reject { |path, _|
           path == current
         }.sort_by { |_, attrs|
           # Sort by timestamp
           Time.parse(attrs['mtime'])
-        }.reverse
-
-        # Keep the last N backups
-        backups = backups[keep..-1] || []
-
-        # Remove old assets
-        backups.each { |path, _| remove(path) }
+        }.reverse.each_with_index.drop_while { |(_, attrs), index|
+          age = [0, Time.now - Time.parse(attrs['mtime'])].max
+          # Keep if under age or within the count limit
+          age < age || index < count
+        }.each { |(path, _), _|
+           # Remove old assets
+          remove(path)
+        }
       end
     end
 
@@ -272,9 +235,10 @@ module Sprockets
     protected
       # Persist manfiest back to FS
       def save
+        data = json_encode(@data)
         FileUtils.mkdir_p File.dirname(filename)
-        File.open(filename, 'w') do |f|
-          f.write json_encode(@data)
+        PathUtils.atomic_write(filename) do |f|
+          f.write(data)
         end
       end
 

data/lib/sprockets/mime.rb

@@ -1,9 +1,10 @@
 require 'sprockets/encoding_utils'
 require 'sprockets/http_utils'
+require 'sprockets/utils'
 
 module Sprockets
   module Mime
-    include HTTPUtils
+    include HTTPUtils, Utils
 
     # Public: Mapping of MIME type Strings to properties Hash.
     #
@@ -13,7 +14,9 @@ module Sprockets
     #   charset    - Default Encoding or function to detect encoding
     #
     # Returns Hash.
-    attr_reader :mime_types
+    def mime_types
+      config[:mime_types]
+    end
 
     # Internal: Mapping of MIME extension Strings to MIME type Strings.
     #
@@ -27,7 +30,9 @@ module Sprockets
     # value - MIME Type String
     #
     # Returns Hash.
-    attr_reader :mime_exts
+    def mime_exts
+      config[:mime_exts]
+    end
 
     # Public: Register a new mime type.
     #
@@ -49,20 +54,25 @@ module Sprockets
       }
 
       charset = options[:charset]
-      charset ||= EncodingUtils::DETECT if mime_type.start_with?('text/')
+      charset ||= :default if mime_type.start_with?('text/')
+      charset = EncodingUtils::CHARSET_DETECT[charset] if charset.is_a?(Symbol)
 
-      mutate_config(:mime_exts) do |mime_exts|
+      self.config = hash_reassoc(config, :mime_exts) do |mime_exts|
         extnames.each do |extname|
           mime_exts[extname] = mime_type
         end
         mime_exts
       end
 
-      mutate_config(:mime_types) do |mime_types|
+      self.config = hash_reassoc(config, :mime_types) do |mime_types|
         type = { extensions: extnames }
         type[:charset] = charset if charset
         mime_types.merge(mime_type => type)
       end
+
+      self.config = hash_reassoc(config, :_extnames) do
+        compute_extname_map
+      end
     end
 
     # Internal: Get detecter function for MIME type.
@@ -95,44 +105,21 @@ module Sprockets
       end
     end
 
-    # Public: Mapping of supported HTTP Content/Transfer encodings
-    #
-    # key   - String name
-    # value - Method/Proc to encode data
-    #
-    # Returns Hash.
-    attr_reader :encodings
-
-    # Public: Register a new encoding.
-    #
-    # Examples
-    #
-    #   register_encoding :gzip, EncodingUtils::GZIP
-    #
-    # key    - String name
-    # encode - Method/Proc to encode data
-    #
-    # Returns nothing.
-    def register_encoding(name, encode)
-      mutate_config(:encodings) do |encodings|
-        encodings.merge(name.to_s => encode)
-      end
-    end
-
     private
-      # Internal: Get a postprocessor to perform the encoding.
-      #
-      # encoding - String encoding.
-      #
-      # Returns an Array of Processors.
-      def unwrap_encoding_processors(encoding)
-        processors = []
-        if encoder = self.encodings[encoding]
-          processors << lambda do |input|
-            { data: encoder.call(input[:data]), encoding: encoding }
+      def compute_extname_map
+        graph = {}
+
+        ([[nil, nil]] + mime_exts.to_a).each do |format_extname, format_type|
+          3.times do |n|
+            engines.keys.permutation(n).each do |engine_extnames|
+              key = "#{format_extname}#{engine_extnames.join}"
+              type = format_type || engine_mime_types[engine_extnames.first]
+              graph[key] = {type: type, engines: engine_extnames}
+            end
           end
         end
-        processors
+
+        graph
       end
   end
 end

data/lib/sprockets/path_dependency_utils.rb

@@ -0,0 +1,76 @@
+require 'set'
+require 'sprockets/path_utils'
+require 'sprockets/uri_utils'
+
+module Sprockets
+  # Internal: Related PathUtils helpers that also track all the file system
+  # calls they make for caching purposes. All functions return a standard
+  # return value and a Set of cache dependency URIs that can be used in the
+  # future to see if the returned value should be invalidated from cache.
+  #
+  #     entries_with_dependencies("app/assets/javascripts")
+  #     # => [
+  #     #   ["application.js", "projects.js", "users.js", ...]
+  #     #    #<Set: {"file-digest:/path/to/app/assets/javascripts"}>
+  #     # ]
+  #
+  # The returned dependency set can be passed to resolve_dependencies(deps)
+  # to check if the returned result is still fresh. In this case, entry always
+  # returns a single path, but multiple calls should accumulate dependencies
+  # into a single set thats saved off and checked later.
+  #
+  #     resolve_dependencies(deps)
+  #     # => "\x01\x02\x03"
+  #
+  # Later, resolving the same set again will produce a different hash if
+  # something on the file system has changed.
+  #
+  #     resolve_dependencies(deps)
+  #     # => "\x03\x04\x05"
+  #
+  module PathDependencyUtils
+    include PathUtils
+    include URIUtils
+
+    # Internal: List directory entries and return a set of dependencies that
+    # would invalid the cached return result.
+    #
+    # See PathUtils#entries
+    #
+    # path - String directory path
+    #
+    # Returns an Array of entry names and a Set of dependency URIs.
+    def entries_with_dependencies(path)
+      return entries(path), Set.new([build_file_digest_uri(path)])
+    end
+
+    # Internal: List directory filenames and associated Stats under a
+    # directory.
+    #
+    # See PathUtils#stat_directory
+    #
+    # dir - A String directory
+    #
+    # Returns an Array of filenames and a Set of dependency URIs.
+    def stat_directory_with_dependencies(dir)
+      return stat_directory(dir).to_a, Set.new([build_file_digest_uri(dir)])
+    end
+
+    # Internal: List directory filenames and associated Stats under an entire
+    # directory tree.
+    #
+    # See PathUtils#stat_sorted_tree
+    #
+    # dir - A String directory
+    #
+    # Returns an Array of filenames and a Set of dependency URIs.
+    def stat_sorted_tree_with_dependencies(dir)
+      deps = Set.new([build_file_digest_uri(dir)])
+      results = stat_sorted_tree(dir).map do |path, stat|
+        deps << build_file_digest_uri(path) if stat.directory?
+        [path, stat]
+      end
+      return results, deps
+    end
+  end
+end

data/lib/sprockets/path_utils.rb

@@ -57,7 +57,7 @@ module Sprockets
       require 'pathname'
 
       # On Windows, ALT_SEPARATOR is \
-      # Delegate to Pathname nice the logic gets complex.
+      # Delegate to Pathname since the logic gets complex.
       def absolute_path?(path)
         Pathname.new(path).absolute?
       end
@@ -91,6 +91,7 @@ module Sprockets
     # Returns relative String path if subpath is a subpath of path, or nil if
     # subpath is outside of path.
     def split_subpath(path, subpath)
+      return "" if path == subpath
       path = File.join(path, '')
       if subpath.start_with?(path)
         subpath[path.length..-1]
@@ -123,6 +124,25 @@ module Sprockets
       File.basename(path).scan(/\.[^.]+/)
     end
 
+    # Internal: Match path extnames against available extensions.
+    #
+    # path       - String
+    # extensions - Hash of String extnames to values
+    #
+    # Returns [String extname, Object value] or nil nothing matched.
+    def match_path_extname(path, extensions)
+      match, key = nil, ""
+      path_extnames(path).reverse_each do |extname|
+        key.prepend(extname)
+        if value = extensions[key]
+          match = [key.dup, value]
+        elsif match
+          break
+        end
+      end
+      match
+    end
+
     # Internal: Returns all parents for path
     #
     # path - String absolute filename or directory

data/lib/sprockets/paths.rb

@@ -1,26 +1,41 @@
 require 'sprockets/path_utils'
+require 'sprockets/utils'
 
 module Sprockets
   module Paths
-    include PathUtils
+    include PathUtils, Utils
 
     # Returns `Environment` root.
     #
     # All relative paths are expanded with root as its base. To be
     # useful set this to your applications root directory. (`Rails.root`)
-    attr_reader :root
+    def root
+      config[:root]
+    end
+
+    # Internal: Change Environment root.
+    #
+    # Only the initializer should change the root.
+    def root=(path)
+      self.config = hash_reassoc(config, :root) do
+        File.expand_path(path)
+      end
+    end
+    private :root=
 
     # Returns an `Array` of path `String`s.
     #
     # These paths will be used for asset logical path lookups.
-    attr_reader :paths
+    def paths
+      config[:paths]
+    end
 
     # Prepend a `path` to the `paths` list.
     #
     # Paths at the end of the `Array` have the least priority.
     def prepend_path(path)
-      mutate_config(:paths) do |paths|
-        path = File.expand_path(path, root).dup.freeze
+      self.config = hash_reassoc(config, :paths) do |paths|
+        path = File.expand_path(path, root).freeze
         paths.unshift(path)
       end
     end
@@ -29,8 +44,8 @@ module Sprockets
     #
     # Paths at the beginning of the `Array` have a higher priority.
     def append_path(path)
-      mutate_config(:paths) do |paths|
-        path = File.expand_path(path, root).dup.freeze
+      self.config = hash_reassoc(config, :paths) do |paths|
+        path = File.expand_path(path, root).freeze
         paths.push(path)
       end
     end
@@ -41,7 +56,7 @@ module Sprockets
     # completely wipe the paths list and reappend them in the order
     # you want.
     def clear_paths
-      mutate_config(:paths) do |paths|
+      self.config = hash_reassoc(config, :paths) do |paths|
         paths.clear
       end
     end

data/lib/sprockets/processing.rb

@@ -1,41 +1,27 @@
 require 'sprockets/engines'
-require 'sprockets/lazy_processor'
 require 'sprockets/legacy_proc_processor'
 require 'sprockets/legacy_tilt_processor'
 require 'sprockets/mime'
+require 'sprockets/processor_utils'
+require 'sprockets/uri_utils'
 require 'sprockets/utils'
 
 module Sprockets
   # `Processing` is an internal mixin whose public methods are exposed on
   # the `Environment` and `CachedEnvironment` classes.
   module Processing
+    include ProcessorUtils, URIUtils, Utils
+
     # Preprocessors are ran before Postprocessors and Engine
     # processors.
-    attr_reader :preprocessors
-
-    # Internal: Find and load preprocessors by mime type.
-    #
-    # mime_type - String MIME type.
-    #
-    # Returns Array of Procs.
-    def unwrap_preprocessors(mime_type)
-      preprocessors[mime_type].map do |processor|
-        unwrap_processor(processor)
-      end
+    def preprocessors
+      config[:preprocessors]
     end
+    alias_method :processors, :preprocessors
 
     # Postprocessors are ran after Preprocessors and Engine processors.
-    attr_reader :postprocessors
-
-    # Internal: Find and load postprocessors by mime type.
-    #
-    # mime_type - String MIME type.
-    #
-    # Returns Array of Procs.
-    def unwrap_postprocessors(mime_type)
-      postprocessors[mime_type].map do |processor|
-        unwrap_processor(processor)
-      end
+    def postprocessors
+      config[:postprocessors]
     end
 
     # Registers a new Preprocessor `klass` for `mime_type`.
@@ -48,12 +34,10 @@ module Sprockets
     #       data.gsub(...)
     #     end
     #
-    def register_preprocessor(mime_type, klass, &block)
-      mutate_hash_config(:preprocessors, mime_type) do |processors|
-        processors.push(wrap_processor(klass, block))
-        processors
-      end
+    def register_preprocessor(*args, &block)
+      register_config_processor(:preprocessors, *args, &block)
     end
+    alias_method :register_processor, :register_preprocessor
 
     # Registers a new Postprocessor `klass` for `mime_type`.
     #
@@ -65,61 +49,31 @@ module Sprockets
     #       data.gsub(...)
     #     end
     #
-    def register_postprocessor(mime_type, klass, proc = nil, &block)
-      proc ||= block
-      mutate_hash_config(:postprocessors, mime_type) do |processors|
-        processors.push(wrap_processor(klass, proc))
-        processors
-      end
+    def register_postprocessor(*args, &block)
+      register_config_processor(:postprocessors, *args, &block)
     end
 
     # Remove Preprocessor `klass` for `mime_type`.
     #
     #     unregister_preprocessor 'text/css', Sprockets::DirectiveProcessor
     #
-    def unregister_preprocessor(mime_type, klass)
-      if klass.is_a?(String) || klass.is_a?(Symbol)
-        klass = preprocessors[mime_type].detect { |cls|
-          cls.respond_to?(:name) && cls.name == "Sprockets::LegacyProcProcessor (#{klass})"
-        }
-      end
-
-      mutate_hash_config(:preprocessors, mime_type) do |processors|
-        processors.delete(klass)
-        processors
-      end
+    def unregister_preprocessor(*args)
+      unregister_config_processor(:preprocessors, *args)
     end
+    alias_method :unregister_processor, :unregister_preprocessor
 
     # Remove Postprocessor `klass` for `mime_type`.
     #
     #     unregister_postprocessor 'text/css', Sprockets::DirectiveProcessor
     #
-    def unregister_postprocessor(mime_type, klass)
-      if klass.is_a?(String) || klass.is_a?(Symbol)
-        klass = postprocessors[mime_type].detect { |cls|
-          cls.respond_to?(:name) && cls.name == "Sprockets::LegacyProcProcessor (#{klass})"
-        }
-      end
-
-      mutate_hash_config(:postprocessors, mime_type) do |processors|
-        processors.delete(klass)
-        processors
-      end
+    def unregister_postprocessor(*args)
+      unregister_config_processor(:postprocessors, *args)
     end
 
     # Bundle Processors are ran on concatenated assets rather than
     # individual files.
-    attr_reader :bundle_processors
-
-    # Internal: Find and load bundle processors by mime type.
-    #
-    # mime_type - String MIME type.
-    #
-    # Returns Array of Procs.
-    def unwrap_bundle_processors(mime_type)
-      bundle_processors[mime_type].map do |processor|
-        unwrap_processor(processor)
-      end
+    def bundle_processors
+      config[:bundle_processors]
     end
 
     # Registers a new Bundle Processor `klass` for `mime_type`.
@@ -132,33 +86,23 @@ module Sprockets
     #       data.gsub(...)
     #     end
     #
-    def register_bundle_processor(mime_type, klass, &block)
-      mutate_hash_config(:bundle_processors, mime_type) do |processors|
-        processors.push(wrap_processor(klass, block))
-        processors
-      end
+    def register_bundle_processor(*args, &block)
+      register_config_processor(:bundle_processors, *args, &block)
     end
 
     # Remove Bundle Processor `klass` for `mime_type`.
     #
     #     unregister_bundle_processor 'application/javascript', Sprockets::DirectiveProcessor
     #
-    def unregister_bundle_processor(mime_type, klass)
-      if klass.is_a?(String) || klass.is_a?(Symbol)
-        klass = bundle_processors[mime_type].detect { |cls|
-          cls.respond_to?(:name) && cls.name == "Sprockets::LegacyProcProcessor (#{klass})"
-        }
-      end
-
-      mutate_hash_config(:bundle_processors, mime_type) do |processors|
-        processors.delete(klass)
-        processors
-      end
+    def unregister_bundle_processor(*args)
+      unregister_config_processor(:bundle_processors, *args)
     end
 
     # Internal: Two dimensional Hash of reducer functions for a given mime type
     # and asset metadata key.
-    attr_reader :bundle_reducers
+    def bundle_reducers
+      config[:bundle_reducers]
+    end
 
     # Public: Register bundle metadata reducer function.
     #
@@ -195,7 +139,7 @@ module Sprockets
         raise ArgumentError, "wrong number of arguments (#{args.size} for 0..2)"
       end
 
-      mutate_hash_config(:bundle_reducers, mime_type) do |reducers|
+      self.config = hash_reassoc(config, :bundle_reducers, mime_type) do |reducers|
         reducers.merge(key => [initial, reducer])
       end
     end
@@ -205,7 +149,7 @@ module Sprockets
     # mime_type - String MIME type
     #
     # Returns an Array of [initial, reducer_proc] pairs.
-    def unwrap_bundle_reducers(mime_type)
+    def load_bundle_reducers(mime_type)
       self.bundle_reducers['*/*'].merge(self.bundle_reducers[mime_type])
     end
 
@@ -231,10 +175,81 @@ module Sprockets
       end
     end
 
+    protected
+      def resolve_processors_cache_key_uri(uri)
+        params = parse_uri_query_params(uri[11..-1])
+        params[:engine_extnames] = params[:engines] ? params[:engines].split(',') : []
+        processors = processors_for(params[:type], params[:file_type], params[:engine_extnames], params[:skip_bundle])
+        processors_cache_keys(processors)
+      end
+
+      def build_processors_uri(type, file_type, engine_extnames, skip_bundle)
+        engines = engine_extnames.join(',') if engine_extnames.any?
+        query = encode_uri_query_params(
+          type: type,
+          file_type: file_type,
+          engines: engines,
+          skip_bundle: skip_bundle
+        )
+        "processors:#{query}"
+      end
+
+      def processors_for(type, file_type, engine_extnames, skip_bundle)
+        processors = []
+
+        bundled_processors = skip_bundle ? [] : config[:bundle_processors][type]
+
+        if bundled_processors.any?
+          processors.concat bundled_processors
+        else
+          processors.concat config[:postprocessors][type]
+
+          if type != file_type && processor = transformers[file_type][type]
+            processors << processor
+          end
+
+          processors.concat engine_extnames.map { |ext| engines[ext] }
+          processors.concat config[:preprocessors][file_type]
+        end
+
+        if processors.any? || mime_type_charset_detecter(type)
+          processors << FileReader
+        end
+
+        processors
+      end
+
     private
+      def register_config_processor(type, mime_type, klass, proc = nil, &block)
+        proc ||= block
+        processor = wrap_processor(klass, proc)
+
+        self.config = hash_reassoc(config, type, mime_type) do |processors|
+          processors.unshift(processor)
+          processors
+        end
+
+        compute_transformers!
+      end
+
+      def unregister_config_processor(type, mime_type, klass)
+        if klass.is_a?(String) || klass.is_a?(Symbol)
+          klass = config[type][mime_type].detect do |cls|
+            cls.respond_to?(:name) && cls.name == "Sprockets::LegacyProcProcessor (#{klass})"
+          end
+        end
+
+        self.config = hash_reassoc(config, type, mime_type) do |processors|
+          processors.delete(klass)
+          processors
+        end
+
+        compute_transformers!
+      end
+
       def wrap_processor(klass, proc)
         if !proc
-          if klass.class == Sprockets::LazyProcessor || klass.respond_to?(:call)
+          if klass.class == Sprockets::AutoloadProcessor || klass.respond_to?(:call)
             klass
           else
             LegacyTiltProcessor.new(klass)
@@ -245,9 +260,5 @@ module Sprockets
           proc
         end
       end
-
-      def unwrap_processor(processor)
-        processor.respond_to?(:unwrap) ? processor.unwrap : processor
-      end
   end
 end