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

data/lib/sprockets/mime.rb

@@ -1,4 +1,5 @@
 require 'sprockets/encoding_utils'
+require 'sprockets/http_utils'
 
 module Sprockets
   module Mime
@@ -119,10 +120,6 @@ module Sprockets
     end
 
     private
-      def read_input(input)
-        read_file(input[:filename], input[:content_type])
-      end
-
       # Internal: Get a postprocessor to perform the encoding.
       #
       # encoding - String encoding.

data/lib/sprockets/path_digest_utils.rb

@@ -0,0 +1,47 @@
+require 'sprockets/digest_utils'
+require 'sprockets/path_utils'
+
+module Sprockets
+  # Internal: Crossover of path and digest utilities functions.
+  module PathDigestUtils
+    include DigestUtils, PathUtils
+
+    # Internal: Compute digest for file stat.
+    #
+    # path - String filename
+    # stat - File::Stat
+    #
+    # Returns String digest bytes.
+    def stat_digest(path, stat)
+      if stat.directory?
+        # If its a directive, digest the list of filenames
+        digest_class.digest(self.entries(path).join(','))
+      elsif stat.file?
+        # If its a file, digest the contents
+        digest_class.file(path.to_s).digest
+      else
+        raise TypeError, "stat was not a directory or file: #{stat.ftype}"
+      end
+    end
+
+    # Internal: Compute digest for path.
+    #
+    # path - String filename or directory path.
+    #
+    # Returns String digest bytes or nil.
+    def file_digest(path)
+      if stat = self.stat(path)
+        self.stat_digest(path, stat)
+      end
+    end
+
+    # Internal: Compute digest for a set of paths.
+    #
+    # paths - Array of filename or directory paths.
+    #
+    # Returns String digest bytes.
+    def files_digest(paths)
+      self.digest(paths.map { |path| self.file_digest(path) })
+    end
+  end
+end

data/lib/sprockets/path_utils.rb

@@ -195,6 +195,28 @@ module Sprockets
       nil
     end
 
+    # Internal: Recursive stat all the files under a directory in alphabetical
+    # order.
+    #
+    # dir - A String directory
+    #
+    # Returns an Enumerator of [path, stat].
+    def stat_sorted_tree(dir, &block)
+      return to_enum(__method__, dir) unless block_given?
+
+      self.stat_directory(dir).sort_by { |path, stat|
+        stat.directory? ? "#{path}/" : path
+      }.each do |path, stat|
+        yield path, stat
+
+        if stat.directory?
+          stat_sorted_tree(path, &block)
+        end
+      end
+
+      nil
+    end
+
     # Internal: Write to a file atomically. Useful for situations where you
     # don't want other processes or threads to see half-written files.
     #

data/lib/sprockets/paths.rb

@@ -1,5 +1,9 @@
+require 'sprockets/path_utils'
+
 module Sprockets
   module Paths
+    include PathUtils
+
     # Returns `Environment` root.
     #
     # All relative paths are expanded with root as its base. To be
@@ -41,5 +45,22 @@ module Sprockets
         paths.clear
       end
     end
+
+    # Public: Iterate over every file under all load paths.
+    #
+    # Returns Enumerator if no block is given.
+    def each_file
+      return to_enum(__method__) unless block_given?
+
+      paths.each do |root|
+        stat_tree(root).each do |filename, stat|
+          if stat.file?
+            yield filename
+          end
+        end
+      end
+
+      nil
+    end
   end
 end

data/lib/sprockets/processing.rb

@@ -156,61 +156,17 @@ module Sprockets
       end
     end
 
