sprockets 3.0.0.beta.8 → 3.0.0.beta.9

data/lib/sprockets/eco_processor.rb

@@ -1,5 +1,3 @@
-require 'eco'
-
 module Sprockets
   # Processor engine class for the Eco compiler. Depends on the `eco` gem.
   #
@@ -12,7 +10,7 @@ module Sprockets
     VERSION = '1'
 
     def self.cache_key
-      @cache_key ||= [name, ::Eco::Source::VERSION, VERSION].freeze
+      @cache_key ||= [name, Autoload::Eco::Source::VERSION, VERSION].freeze
     end
 
     # Compile template data with Eco compiler.
@@ -25,7 +23,7 @@ module Sprockets
     def self.call(input)
       data = input[:data]
       input[:cache].fetch(cache_key + [data]) do
-        ::Eco.compile(data)
+        Autoload::Eco.compile(data)
       end
     end
   end

data/lib/sprockets/ejs_processor.rb

@@ -1,5 +1,3 @@
-require 'ejs'
-
 module Sprockets
   # Processor engine class for the EJS compiler. Depends on the `ejs` gem.
   #
@@ -24,7 +22,7 @@ module Sprockets
     def self.call(input)
       data = input[:data]
       input[:cache].fetch(cache_key + [data]) do
-        ::EJS.compile(data)
+        Autoload::EJS.compile(data)
       end
     end
   end

data/lib/sprockets/engines.rb

@@ -53,7 +53,7 @@ module Sprockets
     def register_engine(ext, klass, options = {})
       ext = Sprockets::Utils.normalize_extension(ext)
 
-      if klass.class == Sprockets::AutoloadProcessor || klass.respond_to?(:call)
+      if klass.respond_to?(:call)
         processor = klass
         self.config = hash_reassoc(config, :engines) do |engines|
           engines.merge(ext => klass)

data/lib/sprockets/http_utils.rb

@@ -4,7 +4,7 @@ module Sprockets
   module HTTPUtils
     extend self
 
-    # Internal: Test mime type against mime range.
+    # Public: Test mime type against mime range.
     #
     #    match_mime_type?('text/html', 'text/*') => true
     #    match_mime_type?('text/plain', '*') => true
@@ -18,6 +18,22 @@ module Sprockets
       (m1 == '*' || v1 == m1) && (m2.nil? || m2 == '*' || m2 == v2)
     end
 
+    # Public: Return values from Hash where the key matches the mime type.
+    #
+    # hash      - Hash of String matcher keys to Object values
+    # mime_type - String mime type
+    #
+    # Returns Array of Object values.
+    def match_mime_type_keys(hash, mime_type)
+      type, subtype = mime_type.split('/', 2)
+      [
+        hash["*"],
+        hash["*/*"],
+        hash["#{type}/*"],
+        hash["#{type}/#{subtype}"]
+      ].compact
+    end
+
     # Internal: Parse Accept header quality values.
     #
     # Adapted from Rack::Utils#q_values.

data/lib/sprockets/legacy.rb

@@ -7,6 +7,7 @@ require 'sprockets/manifest'
 require 'sprockets/resolve'
 
 module Sprockets
+  autoload :CoffeeScriptTemplate, 'sprockets/coffee_script_template'
   autoload :EcoTemplate, 'sprockets/eco_template'
   autoload :EjsTemplate, 'sprockets/ejs_template'
   autoload :ERBTemplate, 'sprockets/erb_template'
@@ -100,12 +101,12 @@ module Sprockets
 
       seen = Set.new
 
-      self.paths.each do |load_path|
+      paths.each do |load_path|
         stat_tree(load_path).each do |filename, stat|
           next unless stat.file?
 
           path = split_subpath(load_path, filename)
-          path, mime_type, _ = parse_path_extnames(path)
+          path, mime_type, _, _ = parse_path_extnames(path)
           path = normalize_logical_path(path)
           path += mime_types[mime_type][:extensions].first if mime_type
 

data/lib/sprockets/loader.rb

