sprockets 3.0.0.beta.3 → 3.0.0.beta.4

data/lib/sprockets/configuration.rb

@@ -10,23 +10,24 @@ module Sprockets
     include Paths, Mime, Engines, Transformers, Processing, Compressing
 
     def initialize_configuration(parent)
-      @logger            = parent.logger
-      @version           = parent.version
-      @digest_class      = parent.digest_class
-      @context_class     = Class.new(parent.context_class)
-      @root              = parent.root
-      @paths             = parent.paths
-      @mime_types        = parent.mime_types
-      @mime_exts         = parent.mime_exts
-      @encodings         = parent.encodings
-      @engines           = parent.engines
-      @engine_mime_types = parent.engine_mime_types
-      @transformers      = parent.transformers
-      @preprocessors     = parent.preprocessors
-      @postprocessors    = parent.postprocessors
-      @bundle_reducers   = parent.bundle_reducers
-      @bundle_processors = parent.bundle_processors
-      @compressors       = parent.compressors
+      @logger                = parent.logger
+      @version               = parent.version
+      @digest_class          = parent.digest_class
+      @context_class         = Class.new(parent.context_class)
+      @root                  = parent.root
+      @paths                 = parent.paths
+      @mime_types            = parent.mime_types
+      @mime_exts             = parent.mime_exts
+      @encodings             = parent.encodings
+      @engines               = parent.engines
+      @engine_mime_types     = parent.engine_mime_types
+      @transformers          = parent.transformers
+      @inverted_transformers = parent.inverted_transformers
+      @preprocessors         = parent.preprocessors
+      @postprocessors        = parent.postprocessors
+      @bundle_reducers       = parent.bundle_reducers
+      @bundle_processors     = parent.bundle_processors
+      @compressors           = parent.compressors
     end
 
     # Get and set `Logger` instance.
@@ -52,7 +53,7 @@ module Sprockets
       mutate_config(:version) { version.dup }
     end
 
-    # Deprecated: Returns a `Digest` implementation class.
+    # Public: Returns a `Digest` implementation class.
     #
     # Defaults to `Digest::SHA256`.
     attr_reader :digest_class

data/lib/sprockets/context.rb

@@ -66,6 +66,39 @@ module Sprockets
     #
     attr_reader :content_type
 
+    # Internal
+    def _resolve(method, path, options = {})
+      options[:content_type] = self.content_type if options[:content_type] == :self
+      options[:accept] = options.delete(:content_type)
+
+      if environment.absolute_path?(path)
+        filename = path
+      elsif environment.relative_path?(path)
+        path = File.expand_path(path, @dirname)
+        if logical_path = @environment.split_subpath(load_path, path)
+          if filename = environment.send(method, logical_path, options.merge(load_paths: [load_path]))
+            accept = options[:accept]
+            message = "couldn't find file '#{logical_path}' under '#{load_path}'"
+            message << " with type '#{accept}'" if accept
+            raise FileNotFound, message
+          end
+        else
+          raise FileOutsidePaths, "#{path} isn't under path: #{load_path}"
+        end
+      else
+        filename = environment.send(method, path, options)
+      end
+
+      if filename
+        filename
+      else
+        accept = options[:accept]
+        message = "couldn't find file '#{path}'"
+        message << " with type '#{accept}'" if accept
+        raise FileNotFound, message
+      end
+    end
+
     # Given a logical path, `resolve` will find and return the fully
     # expanded path. Relative paths will also be resolved. An optional
     # `:content_type` restriction can be supplied to restrict the
@@ -78,21 +111,11 @@ module Sprockets
     #     # => "/path/to/app/javascripts/bar.js"
     #
     def resolve(path, options = {})
-      options[:content_type] = self.content_type if options[:content_type] == :self
-      options[:accept] = options.delete(:content_type)
+      _resolve(:resolve, path, options)
+    end
 
-      if environment.absolute_path?(path)
-        path
-      elsif environment.relative_path?(path)
-        path = File.expand_path(path, @dirname)
-        if logical_path = @environment.split_subpath(load_path, path)
-          environment.resolve_in_load_path(load_path, logical_path, options)
-        else
-          raise FileOutsidePaths, "#{path} isn't under path: #{load_path}"
-        end
-      else
-        environment.resolve(path, options)
-      end
+    def locate(path, options = {})
+      _resolve(:locate, path, options)
     end
 
     # `depend_on` allows you to state a dependency on a file without
@@ -114,7 +137,7 @@ module Sprockets
     # file. Unlike `depend_on`, this will include recursively include
     # the target asset's dependencies.
     def depend_on_asset(path)
-      if asset = @environment.find_asset(resolve(path))
+      if asset = @environment.load(locate(path))
         @dependency_paths.merge(asset.metadata[:dependency_paths])
       end
       nil
@@ -130,8 +153,7 @@ module Sprockets
     #     <%= require_asset "#{framework}.js" %>
     #
     def require_asset(path)