-    # Internal: Run processors on filename and data.
-    #
-    # Returns Hash.
-    def process(processors, uri, filename, load_path, name, content_type)
-      data, metadata = nil, {}
-
-      input = {
-        environment: self,
-        cache: cache,
-        uri: uri,
-        filename: filename,
-        load_path: load_path,
-        name: name,
-        content_type: 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
-
-      {
-        source: data,
-        charset: data.encoding.name.downcase,
-        length: data.bytesize,
-        digest: digest(data),
-        metadata: metadata
-      }
-    end
-
     # Internal: Two dimensional Hash of reducer functions for a given mime type
     # and asset metadata key.
     attr_reader :bundle_reducers
 
-    # Public: Register bundle reducer function.
+    # Public: Register bundle metadata reducer function.
     #
     # Examples
     #
-    #   Sprockets.register_bundle_reducer 'application/javascript', :jshint_errors, [], :+
+    #   Sprockets.register_bundle_metadata_reducer 'application/javascript', :jshint_errors, [], :+
     #
-    #   Sprockets.register_bundle_reducer 'text/css', :selector_count, 0 { |total, count|
+    #   Sprockets.register_bundle_metadata_reducer 'text/css', :selector_count, 0 { |total, count|
     #     total + count
     #   }
     #
@@ -220,7 +176,7 @@ module Sprockets
     # block     - Proc accepting the memo accumulator and current value
     #
     # Returns nothing.
-    def register_bundle_reducer(mime_type, key, *args, &block)
+    def register_bundle_metadata_reducer(mime_type, key, *args, &block)
       case args.size
       when 0
         reducer = block

data/lib/sprockets/resolve.rb

@@ -1,106 +1,57 @@
+require 'sprockets/asset_uri'
+
 module Sprockets
   module Resolve
-    # Public: Iterate over every file under all load paths.
-    #
-    # Returns Enumerator if no block is given.
-    def each_file
-      return to_enum(__method__) unless block_given?
-
-      paths.each do |root|
-        stat_tree(root).each do |filename, stat|
-          if stat.file?
-            yield filename
-          end
-        end
-      end
-
-      nil
-    end
-
-    # Finds the expanded real path for a given logical path by
-    # searching the environment's paths.
+    # Public: Finds the absolute path for a given logical path by searching the
+    # environment's load paths.
     #
     #     resolve("application.js")
-    #     # => "/path/to/app/javascripts/application.js.coffee"
+    #     # => "/path/to/app/javascripts/application.js"
+    #
+    # An accept content type can be given if the logical path doesn't have a
+    # format extension.
     #
-    # A `FileNotFound` exception is raised if the file does not exist.
+    #     resolve("application", accept: "application/javascript")
+    #     # => "/path/to/app/javascripts/application.js"
+    #
+    # The String path is returned or nil if no results are found.
     def resolve(path, options = {})
-      resolve_all(path, options) do |filename|
-        return filename
-      end
-
-      accept = options[:accept]
-      message = "couldn't find file '#{path}'"
-      message << " with type '#{accept}'" if accept
-      raise FileNotFound, message
-    end
+      logical_name, mime_type, _ = parse_path_extnames(path)
 
-    def resolve_in_load_path(load_path, logical_path, options = {})
-      if !self.paths.include?(load_path.to_s)
-        raise FileOutsidePaths, "#{load_path} isn't in paths: #{self.paths.join(', ')}"
-      end
+      paths = options[:load_paths] || self.paths
 
-      resolve_all_under_load_path(load_path, logical_path, options) do |filename|
-        return filename
+      if absolute_path?(path)
+        path = File.expand_path(path)
+        if paths_split(paths, path) && file?(path)
+          if accept = options[:accept]
+            find_best_q_match(accept, [path]) do |candidate, matcher|
+              match_mime_type?(mime_type || "application/octet-stream", matcher)
+            end
+          else
+            path
+          end
+        end
+      else
+        accepts = parse_accept_options(mime_type, options[:accept])
+        filename, _ = resolve_under_paths(paths, logical_name, mime_type, accepts)
+        filename
       end
-
-      accept = options[:accept]
-      message = "couldn't find file '#{logical_path}' under '#{load_path}'"
-      message << " with type '#{accept}'" if accept
-      raise FileNotFound, message
     end
 
-    def resolve_all_under_load_path(load_path, logical_path, options = {}, &block)
-      return to_enum(__method__, load_path, logical_path, options) unless block_given?
-
-      logical_name, mime_type, _ = parse_path_extnames(logical_path)
-      logical_basename = File.basename(logical_name)
-
-      accepts = parse_accept_options(mime_type, options[:accept])
-
-      _resolve_all_under_load_path(load_path, logical_name, logical_basename, accepts, &block)
-
-      nil
-    end
-
-    # Public: Finds the expanded real path for a given logical path by searching
-    # the environment's paths. Includes all matching paths including fallbacks
-    # and shadowed matches.
+    # Public: Find Asset URI for given a logical path by searching the
+    # environment's load paths.
     #
-    #     resolve_all("application.js").first
-    #     # => "/path/to/app/javascripts/application.js.coffee"
+    #     locate("application.js")
+    #     # => "file:///path/to/app/javascripts/application.js?content_type=application/javascript"
     #
-    # `resolve_all` returns an `Enumerator`. This allows you to filter your
-    # matches by any condition.
+    # An accept content type can be given if the logical path doesn't have a
+    # format extension.
     #
-    #     resolve_all("application").find do |path|
-    #       mime_type_for(path) == "text/css"
-    #     end
+    #     locate("application", accept: "application/javascript")
+    #     # => "file:///path/to/app/javascripts/application.coffee?content_type=application/javascript"
     #
-    def resolve_all(path, options = {}, &block)
-      return to_enum(__method__, path, options) unless block_given?
-      path = path.to_s
-
-      logical_name, mime_type, _ = parse_path_extnames(path)
-      logical_basename = File.basename(logical_name)
-
-      accepts = parse_accept_options(mime_type, options[:accept])
-
-      self.paths.each do |load_path|
-        _resolve_all_under_load_path(load_path, logical_name, logical_basename, accepts, &block)
-      end
-
-      nil
-    end
-
-    # Experimental: Get transform type for filename
-    def resolve_path_transform_type(filename, accept)
-      mime_type = parse_path_extnames(filename)[1]
-      resolve_transform_type(mime_type, accept)
-    end
-
-    # Experimental
-    def resolve_asset_uri(path, options = {})
+    # The String Asset URI is returned or nil if no results are found.
+    def locate(path, options = {})
       path = path.to_s
       accept = options[:accept]
       skip_bundle = options.key?(:bundle) ? !options[:bundle] : false
@@ -108,19 +59,29 @@ module Sprockets
       available_encodings = self.encodings.keys + ['identity']
       encoding = find_best_q_match(options[:accept_encoding], available_encodings)
 
+      paths = options[:load_paths] || self.paths
+
       if absolute_path?(path)
         path = File.expand_path(path)
-        if paths_split(self.paths, path) && file?(path) &&
-            (accept.nil? || resolve_path_transform_type(path, accept))
-          filename = path
-          type = resolve_path_transform_type(path, accept)
+        if paths_split(paths, path) && file?(path)
+          mime_type = parse_path_extnames(path)[1]
+          _type = resolve_transform_type(mime_type, accept)
+          if !accept || _type
+            filename = path
+            type = _type
+          end
         end
       else
-        if filename = resolve_all(path, accept: accept).first
-          mime_type = parse_path_extnames(path)[1]
-          accept = parse_accept_options(mime_type, accept).map { |t, v| "#{t}; q=#{v}" }.join(", ")
-          type = resolve_path_transform_type(filename, accept)
+        logical_name, mime_type, _ = parse_path_extnames(path)
+        parsed_accept = parse_accept_options(mime_type, accept)
+
+        if parsed_accept.empty?
+          return
         end
+
+        transformed_accepts = expand_transform_accepts(parsed_accept)
+        filename, mime_type = resolve_under_paths(paths, logical_name, mime_type, transformed_accepts)
+        type = resolve_transform_type(mime_type, parsed_accept) if filename
       end
 
       if filename
@@ -129,58 +90,21 @@ module Sprockets
       end
     end
 
-    # Public: 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
+    protected
+      def resolve_under_paths(paths, logical_name, mime_type, accepts)
+        logical_basename = File.basename(logical_name)
 
-          if !seen.include?(path)
-            yield path, filename
-            seen << path
+        paths.each do |load_path|
+          candidates = path_matches(load_path, logical_name, logical_basename)
+          candidate = find_best_q_match(accepts, candidates) do |c, matcher|
+            match_mime_type?(c[1] || "application/octet-stream", matcher)
           end
+          return candidate if candidate
         end
-      end
-
-      nil
-    end
-
-    # 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
+        nil
       end
 
-      nil
-    end
-
-    protected
       def parse_accept_options(mime_type, types)
         accepts = []
         accepts += parse_q_values(types) if types
@@ -206,52 +130,20 @@ module Sprockets
         path
       end
 
-      def _resolve_all_under_load_path(load_path, logical_name, logical_basename, accepts, &block)
-        filenames = path_matches(load_path, logical_name, logical_basename)
-
-        matches = []
-
-        # TODO: Cleanup double iteration of accept and filenames
-
-        # Exact mime type match first
-        matches += find_q_matches(accepts, filenames) do |filename, accepted|
-          if !file?(filename)
-            nil
-          elsif accepted == '*/*'
-            filename
-          elsif parse_path_extnames(filename)[1] == accepted
-            filename
-          end
-        end
-
-        # Then transformable match
-        matches += find_q_matches(accepts, filenames) do |filename, accepted|
-          if !file?(filename)
-            nil
-          elsif accepted == '*/*'
-            filename
-          elsif resolve_path_transform_type(filename, accepted)
-            filename
-          end
-        end
-
-        matches.uniq.each(&block)
-      end
-
       def path_matches(load_path, logical_name, logical_basename)
-        filenames = []
+        candidates = []
         dirname = File.dirname(File.join(load_path, logical_name))
-        dirname_matches(dirname, logical_basename) { |fn| filenames << fn }
-        resolve_alternates(load_path, logical_name) { |fn| filenames << fn }
-        dirname_matches(File.join(load_path, logical_name), "index") { |fn| filenames << fn }
-        filenames
+        dirname_matches(dirname, logical_basename) { |candidate| candidates << candidate }
+        resolve_alternates(load_path, logical_name) { |fn| candidates << [fn, parse_path_extnames(fn)[1]] }
+        dirname_matches(File.join(load_path, logical_name), "index") { |candidate| candidates << candidate }
+        candidates.select { |fn, _| file?(fn) }
       end
 
       def dirname_matches(dirname, basename)
         self.entries(dirname).each do |entry|
-          name = parse_path_extnames(entry)[0]
+          name, type, _ = parse_path_extnames(entry)
           if basename == name
-            yield File.join(dirname, entry)
+            yield [File.join(dirname, entry), type]
           end
         end
       end