@@ -71,29 +71,32 @@ module Sprockets
           raise FileNotFound, "could not find file: #{filename}"
         end
 
-        load_path, logical_path = paths_split(self.paths, filename)
+        load_path, logical_path = paths_split(config[:paths], filename)
 
         unless load_path
           raise FileOutsidePaths, "#{filename} is no longer under a load path: #{self.paths.join(', ')}"
         end
 
-        logical_path, file_type, engine_extnames = parse_path_extnames(logical_path)
+        logical_path, file_type, engine_extnames, _ = parse_path_extnames(logical_path)
         logical_path = normalize_logical_path(logical_path)
         name = logical_path
 
+        if pipeline = params[:pipeline]
+          logical_path += ".#{pipeline}"
+        end
+
         if type = params[:type]
-          logical_path += mime_types[type][:extensions].first
+          logical_path += config[:mime_types][type][:extensions].first
         end
 
-        if type != file_type && !transformers[file_type][type]
+        if type != file_type && !config[:transformers][file_type][type]
           raise ConversionError, "could not convert #{file_type.inspect} to #{type.inspect}"
         end
 
-        skip_bundle = params[:skip_bundle]
-        processors = processors_for(type, file_type, engine_extnames, skip_bundle)
+        processors = processors_for(type, file_type, engine_extnames, pipeline)
 
-        processors_dep_uri = build_processors_uri(type, file_type, engine_extnames, skip_bundle)
-        dependencies = self.dependencies + [processors_dep_uri]
+        processors_dep_uri = build_processors_uri(type, file_type, engine_extnames, pipeline)
+        dependencies = config[:dependencies] + [processors_dep_uri]
 
         # Read into memory and process if theres a processor pipeline
         if processors.any?

data/lib/sprockets/manifest.rb

@@ -1,6 +1,6 @@
 require 'json'
-require 'securerandom'
 require 'time'
+require 'sprockets/manifest_utils'
 
 module Sprockets
   # The Manifest logs the contents of assets compiled to a single directory. It
@@ -13,13 +13,15 @@ module Sprockets
   # that don't have sprockets loaded. See `#assets` and `#files` for more
   # infomation about the structure.
   class Manifest
+    include ManifestUtils
+
     attr_reader :environment
 
     # Create new Manifest associated with an `environment`. `filename` is a full
     # path to the manifest json file. The file may or may not already exist. The
     # dirname of the `filename` will be used to write compiled assets to.
     # Otherwise, if the path is a directory, the filename will default a random
-    # "manifest-123.json" file in that directory.
+    # ".sprockets-manifest-*.json" file in that directory.
     #
     #   Manifest.new(environment, "./public/assets/manifest.json")
     #
@@ -30,6 +32,9 @@ module Sprockets
 
       @directory, @filename = args[0], args[1]
 
+      # Whether the manifest file is using the old manifest-*.json naming convention
+      @legacy_manifest = false
+
       # Expand paths
       @directory = File.expand_path(@directory) if @directory
       @filename  = File.expand_path(@filename) if @filename
@@ -42,14 +47,14 @@ module Sprockets
       # Default dir to the directory of the filename
       @directory ||= File.dirname(@filename) if @filename
 
-      # If directory is given w/o filename, pick a random manifest.json location
+      # If directory is given w/o filename, pick a random manifest location
+      @rename_filename = nil
       if @directory && @filename.nil?
-        # Find the first manifest.json in the directory
-        filenames = Dir[File.join(@directory, "manifest*.json")]
-        if filenames.any?
-          @filename = filenames.first
-        else
-          @filename = File.join(@directory, "manifest-#{SecureRandom.hex(16)}.json")
+        @filename = find_directory_manifest(@directory)
+
+        # If legacy manifest name autodetected, mark to rename on save
+        if File.basename(@filename).start_with?("manifest")
+          @rename_filename = File.join(@directory, generate_manifest_path)
         end
       end
 
@@ -232,15 +237,20 @@ module Sprockets
       nil
     end
 