-      filename = resolve(path, accept: @content_type)
-      @required << @environment.resolve_asset_uri(filename, accept: @content_type, bundle: false)
+      @required << locate(path, accept: @content_type, bundle: false)
       nil
     end
 
@@ -139,8 +161,7 @@ module Sprockets
     # `path` must be an asset which may or may not already be included
     # in the bundle.
     def stub_asset(path)
-      filename = resolve(path, accept: @content_type)
-      @stubbed << @environment.resolve_asset_uri(filename, accept: @content_type, bundle: false)
+      @stubbed << @environment.locate(path, accept: @content_type, bundle: false)
       nil
     end
 
@@ -150,7 +171,7 @@ module Sprockets
     #
     # Returns an Asset or nil.
     def link_asset(path)
-      if asset = @environment.find_asset(resolve(path))
+      if asset = @environment.load(locate(path))
         @dependency_paths.merge(asset.metadata[:dependency_paths])
         @links << asset.uri
       end

data/lib/sprockets/directive_processor.rb

@@ -196,7 +196,7 @@ module Sprockets
       #     //= require "./bar"
       #
       def process_require_directive(path)
-        @required << resolve_uri(path)
+        @required << locate(path, accept: @content_type, bundle: false)
       end
 
       # `require_self` causes the body of the current file to be inserted
@@ -235,8 +235,10 @@ module Sprockets
           @environment.stat_directory(root).each do |subpath, stat|
             if subpath == @filename
               next
-            elsif @environment.resolve_path_transform_type(subpath, @content_type)
-              @required << @environment.resolve_asset_uri(subpath, accept: @content_type, bundle: false)
+            elsif stat.directory?
+              next
+            elsif uri = @environment.locate(subpath, accept: @content_type, bundle: false)
+              @required << uri
             end
           end
         else
@@ -260,19 +262,15 @@ module Sprockets
 
           @dependency_paths << root
 
-          required = []
-          @environment.stat_tree(root).each do |subpath, stat|
+          @environment.stat_sorted_tree(root).each do |subpath, stat|
             if subpath == @filename
               next
             elsif stat.directory?
               @dependency_paths << subpath
-            elsif @environment.resolve_path_transform_type(subpath, @content_type)
-              required << subpath
+            elsif uri = @environment.locate(subpath, accept: @content_type, bundle: false)
+              @required << uri
             end
           end
-          required.sort_by(&:to_s).each do |subpath|
-            @required << @environment.resolve_asset_uri(subpath, accept: @content_type, bundle: false)
-          end
         else
           # The path must be relative and start with a `./`.
           raise ArgumentError, "require_tree argument must be a relative path"
@@ -292,7 +290,7 @@ module Sprockets
       #     //= depend_on "foo.png"
       #
       def process_depend_on_directive(path)
-        @dependency_paths << resolve(path, accept: "#{@content_type}, */*")
+        @dependency_paths << resolve(path)
       end
 
       # Allows you to state a dependency on an asset without including
@@ -307,7 +305,7 @@ module Sprockets
       #     //= depend_on_asset "bar.js"
       #
       def process_depend_on_asset_directive(path)
-        if asset = @environment.find_asset(resolve(path, accept: "#{@content_type}, */*"))
+        if asset = @environment.load(locate(path))
           @dependency_paths.merge(asset.metadata[:dependency_paths])
         end
       end
@@ -321,7 +319,7 @@ module Sprockets
       #     //= stub "jquery"
       #
       def process_stub_directive(path)
-        @stubbed << resolve_uri(path)
+        @stubbed << locate(path, accept: @content_type, bundle: false)
       end
 
       # Declares a linked dependency on the target asset.
@@ -333,7 +331,7 @@ module Sprockets
       #   /*= link "logo.png" */
       #
       def process_link_directive(path)
-        if asset = @environment.find_asset(resolve(path, accept: "#{@content_type}, */*"))
+        if asset = @environment.load(locate(path))
           @dependency_paths.merge(asset.metadata[:dependency_paths])
           @links << asset.uri
         end
@@ -344,23 +342,42 @@ module Sprockets
         File.expand_path(path, @dirname)
       end
 
-      def resolve_uri(path)
-        filename = resolve(path, accept: @content_type)
-        @environment.resolve_asset_uri(filename, accept: @content_type, bundle: false)
+      def locate(path, options = {})
+        _resolve(:locate, path, options)
       end
 
       def resolve(path, options = {})
+        _resolve(:resolve, path, options)
+      end
+
+      def _resolve(method, path, options = {})
         if @environment.absolute_path?(path)
           raise FileOutsidePaths, "can't require absolute file: #{path}"
         elsif @environment.relative_path?(path)
           path = expand_relative_path(path)
           if logical_path = @environment.split_subpath(@load_path, path)
