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

data/lib/sprockets/legacy.rb

@@ -1,7 +1,73 @@
+require 'pathname'
+require 'sprockets/asset'
+require 'sprockets/base'
+require 'sprockets/cached_environment'
+require 'sprockets/context'
 require 'sprockets/manifest'
+require 'sprockets/resolve'
 
 module Sprockets
-  module Legacy
+  autoload :EcoTemplate, 'sprockets/eco_template'
+  autoload :EjsTemplate, 'sprockets/ejs_template'
+  autoload :ERBTemplate, 'sprockets/erb_template'
+  autoload :SassTemplate, 'sprockets/sass_template'
+  autoload :ScssTemplate, 'sprockets/sass_template'
+
+  # Deprecated
+  Index = CachedEnvironment
+
+  class Base
+    include Resolve
+
+    # Deprecated: Change default return type of resolve() to return 2.x
+    # compatible plain filename String. 4.x will always return an Asset URI
+    # and a set of file system dependencies that had to be read to compute the
+    # result.
+    #
+    #   2.x
+    #
+    #     resolve("foo.js")
+    #     # => "/path/to/app/javascripts/foo.js"
+    #
+    #   3.x
+    #
+    #     resolve("foo.js")
+    #     # => "/path/to/app/javascripts/foo.js"
+    #
+    #     resolve("foo.js", compat: true)
+    #     # => "/path/to/app/javascripts/foo.js"
+    #
+    #     resolve("foo.js", compat: false)
+    #     # => [
+    #     #   "file:///path/to/app/javascripts/foo.js?type=application/javascript"
+    #     #    #<Set: {"file-digest:/path/to/app/javascripts/foo.js"}>
+    #     # ]
+    #
+    #   4.x
+    #
+    #     resolve("foo.js")
+    #     # => [
+    #     #   "file:///path/to/app/javascripts/foo.js?type=application/javascript"
+    #     #    #<Set: {"file-digest:/path/to/app/javascripts/foo.js"}>
+    #     # ]
+    #
+    def resolve_with_compat(path, options = {})
+      options = options.dup
+      if options.delete(:compat) { true }
+        uri, _ = resolve_without_compat(path, options)
+        if uri
+          path, _ = parse_asset_uri(uri)
+          path
+        else
+          nil
+        end
+      else
+        resolve_without_compat(path, options)
+      end
+    end
+    alias_method :resolve_without_compat, :resolve
+    alias_method :resolve, :resolve_with_compat
+
     # Deprecated: Iterate over all logical paths with a matcher.
     #
     # Remove from 4.x.
@@ -54,11 +120,11 @@ module Sprockets
     end
 
     def cache_get(key)
-      cache._get(key)
+      cache.get(key)
     end
 
     def cache_set(key, value)
-      cache._set(key, value)
+      cache.set(key, value)
     end
 
     private
@@ -95,4 +161,147 @@ module Sprockets
         end
       end
   end
+
+  class Asset
+    # Deprecated: Use #filename instead.
+    #
+    # Returns Pathname.
+    def pathname
+      @pathname ||= Pathname.new(filename)
+    end
+
+    # Deprecated: Expand asset into an `Array` of parts.
+    #
+    # Appending all of an assets body parts together should give you
+    # the asset's contents as a whole.
+    #
+    # This allows you to link to individual files for debugging
+    # purposes.
+    #
+    # Use Asset#included instead. Keeping a full copy of the bundle's processed
+    # assets in memory (and in cache) is expensive and redundant. The common use
+    # case is to relink to the assets anyway.
+    #
+    # Returns Array of Assets.
+    def to_a
+      if metadata[:included]
+        metadata[:included].map { |uri| @environment.load(uri) }
+      else
+        [self]
+      end
+    end
+
+    # Deprecated: Get all required Assets.
+    #
+    # See Asset#to_a
+    #
+    # Returns Array of Assets.
+    def dependencies
+      to_a.reject { |a| a.filename.eql?(self.filename) }
+    end
+
+    # Deprecated: Returns Time of the last time the source was modified.
+    #
+    # Time resolution is normalized to the nearest second.
+    #
+    # Returns Time.
+    def mtime
+      Time.at(@mtime)
+    end
+  end
+
+  class Context
+    # Deprecated: Change default return type of resolve() to return 2.x
+    # compatible plain filename String. 4.x will always return an Asset URI.
+    #
+    #   2.x
+    #
+    #     resolve("foo.js")
+    #     # => "/path/to/app/javascripts/foo.js"
+    #
+    #   3.x
+    #
+    #     resolve("foo.js")
+    #     # => "/path/to/app/javascripts/foo.js"
+    #
+    #     resolve("foo.js", compat: true)
+    #     # => "/path/to/app/javascripts/foo.js"
+    #
+    #     resolve("foo.js", compat: false)
+    #     # => "file:///path/to/app/javascripts/foo.js?type=application/javascript"
+    #
+    #   4.x
+    #
+    #     resolve("foo.js")
+    #     # => "file:///path/to/app/javascripts/foo.js?type=application/javascript"
+    #
+    def resolve_with_compat(path, options = {})
+      options = options.dup
+
+      # Support old :content_type option, prefer :accept going forward
+      if type = options.delete(:content_type)
+        type = self.content_type if type == :self
+        options[:accept] ||= type
+      end
+
+      if options.delete(:compat) { true }
+        uri = resolve_without_compat(path, options)
+        path, _ = environment.parse_asset_uri(uri)
+        path
+      else
+        resolve_without_compat(path, options)
+      end
+    end
+    alias_method :resolve_without_compat, :resolve
+    alias_method :resolve, :resolve_with_compat
+  end
+
+  class Manifest
+    # 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.cached.logical_paths.select do |a, b|
+        filters.any? { |f| f.call(a, b) }
+      end
+    end
+
+    # Deprecated alias.
+    alias_method :find_logical_paths, :filter_logical_paths
+  end
 end