-    protected
-      # Persist manfiest back to FS
-      def save
-        data = json_encode(@data)
-        FileUtils.mkdir_p File.dirname(filename)
-        PathUtils.atomic_write(filename) do |f|
-          f.write(data)
-        end
+    # Persist manfiest back to FS
+    def save
+      if @rename_filename
+        FileUtils.mv(@filename, @rename_filename)
+        @filename = @rename_filename
+        @rename_filename = nil
+      end
+
+      data = json_encode(@data)
+      FileUtils.mkdir_p File.dirname(@filename)
+      PathUtils.atomic_write(@filename) do |f|
+        f.write(data)
       end
+    end
 
     private
       def json_decode(obj)

data/lib/sprockets/manifest_utils.rb

@@ -0,0 +1,45 @@
+require 'securerandom'
+
+module Sprockets
+  # Public: Manifest utilities.
+  module ManifestUtils
+    extend self
+
+    MANIFEST_RE = /^\.sprockets-manifest-[0-9a-f]{32}.json$/
+    LEGACY_MANIFEST_RE = /^manifest(-[0-9a-f]{32})?.json$/
+
+    # Public: Generate a new random manifest path.
+    #
+    # Manifests are not intended to be accessed publicly, but typically live
+    # alongside public assets for convenience. To avoid being served, the
+    # filename is prefixed with a "." which is usually hidden by web servers
+    # like Apache. To help in other environments that may not control this,
+    # a random hex string is appended to the filename to prevent people from
+    # guessing the location. If directory indexes are enabled on the server,
+    # all bets are off.
+    #
+    # Return String path.
+    def generate_manifest_path
+      ".sprockets-manifest-#{SecureRandom.hex(16)}.json"
+    end
+
+    # Public: Find or pick a new manifest filename for target build directory.
+    #
+    # dirname - String dirname
+    #
+    # Examples
+    #
+    #     find_directory_manifest("/app/public/assets")
+    #     # => "/app/public/assets/.sprockets-manifest-abc123.json"
+    #
+    # Returns String filename.
+    def find_directory_manifest(dirname)
+      entries = File.directory?(dirname) ? Dir.entries(dirname) : []
+      entry = entries.find { |e| e =~ MANIFEST_RE } ||
+        # Deprecated: Will be removed in 4.x
+        entries.find { |e| e =~ LEGACY_MANIFEST_RE } ||
+        generate_manifest_path
+      File.join(dirname, entry)
+    end
+  end
+end

data/lib/sprockets/mime.rb

@@ -81,7 +81,7 @@ module Sprockets
     #
     # Returns Proc detector or nil if none is available.
     def mime_type_charset_detecter(mime_type)
-      if type = mime_types[mime_type]
+      if type = config[:mime_types][mime_type]
         if detect = type[:charset]
           return detect
         end
@@ -109,12 +109,15 @@ module Sprockets
       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}
+        ([nil] + pipelines.keys.map(&:to_s)).each do |pipeline|
+          pipeline_extname = ".#{pipeline}" if pipeline
+          ([[nil, nil]] + config[:mime_exts].to_a).each do |format_extname, format_type|
+            3.times do |n|
+              config[:engines].keys.permutation(n).each do |engine_extnames|
+                key = "#{pipeline_extname}#{format_extname}#{engine_extnames.join}"
+                type = format_type || config[:engine_mime_types][engine_extnames.first]
+                graph[key] = {type: type, engines: engine_extnames, pipeline: pipeline}
+              end
             end
           end
         end

data/lib/sprockets/paths.rb

@@ -35,7 +35,7 @@ module Sprockets
     # Paths at the end of the `Array` have the least priority.
     def prepend_path(path)
       self.config = hash_reassoc(config, :paths) do |paths|
-        path = File.expand_path(path, root).freeze
+        path = File.expand_path(path, config[:root]).freeze
         paths.unshift(path)
       end
     end
@@ -45,7 +45,7 @@ module Sprockets
     # Paths at the beginning of the `Array` have a higher priority.
     def append_path(path)
       self.config = hash_reassoc(config, :paths) do |paths|