-            @environment.resolve_in_load_path(@load_path, logical_path, options)
+            if filename = @environment.send(method, logical_path, options.merge(load_paths: [@load_path]))
+              filename
+            else
+              accept = options[:accept]
+              message = "couldn't find file '#{logical_path}' under '#{@load_path}'"
+              message << " with type '#{accept}'" if accept
+              raise FileNotFound, message
+            end
           else
             raise FileOutsidePaths, "#{path} isn't under path: #{@load_path}"
           end
         else
-          @environment.resolve(path, options)
+          filename = @environment.send(method, path, options)
+        end
+
+        if filename
+          filename
+        else
+          accept = options[:accept]
+          message = "couldn't find file '#{path}'"
+          message << " with type '#{accept}'" if accept
+          raise FileNotFound, message
         end
       end
   end

data/lib/sprockets/environment.rb

@@ -1,4 +1,5 @@
 require 'sprockets/base'
+require 'sprockets/cache/memory_store'
 require 'sprockets/cached_environment'
 
 module Sprockets

data/lib/sprockets/legacy.rb

@@ -1,5 +1,58 @@
+require 'sprockets/manifest'
+
 module Sprockets
   module Legacy
+    # Deprecated: Iterate over all logical paths with a matcher.
+    #
+    # Remove from 4.x.
+    #
+    # args - List of matcher objects.
+    #
+    # Returns Enumerator if no block is given.
+    def each_logical_path(*args, &block)
+      return to_enum(__method__, *args) unless block_given?
+
+      filters = args.flatten.map { |arg| Manifest.compile_match_filter(arg) }
+      logical_paths.each do |a, b|
+        if filters.any? { |f| f.call(a, b) }
+          if block.arity == 2
+            yield a, b
+          else
+            yield a
+          end
+        end
+      end
+
+      nil
+    end
+
+    # Deprecated: Enumerate over all logical paths in the environment.
+    #
+    # Returns an Enumerator of [logical_path, filename].
+    def logical_paths
+      return to_enum(__method__) unless block_given?
+
+      seen = Set.new
+
+      self.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 = normalize_logical_path(path)
+          path += mime_types[mime_type][:extensions].first if mime_type
+
+          if !seen.include?(path)
+            yield path, filename
+            seen << path
+          end
+        end
+      end
+
+      nil
+    end
+
     private
       # Deprecated: Seriously.
       def matches_filter(filters, logical_path, filename)
@@ -19,5 +72,19 @@ module Sprockets
           end
         end
       end
+
+      # URI.unescape is deprecated on 1.9. We need to use URI::Parser
+      # if its available.
+      if defined? URI::DEFAULT_PARSER
+        def unescape(str)
+          str = URI::DEFAULT_PARSER.unescape(str)
+          str.force_encoding(Encoding.default_internal) if Encoding.default_internal
+          str
+        end
+      else
+        def unescape(str)
+          URI.unescape(str)
+        end
+      end
   end
 end

data/lib/sprockets/loader.rb

@@ -0,0 +1,168 @@
+require 'sprockets/asset_uri'
+require 'sprockets/asset'
+require 'sprockets/digest_utils'
+require 'sprockets/engines'
+require 'sprockets/errors'
+require 'sprockets/mime'
+require 'sprockets/path_utils'
+require 'sprockets/processing'
+require 'sprockets/resolve'
+require 'sprockets/transformers'
+
+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
+
+    # Public: Load Asset by AssetURI.
+    #
+    # uri - AssetURI
+    #
+    # Returns Asset.
+    def load(uri)
+      _, params = AssetURI.parse(uri)
+      asset = params.key?(:id) ?
+        load_asset_by_id_uri(uri) :
+        load_asset_by_uri(uri)
+      Asset.new(self, asset)
+    end
+
+    private
+      def load_asset_by_id_uri(uri)
+        path, params = AssetURI.parse(uri)
+
+        # 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))
+
+        if id && asset[:id] != id
+          raise VersionNotFound, "could not find specified id: #{id}"
+        end
+
+        asset
+      end
+
+      def load_asset_by_uri(uri)
+        filename, params = AssetURI.parse(uri)
+
+        # Internal assertion, should be routed through load_asset_by_id_uri
+        if params.key?(:id)
+          raise ArgumentError, "expected uri to have no id: #{uri}"
+        end
+
+        unless file?(filename)
+          raise FileNotFound, "could not find file: #{filename}"
+        end
+
+
+        type = params[:type]
+        load_path, logical_path = paths_split(self.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 = normalize_logical_path(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
+        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 = []
+        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)
+
+        processors = bundled_processors.any? ? bundled_processors : processed_processors
+        processors += unwrap_encoding_processors(params[:encoding])
+
+        # 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 = {
+            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
+          )
+        else
+          asset[:metadata] = {
+            encoding: Encoding::BINARY,
+            digest: file_digest(asset[:filename]),
+            length: self.stat(asset[:filename]).size
+          }
+        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[:id]  = pack_hexdigest(digest(asset))
+        asset[:uri] = AssetURI.build(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
+      end
+  end
+end