data/lib/sprockets/legacy_tilt_processor.rb

@@ -6,7 +6,7 @@ module Sprockets
   #
   # Will be removed in Sprockets 4.x.
   #
-  #     LegacyTiltProcessor.new(Tilt::CoffeeScriptTemplate)
+  #     LegacyTiltProcessor.new(Tilt::CoffeeScriptProcessor)
   #
   class LegacyTiltProcessor < Delegator
     def initialize(klass)

data/lib/sprockets/loader.rb

@@ -1,19 +1,22 @@
-require 'sprockets/asset_uri'
 require 'sprockets/asset'
 require 'sprockets/digest_utils'
 require 'sprockets/engines'
 require 'sprockets/errors'
+require 'sprockets/file_reader'
 require 'sprockets/mime'
 require 'sprockets/path_utils'
 require 'sprockets/processing'
+require 'sprockets/processor_utils'
 require 'sprockets/resolve'
 require 'sprockets/transformers'
+require 'sprockets/uri_utils'
 
 module Sprockets
   # The loader phase takes a asset URI location and returns a constructed Asset
   # object.
   module Loader
-    include DigestUtils, Engines, Mime, PathUtils, Processing, Resolve, Transformers
+    include DigestUtils, PathUtils, ProcessorUtils, URIUtils
+    include Engines, Mime, Processing, Resolve, Transformers
 
     # Public: Load Asset by AssetURI.
     #
@@ -21,23 +24,35 @@ module Sprockets
     #
     # Returns Asset.
     def load(uri)
-      _, params = AssetURI.parse(uri)
-      asset = params.key?(:id) ?
-        load_asset_by_id_uri(uri) :
-        load_asset_by_uri(uri)
+      filename, params = parse_asset_uri(uri)
+      if params.key?(:id)
+        asset = cache.fetch(['asset-uri', uri]) do
+          load_asset_by_id_uri(uri, filename, params)
+        end
+      else
+        asset = fetch_asset_from_dependency_cache(uri, filename) do |paths|
+          if paths
+            digest = digest(resolve_dependencies(paths))
+            if id_uri = cache.get(['asset-uri-digest', VERSION, uri, digest], true)
+              cache.get(['asset-uri', VERSION, id_uri], true)
+            end
+          else
+            load_asset_by_uri(uri, filename, params)
+          end
+        end
+      end
       Asset.new(self, asset)
     end
 
     private
-      def load_asset_by_id_uri(uri)
-        path, params = AssetURI.parse(uri)
-
+      def load_asset_by_id_uri(uri, filename, params)
         # Internal assertion, should be routed through load_asset_by_uri
         unless id = params.delete(:id)
           raise ArgumentError, "expected uri to have an id: #{uri}"
         end
 
-        asset = load_asset_by_uri(AssetURI.build(path, params))
+        uri = build_asset_uri(filename, params)
+        asset = load_asset_by_uri(uri, filename, params)
 
         if id && asset[:id] != id
           raise VersionNotFound, "could not find specified id: #{id}"
@@ -46,9 +61,7 @@ module Sprockets
         asset
       end
 
-      def load_asset_by_uri(uri)
-        filename, params = AssetURI.parse(uri)
-
+      def load_asset_by_uri(uri, filename, params)
         # Internal assertion, should be routed through load_asset_by_id_uri
         if params.key?(:id)
           raise ArgumentError, "expected uri to have no id: #{uri}"
@@ -58,8 +71,6 @@ module Sprockets
           raise FileNotFound, "could not find file: #{filename}"
         end
 
-
-        type = params[:type]
         load_path, logical_path = paths_split(self.paths, filename)
 
         unless load_path
@@ -68,99 +79,94 @@ module Sprockets
 
         logical_path, file_type, engine_extnames = parse_path_extnames(logical_path)
         logical_path = normalize_logical_path(logical_path)
+        name = logical_path
 
-        asset = {
-          uri: uri,
-          load_path: load_path,
-          filename: filename,
-          name: logical_path,
-          logical_path: logical_path
-        }
-
-        if type
-          asset[:content_type] = type
-          asset[:logical_path] += mime_types[type][:extensions].first
+        if type = params[:type]
+          logical_path += mime_types[type][:extensions].first
         end
 