-        path = File.expand_path(path, root).freeze
+        path = File.expand_path(path, config[:root]).freeze
         paths.push(path)
       end
     end

data/lib/sprockets/processing.rb

@@ -12,6 +12,18 @@ module Sprockets
   module Processing
     include ProcessorUtils, URIUtils, Utils
 
+    def pipelines
+      config[:pipelines]
+    end
+
+    def register_pipeline(name, proc = nil, &block)
+      proc ||= block
+
+      self.config = hash_reassoc(config, :pipelines) do |pipelines|
+        pipelines.merge(name.to_sym => proc)
+      end
+    end
+
     # Preprocessors are ran before Postprocessors and Engine
     # processors.
     def preprocessors
@@ -98,12 +110,6 @@ module Sprockets
       unregister_config_processor(:bundle_processors, *args)
     end
 
-    # Internal: Two dimensional Hash of reducer functions for a given mime type
-    # and asset metadata key.
-    def bundle_reducers
-      config[:bundle_reducers]
-    end
-
     # Public: Register bundle metadata reducer function.
     #
     # Examples
@@ -144,74 +150,51 @@ module Sprockets
       end
     end
 
-    # Internal: Gather all bundle reducer functions for MIME type.
-    #
-    # mime_type - String MIME type
-    #
-    # Returns an Array of [initial, reducer_proc] pairs.
-    def load_bundle_reducers(mime_type)
-      self.bundle_reducers['*/*'].merge(self.bundle_reducers[mime_type])
-    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 process_bundle_reducers(assets, reducers)
-      initial = {}
-      reducers.each do |k, (v, _)|
-        initial[k] = v if v
-      end
-
-      assets.reduce(initial) do |h, asset|
-        reducers.each do |k, (_, block)|
-          value = k == :data ? asset.source : asset.metadata[k]
-          h[k]  = h.key?(k) ? block.call(h[k], value) : value
-        end
-        h
-      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 = processors_for(params[:type], params[:file_type], params[:engine_extnames], params[:pipeline])
         processors_cache_keys(processors)
       end
 
-      def build_processors_uri(type, file_type, engine_extnames, skip_bundle)
+      def build_processors_uri(type, file_type, engine_extnames, pipeline)
         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
+          pipeline: pipeline
         )
         "processors:#{query}"
       end
 
-      def processors_for(type, file_type, engine_extnames, skip_bundle)
-        processors = []
-
-        bundled_processors = skip_bundle ? [] : config[:bundle_processors][type]
+      def processors_for(type, file_type, engine_extnames, pipeline)
+        pipeline ||= :default
+        config[:pipelines][pipeline.to_sym].call(self, type, file_type, engine_extnames)
+      end
 
+      def default_processors_for(type, file_type, engine_extnames)
+        bundled_processors = config[:bundle_processors][type]
         if bundled_processors.any?
-          processors.concat bundled_processors
+          bundled_processors
         else
-          processors.concat config[:postprocessors][type]
+          self_processors_for(type, file_type, engine_extnames)
+        end
+      end
 
-          if type != file_type && processor = transformers[file_type][type]
-            processors << processor
-          end
+      def self_processors_for(type, file_type, engine_extnames)
+        processors = []
+
+        processors.concat config[:postprocessors][type]
 
-          processors.concat engine_extnames.map { |ext| engines[ext] }
-          processors.concat config[:preprocessors][file_type]
+        if type != file_type && processor = config[:transformers][file_type][type]
+          processors << processor
         end
 
+        processors.concat engine_extnames.map { |ext| engines[ext] }
+        processors.concat config[:preprocessors][file_type]
+
         if processors.any? || mime_type_charset_detecter(type)
           processors << FileReader
         end
@@ -249,7 +232,7 @@ module Sprockets
 
       def wrap_processor(klass, proc)
         if !proc
-          if klass.class == Sprockets::AutoloadProcessor || klass.respond_to?(:call)
+          if klass.respond_to?(:call)
             klass
           else
             LegacyTiltProcessor.new(klass)