sprockets 2.3.2 → 3.0.0

data/lib/sprockets/loader.rb

@@ -0,0 +1,176 @@
+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, PathUtils, ProcessorUtils, URIUtils
+    include Engines, Mime, Processing, Resolve, Transformers
+
+    # Public: Load Asset by AssetURI.
+    #
+    # uri - AssetURI
+    #
+    # Returns Asset.
+    def load(uri)
+      filename, params = parse_asset_uri(uri)
+      if params.key?(:id)
+        asset = cache.fetch("asset-uri:#{VERSION}#{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, 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
+
+        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: #{uri}##{id}"
+        end
+
+        asset
+      end
+
+      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}"
+        end
+
+        unless file?(filename)
+          raise FileNotFound, "could not find file: #{filename}"
+        end
+
+        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 = normalize_logical_path(logical_path)
+        name = logical_path
+
+        if pipeline = params[:pipeline]
+          logical_path += ".#{pipeline}"
+        end
+
+        if type = params[:type]
+          logical_path += config[:mime_types][type][:extensions].first
+        end
+
+        if type != file_type && !config[:transformers][file_type][type]
+          raise ConversionError, "could not convert #{file_type.inspect} to #{type.inspect}"
+        end
+
+        processors = processors_for(type, file_type, engine_extnames, pipeline)
+
+        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?
+          result = call_processors(processors, {
+            environment: self,
+            cache: self.cache,
+            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
+          metadata = {
+            digest: file_digest(filename),
+            length: self.stat(filename).size,
+            dependencies: dependencies
+          }
+        end
+
+        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] = build_asset_uri(filename, params.merge(id: asset[:id]))
+
+        # Deprecated: Avoid tracking Asset mtime
+        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
+end

data/lib/sprockets/manifest.rb

@@ -1,51 +1,87 @@
-require 'multi_json'
+require 'json'
 require 'time'
+require 'sprockets/manifest_utils'
 
 module Sprockets
-  # The Manifest logs the contents of assets compiled to a single
-  # directory. It records basic attributes about the asset for fast
-  # lookup without having to compile. A pointer from each logical path
-  # indicates with fingerprinted asset is the current one.
+  # The Manifest logs the contents of assets compiled to a single directory. It
+  # records basic attributes about the asset for fast lookup without having to
+  # compile. A pointer from each logical path indicates which fingerprinted
+  # asset is the current one.
   #
-  # The JSON is part of the public API and should be considered
-  # stable. This should make it easy to read from other programming
-  # languages and processes that don't have sprockets loaded. See
-  # `#assets` and `#files` for more infomation about the structure.
+  # The JSON is part of the public API and should be considered stable. This
+  # should make it easy to read from other programming languages and processes
+  # that don't have sprockets loaded. See `#assets` and `#files` for more
+  # infomation about the structure.
   class Manifest
-    attr_reader :environment, :path, :dir
+    include ManifestUtils
 
-    # Create new Manifest associated with an `environment`. `path` is
-    # a full path to the manifest json file. The file may or may not
-    # already exist. The dirname of the `path` will be used to write
-    # compiled assets to. Otherwise, if the path is a directory, the
-    # filename will default to "manifest.json" in that directory.
+    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
+    # ".sprockets-manifest-*.json" file in that directory.
     #
     #   Manifest.new(environment, "./public/assets/manifest.json")
     #
-    def initialize(environment, path)
-      @environment = environment
+    def initialize(*args)
+      if args.first.is_a?(Base) || args.first.nil?
+        @environment = args.shift
+      end
+
+      @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
+
+      # If filename is given as the second arg
+      if @directory && File.extname(@directory) != ""
+        @directory, @filename = nil, @directory
+      end
 
-      if File.extname(path) == ""
-        @dir  = File.expand_path(path)
-        @path = File.join(@dir, 'manifest.json')
-      else
-        @path = File.expand_path(path)
-        @dir  = File.dirname(path)
+      # 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 location
+      @rename_filename = nil
+      if @directory && @filename.nil?
+        @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
 
-      data = nil
+      unless @directory && @filename
+        raise ArgumentError, "manifest requires output filename"
+      end
+
+      data = {}
 
       begin
-        if File.exist?(@path)
-          data = MultiJson.decode(File.read(@path))
+        if File.exist?(@filename)
+          data = json_decode(File.read(@filename))
         end
-      rescue MultiJson::DecodeError => e
-        logger.error "#{@path} is invalid: #{e.class} #{e.message}"
+      rescue JSON::ParserError => e
+        logger.error "#{@filename} is invalid: #{e.class} #{e.message}"
       end
 
-      @data = data.is_a?(Hash) ? data : {}
+      @data = data
     end
 
+    # Returns String path to manifest.json file.
+    attr_reader :filename
+    alias_method :path, :filename
+
+    attr_reader :directory
+    alias_method :dir, :directory
+
     # Returns internal assets mapping. Keys are logical paths which
     # map to the latest fingerprinted filename.
     #
@@ -75,6 +111,40 @@ module Sprockets
       @data['files'] ||= {}
     end
 
+    # Public: Find all assets matching pattern set in environment.
+    #
+    # Returns Enumerator of Assets.
+    def find(*args)
+      unless environment
+        raise Error, "manifest requires environment for compilation"
+      end
+
+      return to_enum(__method__, *args) unless block_given?
+
+      paths, filters = args.flatten.partition { |arg| self.class.simple_logical_path?(arg) }
+      filters = filters.map { |arg| self.class.compile_match_filter(arg) }
+
+      environment = self.environment.cached
+
+      paths.each do |path|
+        environment.find_all_linked_assets(path) do |asset|
+          yield asset
+        end
+      end
+
+      if filters.any?
+        environment.logical_paths do |logical_path, filename|
+          if filters.any? { |f| f.call(logical_path, filename) }
+            environment.find_all_linked_assets(filename) do |asset|
+              yield asset
+            end
+          end
+        end
+      end
+
+      nil
+    end
+
     # Compile and write asset to directory. The asset is written to a
     # fingerprinted filename like
     # `application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js`. An entry is
@@ -83,32 +153,36 @@ module Sprockets
     #   compile("application.js")
     #
     def compile(*args)
-      paths = environment.each_logical_path(*args).to_a +
-        args.flatten.select { |fn| Pathname.new(fn).absolute? }
+      unless environment
+        raise Error, "manifest requires environment for compilation"
+      end
 
-      paths.each do |path|
-        if asset = find_asset(path)
-          files[asset.digest_path] = {
-            'logical_path' => asset.logical_path,
-            'mtime'        => asset.mtime.iso8601,
-            'size'         => asset.bytesize,
-            'digest'       => asset.digest
-          }
-          assets[asset.logical_path] = asset.digest_path
-
-          target = File.join(dir, asset.digest_path)
-
-          if File.exist?(target)
-            logger.debug "Skipping #{target}, already exists"
-          else
-            logger.info "Writing #{target}"
-            asset.write_to target
-          end
+      filenames = []
+
+      find(*args) do |asset|
+        files[asset.digest_path] = {
+          'logical_path' => asset.logical_path,
+          'mtime'        => asset.mtime.iso8601,
+          'size'         => asset.bytesize,
+          'digest'       => asset.hexdigest,
+          'integrity'    => asset.integrity
+        }
+        assets[asset.logical_path] = asset.digest_path
 
-          save
-          asset
+        target = File.join(dir, asset.digest_path)
+
+        if File.exist?(target)
+          logger.debug "Skipping #{target}, already exists"
+        else
+          logger.info "Writing #{target}"
+          asset.write_to target
         end
+
+        filenames << asset.filename
       end
+      save
+
+      filenames
     end
 
     # Removes file from directory and from manifest. `filename` must
@@ -129,76 +203,83 @@ module Sprockets
 
       save
 
-      logger.warn "Removed #{filename}"
+      logger.info "Removed #{filename}"
 
       nil
     end
 
     # Cleanup old assets in the compile directory. By default it will
-    # keep the latest version plus 2 backups.
-    def clean(keep = 2)
-      self.assets.keys.each do |logical_path|
-        # Get assets sorted by ctime, newest first
-        assets = backups_for(logical_path)
+    # 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'] }
 
-        # Keep the last N backups
-        assets = assets[keep..-1] || []
+      asset_versions.each do |logical_path, versions|
+        current = assets[logical_path]
 
-        # Remove old assets
-        assets.each { |path, _| remove(path) }
+        versions.reject { |path, _|
+          path == current
+        }.sort_by { |_, attrs|
+          # Sort by timestamp
+          Time.parse(attrs['mtime'])
+        }.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
 
     # Wipe directive
     def clobber
-      FileUtils.rm_r(@dir) if File.exist?(@dir)
-      logger.warn "Removed #{@dir}"
+      FileUtils.rm_r(directory) if File.exist?(directory)
+      logger.info "Removed #{directory}"
       nil
     end
 
-    protected
-      # Finds all the backup assets for a logical path. The latest
-      # version is always excluded. The return array is sorted by the
-      # assets mtime in descending order (Newest to oldest).
-      def backups_for(logical_path)
-        files.select { |filename, attrs|
-          # Matching logical paths
-          attrs['logical_path'] == logical_path &&
-            # Excluding whatever asset is the current
-            assets[logical_path] != filename
-        }.sort_by { |filename, attrs|
-          # Sort by timestamp
-          Time.parse(attrs['mtime'])
-        }.reverse
+    # Persist manfiest back to FS
+    def save
+      if @rename_filename
+        logger.info "Renaming #{@filename} to #{@rename_filename}"
+        FileUtils.mv(@filename, @rename_filename)
+        @filename = @rename_filename
+        @rename_filename = nil
       end
 
-      # Basic wrapper around Environment#find_asset. Logs compile time.
-      def find_asset(logical_path)
-        asset = nil
-        ms = benchmark do
-          asset = environment.find_asset(logical_path)
-        end
-        logger.warn "Compiled #{logical_path}  (#{ms}ms)"
-        asset
+      data = json_encode(@data)
+      FileUtils.mkdir_p File.dirname(@filename)
+      PathUtils.atomic_write(@filename) do |f|
+        f.write(data)
       end
+    end
 
-      # Persist manfiest back to FS
-      def save
-        FileUtils.mkdir_p dir
-        File.open(path, 'w') do |f|
-          f.write MultiJson.encode(@data)
-        end
+    private
+      def json_decode(obj)
+        JSON.parse(obj, create_additions: false)
       end
 
-    private
-      def logger
-        environment.logger
+      def json_encode(obj)
+        JSON.generate(obj)
       end
 
-      def benchmark
-        start_time = Time.now.to_f
-        yield
-        ((Time.now.to_f - start_time) * 1000).to_i
+      def logger
+        if environment
+          environment.logger
+        else
+          logger = Logger.new($stderr)
+          logger.level = Logger::FATAL
+          logger
+        end
       end
   end
 end

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