sprokovuln 0.2.0

data/vendor/ruby/gems/sprockets-3.7.1/lib/sprockets/loader.rb

@@ -0,0 +1,325 @@
+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'
+require 'sprockets/unloaded_asset'
+
+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 Asset URI.
+    #
+    # uri - A String containing complete URI to a file including schema
+    #       and full path such as:
+    #       "file:///Path/app/assets/js/app.js?type=application/javascript"
+    #
+    #
+    # Returns Asset.
+    def load(uri)
+      unloaded = UnloadedAsset.new(uri, self)
+      if unloaded.params.key?(:id)
+        unless asset = asset_from_cache(unloaded.asset_key)
+          id = unloaded.params.delete(:id)
+          uri_without_id = build_asset_uri(unloaded.filename, unloaded.params)
+          asset = load_from_unloaded(UnloadedAsset.new(uri_without_id, self))
+          if asset[:id] != id
+            @logger.warn "Sprockets load error: Tried to find #{uri}, but latest was id #{asset[:id]}"
+          end
+        end
+      else
+        asset = fetch_asset_from_dependency_cache(unloaded) do |paths|
+          # When asset is previously generated, its "dependencies" are stored in the cache.
+          # The presence of `paths` indicates dependencies were stored.
+          # We can check to see if the dependencies have not changed by "resolving" them and
+          # generating a digest key from the resolved entries. If this digest key has not
+          # changed the asset will be pulled from cache.
+          #
+          # If this `paths` is present but the cache returns nothing then `fetch_asset_from_dependency_cache`
+          # will confusingly be called again with `paths` set to nil where the asset will be
+          # loaded from disk.
+          if paths
+            digest = DigestUtils.digest(resolve_dependencies(paths))
+            if uri_from_cache = cache.get(unloaded.digest_key(digest), true)
+              asset_from_cache(UnloadedAsset.new(uri_from_cache, self).asset_key)
+            end
+          else
+            load_from_unloaded(unloaded)
+          end
+        end
+      end
+      Asset.new(self, asset)
+    end
+
+    private
+
+      # Internal: Load asset hash from cache
+      #
+      # key - A String containing lookup information for an asset
+      #
+      # This method converts all "compressed" paths to absolute paths.
+      # Returns a hash of values representing an asset
+      def asset_from_cache(key)
+        asset = cache.get(key, true)
+        if asset
+          asset[:uri]       = expand_from_root(asset[:uri])
+          asset[:load_path] = expand_from_root(asset[:load_path])
+          asset[:filename]  = expand_from_root(asset[:filename])
+          asset[:metadata][:included].map!          { |uri| expand_from_root(uri) } if asset[:metadata][:included]
+          asset[:metadata][:links].map!             { |uri| expand_from_root(uri) } if asset[:metadata][:links]
+          asset[:metadata][:stubbed].map!           { |uri| expand_from_root(uri) } if asset[:metadata][:stubbed]
+          asset[:metadata][:required].map!          { |uri| expand_from_root(uri) } if asset[:metadata][:required]
+          asset[:metadata][:dependencies].map!      { |uri| uri.start_with?("file-digest://") ? expand_from_root(uri) : uri } if asset[:metadata][:dependencies]
+
+          asset[:metadata].each_key do |k|
+            next unless k =~ /_dependencies\z/
+            asset[:metadata][k].map! { |uri| expand_from_root(uri) }
+          end
+        end
+        asset
+      end
+
+      # Internal: Loads an asset and saves it to cache
+      #
+      # unloaded - An UnloadedAsset
+      #
+      # This method is only called when the given unloaded asset could not be
+      # successfully pulled from cache.
+      def load_from_unloaded(unloaded)
+        unless file?(unloaded.filename)
+          raise FileNotFound, "could not find file: #{unloaded.filename}"
+        end
+
+        load_path, logical_path = paths_split(config[:paths], unloaded.filename)
+
+        unless load_path
+          raise FileOutsidePaths, "#{unloaded.filename} is no longer under a load path: #{self.paths.join(', ')}"
+        end
+
+        logical_path, file_type, engine_extnames, _ = parse_path_extnames(logical_path)
+        name = logical_path
+
+        if pipeline = unloaded.params[:pipeline]
+          logical_path += ".#{pipeline}"
+        end
+
+        if type = unloaded.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: unloaded.uri,
+            filename: unloaded.filename,
+            load_path: load_path,
+            name: name,
+            content_type: type,
+            metadata: { dependencies: dependencies }
+          })
+          validate_processor_result!(result)
+          source = result.delete(:data)
+          metadata = result
+          metadata[:charset] = source.encoding.name.downcase unless metadata.key?(:charset)
+          metadata[:digest]  = digest(source)
+          metadata[:length]  = source.bytesize
+        else
+          dependencies << build_file_digest_uri(unloaded.filename)
+          metadata = {
+            digest: file_digest(unloaded.filename),
+            length: self.stat(unloaded.filename).size,
+            dependencies: dependencies
+          }
+        end
+
+        asset = {
+          uri: unloaded.uri,
+          load_path: load_path,
+          filename: unloaded.filename,
+          name: name,
+          logical_path: logical_path,
+          content_type: type,
+          source: source,
+          metadata: metadata,
+          dependencies_digest: DigestUtils.digest(resolve_dependencies(metadata[:dependencies]))
+        }
+
+        asset[:id]  = pack_hexdigest(digest(asset))
+        asset[:uri] = build_asset_uri(unloaded.filename, unloaded.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 : nil
+          else
+            nil
+          end
+        }.compact.max
+        asset[:mtime] ||= self.stat(unloaded.filename).mtime.to_i
+
+        store_asset(asset, unloaded)
+        asset
+      end
+
+      # Internal: Save a given asset to the cache
+      #
+      # asset - A hash containing values of loaded asset
+      # unloaded - The UnloadedAsset used to lookup the `asset`
+      #
+      # This method converts all absolute paths to "compressed" paths
+      # which are relative if they're in the root.
+      def store_asset(asset, unloaded)
+        # Save the asset in the cache under the new URI
+        cached_asset             = asset.dup
+        cached_asset[:uri]       = compress_from_root(asset[:uri])
+        cached_asset[:filename]  = compress_from_root(asset[:filename])
+        cached_asset[:load_path] = compress_from_root(asset[:load_path])
+
+        if cached_asset[:metadata]
+          # Deep dup to avoid modifying `asset`
+          cached_asset[:metadata] = cached_asset[:metadata].dup
+          if cached_asset[:metadata][:included] && !cached_asset[:metadata][:included].empty?
+            cached_asset[:metadata][:included] = cached_asset[:metadata][:included].dup
+            cached_asset[:metadata][:included].map! { |uri| compress_from_root(uri) }
+          end
+
+          if cached_asset[:metadata][:links] && !cached_asset[:metadata][:links].empty?
+            cached_asset[:metadata][:links] = cached_asset[:metadata][:links].dup
+            cached_asset[:metadata][:links].map! { |uri| compress_from_root(uri) }
+          end
+
+          if cached_asset[:metadata][:stubbed] && !cached_asset[:metadata][:stubbed].empty?
+            cached_asset[:metadata][:stubbed] = cached_asset[:metadata][:stubbed].dup
+            cached_asset[:metadata][:stubbed].map! { |uri| compress_from_root(uri) }
+          end
+
+          if cached_asset[:metadata][:required] && !cached_asset[:metadata][:required].empty?
+            cached_asset[:metadata][:required] = cached_asset[:metadata][:required].dup
+            cached_asset[:metadata][:required].map! { |uri| compress_from_root(uri) }
+          end
+
+          if cached_asset[:metadata][:dependencies] && !cached_asset[:metadata][:dependencies].empty?
+            cached_asset[:metadata][:dependencies] = cached_asset[:metadata][:dependencies].dup
+            cached_asset[:metadata][:dependencies].map! do |uri|
+              uri.start_with?("file-digest://".freeze) ? compress_from_root(uri) : uri
+            end
+          end
+
+          # compress all _dependencies in metadata like `sass_dependencies`
+          cached_asset[:metadata].each do |key, value|
+            next unless key =~ /_dependencies\z/
+            cached_asset[:metadata][key] = value.dup
+            cached_asset[:metadata][key].map! {|uri| compress_from_root(uri) }
+          end
+        end
+
+        # Unloaded asset and stored_asset now have a different URI
+        stored_asset = UnloadedAsset.new(asset[:uri], self)
+        cache.set(stored_asset.asset_key, cached_asset, true)
+
+        # Save the new relative path for the digest key of the unloaded asset
+        cache.set(unloaded.digest_key(asset[:dependencies_digest]), stored_asset.compressed_path, true)
+      end
+
+
+      # Internal: Resolve set of dependency URIs.
+      #
+      # uris - An Array of "dependencies" for example:
+      #        ["environment-version", "environment-paths", "processors:type=text/css&file_type=text/css",
+      #           "file-digest:///Full/path/app/assets/stylesheets/application.css",
+      #           "processors:type=text/css&file_type=text/css&pipeline=self",
+      #           "file-digest:///Full/path/app/assets/stylesheets"]
+      #
+      # Returns back array of things that the given uri dpends on
+      # For example the environment version, if you're using a different version of sprockets
+      # then the dependencies should be different, this is used only for generating cache key
+      # for example the "environment-version" may be resolved to "environment-1.0-3.2.0" for
+      #  version "3.2.0" of sprockets.
+      #
+      # Any paths that are returned are converted to relative paths
+      #
+      # Returns array of resolved dependencies
+      def resolve_dependencies(uris)
+        uris.map { |uri| resolve_dependency(uri) }
+      end
+
+      # Internal: Retrieves an asset based on its digest
+      #
+      # unloaded - An UnloadedAsset
+      # limit    - A Fixnum which sets the maximum number of versions of "histories"
+      #            stored in the cache
+      #
+      # This method attempts to retrieve the last `limit` number of histories of an asset
+      # from the cache a "history" which is an array of unresolved "dependencies" that the asset needs
+      # to compile. In this case A dependency can refer to either an asset i.e. index.js
+      # may rely on jquery.js (so jquery.js is a depndency), or other factors that may affect
+      # compilation, such as the VERSION of sprockets (i.e. the environment) and what "processors"
+      # are used.
+      #
+      # For example a history array may look something like this
+      #
+      #   [["environment-version", "environment-paths", "processors:type=text/css&file_type=text/css",
+      #     "file-digest:///Full/path/app/assets/stylesheets/application.css",
+      #     "processors:type=text/css&file_digesttype=text/css&pipeline=self",
+      #     "file-digest:///Full/path/app/assets/stylesheets"]]
+      #
+      # Where the first entry is a Set of dependencies for last generated version of that asset.
+      # Multiple versions are stored since sprockets keeps the last `limit` number of assets
+      # generated present in the system.
+      #
+      # If a "history" of dependencies is present in the cache, each version of "history" will be
+      # yielded to the passed block which is responsible for loading the asset. If found, the existing
+      # history will be saved with the dependency that found a valid asset moved to the front.
+      #
+      # If no history is present, or if none of the histories could be resolved to a valid asset then,
+      # the block is yielded to and expected to return a valid asset.
+      # When this happens the dependencies for the returned asset are added to the "history", and older
+      # entries are removed if the "history" is above `limit`.
+      def fetch_asset_from_dependency_cache(unloaded, limit = 3)
+        key = unloaded.dependency_history_key
+
+        history = cache.get(key) || []
+        history.each_with_index do |deps, index|
+          expanded_deps = deps.map do |path|
+            path.start_with?("file-digest://") ? expand_from_root(path) : path
+          end
+          if asset = yield(expanded_deps)
+            cache.set(key, history.rotate!(index)) if index > 0
+            return asset
+          end
+        end
+
+        asset = yield
+        deps  = asset[:metadata][:dependencies].dup.map! do |uri|
+          uri.start_with?("file-digest://") ? compress_from_root(uri) : uri
+        end
+        cache.set(key, history.unshift(deps).take(limit))
+        asset
+      end
+  end
+end