-        if type != file_type
-          transformers = unwrap_transformer(file_type, type)
-          unless transformers.any?
-            raise ConversionError, "could not convert #{file_type.inspect} to #{type.inspect}"
-          end
-        else
-          transformers = []
+        if type != file_type && !transformers[file_type][type]
+          raise ConversionError, "could not convert #{file_type.inspect} to #{type.inspect}"
         end
 
-        processed_processors = unwrap_preprocessors(file_type) +
-          unwrap_engines(engine_extnames).reverse +
-          transformers +
-          unwrap_postprocessors(type)
-
-        bundled_processors = params[:skip_bundle] ? [] : unwrap_bundle_processors(type)
+        skip_bundle = params[:skip_bundle]
+        processors = processors_for(type, file_type, engine_extnames, skip_bundle)
 
-        processors = bundled_processors.any? ? bundled_processors : processed_processors
-        processors += unwrap_encoding_processors(params[:encoding])
+        processors_dep_uri = build_processors_uri(type, file_type, engine_extnames, skip_bundle)
+        dependencies = self.dependencies + [processors_dep_uri]
 
-        # Read into memory and process if theres a processor pipeline or the
-        # content type is text.
-        if processors.any? || mime_type_charset_detecter(type)
-          data = read_file(asset[:filename], asset[:content_type])
-          metadata = {}
-
-          input = {
+        # Read into memory and process if theres a processor pipeline
+        if processors.any?
+          result = call_processors(processors, {
             environment: self,
             cache: self.cache,
-            uri: asset[:uri],
-            filename: asset[:filename],
-            load_path: asset[:load_path],
-            name: asset[:name],
-            content_type: asset[:content_type],
-            metadata: metadata
-          }
-
-          processors.each do |processor|
-            begin
-              result = processor.call(input.merge(data: data, metadata: metadata))
-              case result
-              when NilClass
-                # noop
-              when Hash
-                data = result[:data] if result.key?(:data)
-                metadata = metadata.merge(result)
-                metadata.delete(:data)
-              when String
-                data = result
-              else
-                raise Error, "invalid processor return type: #{result.class}"
-              end
-            end
-          end
-
-          asset[:source] = data
-          asset[:metadata] = metadata.merge(
-            charset: data.encoding.name.downcase,
-            digest: digest(data),
-            length: data.bytesize
+            uri: uri,
+            filename: filename,
+            load_path: load_path,
+            name: name,
+            content_type: type,
+            metadata: { dependencies: dependencies }
+          })
+          source = result.delete(:data)
+          metadata = result.merge!(
+            charset: source.encoding.name.downcase,
+            digest: digest(source),
+            length: source.bytesize
           )
         else
-          asset[:metadata] = {
-            digest: file_digest(asset[:filename]),
-            length: self.stat(asset[:filename]).size
+          metadata = {
+            digest: file_digest(filename),
+            length: self.stat(filename).size,
+            dependencies: dependencies
           }
         end
 
-        metadata = asset[:metadata]
-        metadata[:dependency_paths] = Set.new(metadata[:dependency_paths]).merge([asset[:filename]])
-        metadata[:dependency_sources_digest] = files_digest(metadata[:dependency_paths])
-
-        asset[:integrity] = integrity_uri(asset[:metadata][:digest], asset[:content_type])
+        asset = {
+          uri: uri,
+          load_path: load_path,
+          filename: filename,
+          name: name,
+          logical_path: logical_path,
+          content_type: type,
+          source: source,
+          metadata: metadata,
+          integrity: integrity_uri(metadata[:digest], type),
+          dependencies_digest: digest(resolve_dependencies(metadata[:dependencies]))
+        }
 
         asset[:id]  = pack_hexdigest(digest(asset))
-        asset[:uri] = AssetURI.build(filename, params.merge(id: asset[:id]))
+        asset[:uri] = build_asset_uri(filename, params.merge(id: asset[:id]))
 
         # Deprecated: Avoid tracking Asset mtime
-        asset[:mtime] = metadata[:dependency_paths].map { |p| stat(p).mtime.to_i }.max
+        asset[:mtime] = metadata[:dependencies].map { |u|
+          if u.start_with?("file-digest:")
+            s = self.stat(parse_file_digest_uri(u))
+            s ? s.mtime.to_i : 0
+          else
+            0
+          end
+        }.max
+
+        cache.set(['asset-uri', VERSION, asset[:uri]], asset, true)
+        cache.set(['asset-uri-digest', VERSION, uri, asset[:dependencies_digest]], asset[:uri], true)
+
+        asset
+      end
+
+      def fetch_asset_from_dependency_cache(uri, filename, limit = 3)
+        key = ['asset-uri-cache-dependencies', VERSION, uri, file_digest(filename)]
+        history = cache.get(key) || []
+
+        history.each_with_index do |deps, index|
+          if asset = yield(deps)
+            cache.set(key, history.rotate!(index)) if index > 0
+            return asset
+          end
+        end
 
+        asset = yield
+        deps = asset[:metadata][:dependencies]
+        cache.set(key, history.unshift(deps).take(limit))
         asset
       end
   end