data/vendor/ruby/gems/sprockets-3.7.1/lib/sprockets/manifest.rb

@@ -0,0 +1,335 @@
+require 'json'
+require 'time'
+
+require 'concurrent'
+
+require 'sprockets/manifest_utils'
+require 'sprockets/utils/gzip'
+
+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 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.
+  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
+    # ".sprockets-manifest-*.json" file in that directory.
+    #
+    #   Manifest.new(environment, "./public/assets/manifest.json")
+    #
+    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
+
+      # 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
+
+      unless @directory && @filename
+        raise ArgumentError, "manifest requires output filename"
+      end
+
+      data = {}
+
+      begin
+        if File.exist?(@filename)
+          data = json_decode(File.read(@filename))
+        end
+      rescue JSON::ParserError => e
+        logger.error "#{@filename} is invalid: #{e.class} #{e.message}"
+      end
+
+      @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.
+    #
+    #   Logical path (String): Fingerprint path (String)
+    #
+    #   { "application.js" => "application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js",
+    #     "jquery.js"      => "jquery-ae0908555a245f8266f77df5a8edca2e.js" }
+    #
+    def assets
+      @data['assets'] ||= {}
+    end
+
+    # Returns internal file directory listing. Keys are filenames
+    # which map to an attributes array.
+    #
+    #   Fingerprint path (String):
+    #     logical_path: Logical path (String)
+    #     mtime: ISO8601 mtime (String)
+    #     digest: Base64 hex digest (String)
+    #
+    #  { "application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js" =>
+    #      { 'logical_path' => "application.js",
+    #        'mtime' => "2011-12-13T21:47:08-06:00",
+    #        'digest' => "2e8e9a7c6b0aafa0c9bdeec90ea30213" } }
+    #
+    def files
+      @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
+
+    # Public: Find the source of assets by paths.
+    #
+    # Returns Enumerator of assets file content.
+    def find_sources(*args)
+      return to_enum(__method__, *args) unless block_given?
+
+      if environment
+        find(*args).each do |asset|
+          yield asset.source
+        end
+      else
+        args.each do |path|
+          yield File.binread(File.join(dir, assets[path]))
+        end
+      end
+    end
+
+    # Compile and write asset to directory. The asset is written to a
+    # fingerprinted filename like
+    # `application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js`. An entry is
+    # also inserted into the manifest file.
+    #
+    #   compile("application.js")
+    #
+    def compile(*args)
+      unless environment
+        raise Error, "manifest requires environment for compilation"
+      end
+
+      filenames              = []
+      concurrent_compressors = []
+      concurrent_writers     = []
+
+      find(*args) do |asset|
+        files[asset.digest_path] = {
+          'logical_path' => asset.logical_path,
+          'mtime'        => asset.mtime.iso8601,
+          'size'         => asset.bytesize,
+          'digest'       => asset.hexdigest,
+
+          # Deprecated: Remove beta integrity attribute in next release.
+          # Callers should DigestUtils.hexdigest_integrity_uri to compute the
+          # digest themselves.
+          'integrity'    => DigestUtils.hexdigest_integrity_uri(asset.hexdigest)
+        }
+        assets[asset.logical_path] = asset.digest_path
+
+        if alias_logical_path = self.class.compute_alias_logical_path(asset.logical_path)
+          assets[alias_logical_path] = asset.digest_path
+        end
+
+        target = File.join(dir, asset.digest_path)
+
+        if File.exist?(target)
+          logger.debug "Skipping #{target}, already exists"
+        else
+          logger.info "Writing #{target}"
+          write_file = Concurrent::Future.execute { asset.write_to target }
+          concurrent_writers << write_file
+        end
+        filenames << asset.filename
+
+        next if environment.skip_gzip?
+        gzip = Utils::Gzip.new(asset)
+        next if gzip.cannot_compress?(environment.mime_types)
+
+        if File.exist?("#{target}.gz")
+          logger.debug "Skipping #{target}.gz, already exists"
+        else
+          logger.info "Writing #{target}.gz"
+          concurrent_compressors << Concurrent::Future.execute do
+            write_file.wait! if write_file
+            gzip.compress(target)
+          end
+        end
+
+      end
+      concurrent_writers.each(&:wait!)
+      concurrent_compressors.each(&:wait!)
+      save
+
+      filenames
+    end
+
+    # Removes file from directory and from manifest. `filename` must
+    # be the name with any directory path.
+    #
+    #   manifest.remove("application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js")
+    #
+    def remove(filename)
+      path = File.join(dir, filename)
+      gzip = "#{path}.gz"
+      logical_path = files[filename]['logical_path']
+
+      if assets[logical_path] == filename
+        assets.delete(logical_path)
+      end
+
+      files.delete(filename)
+      FileUtils.rm(path) if File.exist?(path)
+      FileUtils.rm(gzip) if File.exist?(gzip)
+
+      save
+
+      logger.info "Removed #{filename}"
+
+      nil
+    end
+
+    # Cleanup old assets in the compile directory. By default it will
+    # 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'] }
+
+      asset_versions.each do |logical_path, versions|
+        current = assets[logical_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(directory) if File.exist?(directory)
+      logger.info "Removed #{directory}"
+      nil
+    end
+
+    # 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
+
+      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)
+        JSON.parse(obj, create_additions: false)
+      end
+
+      def json_encode(obj)
+        JSON.generate(obj)
+      end
+
+      def logger
+        if environment
+          environment.logger
+        else
+          logger = Logger.new($stderr)
+          logger.level = Logger::FATAL
+          logger
+        end
+      end
+  end
+end

data/vendor/ruby/gems/sprockets-3.7.1/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