sprockets 2.2.3 → 4.0.0

data/lib/sprockets/manifest.rb

@@ -1,51 +1,85 @@
-require 'multi_json'
+# frozen_string_literal: true
+require 'json'
 require 'time'
 
+require 'concurrent'
+
+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
+
+    attr_reader :environment
 
-    # 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.
+    # 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
 
-      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)
+      @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
 
-      data = nil
+      # 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
+      if @directory && @filename.nil?
+        @filename = find_directory_manifest(@directory, logger)
+      end
+
+      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,7 +109,48 @@ module Sprockets
       @data['files'] ||= {}
     end
 
-    # Compile and write asset to directory. The asset is written to a
+    # 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?
+
+      environment = self.environment.cached
+      promises = args.flatten.map do |path|
+        Concurrent::Promise.execute(executor: executor) do
+          environment.find_all_linked_assets(path) do |asset|
+            yield asset
+          end
+        end
+      end
+      promises.each(&:wait!)
+
+      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|
+          asset = assets[path]
+          yield File.binread(File.join(dir, asset)) if asset
+        end
+      end
+    end
+
+    # Compile asset to directory. The asset is written to a
     # fingerprinted filename like
     # `application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js`. An entry is
     # also inserted into the manifest file.
@@ -83,31 +158,53 @@ module Sprockets
     #   compile("application.js")
     #
     def compile(*args)
-      paths = environment.each_logical_path(*args).to_a +
-        args.flatten.select { |fn| Pathname.new(fn).absolute? }
-
-      paths.each do |path|
-        if asset = find_asset(path)
-          files[asset.digest_path] = {
-            'logical_path' => asset.logical_path,
-            'mtime'        => asset.mtime.iso8601,
-            '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"
+      unless environment
+        raise Error, "manifest requires environment for compilation"
+      end
+
+      filenames            = []
+      concurrent_exporters = []
+
+      assets_to_export = Concurrent::Array.new
+      find(*args) do |asset|
+        assets_to_export << asset
+      end
+
+      assets_to_export.each do |asset|
+        mtime = Time.now.iso8601
+        files[asset.digest_path] = {
+          'logical_path' => asset.logical_path,
+          'mtime'        => mtime,
+          '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
+
+        filenames << asset.filename
+
+        promise      = nil
+        exporters_for_asset(asset) do |exporter|
+          next if exporter.skip?(logger)
+
+          if promise.nil?
+            promise = Concurrent::Promise.new(executor: executor) { exporter.call }
+            concurrent_exporters << promise.execute
           else
-            logger.info "Writing #{target}"
-            asset.write_to target
+            concurrent_exporters << promise.then { exporter.call }
           end
-
-          save
-          asset
         end
       end
+
+      # make sure all exporters have finished before returning the main thread
+      concurrent_exporters.each(&:wait!)
+      save
+
+      filenames
     end
 
     # Removes file from directory and from manifest. `filename` must
@@ -117,6 +214,7 @@ module Sprockets
     #
     def remove(filename)
       path = File.join(dir, filename)
+      gzip = "#{path}.gz"
       logical_path = files[filename]['logical_path']
 
       if assets[logical_path] == filename
@@ -125,79 +223,116 @@ module Sprockets
 
       files.delete(filename)
       FileUtils.rm(path) if File.exist?(path)
+      FileUtils.rm(gzip) if File.exist?(gzip)
 
       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}"
+      # if we have an environment clear the cache too
+      environment.cache.clear if environment
       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
+      data = json_encode(@data)
+      FileUtils.mkdir_p File.dirname(@filename)
+      PathUtils.atomic_write(@filename) do |f|
+        f.write(data)
       end
+    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)
+    private
+
+      # Given an asset, finds all exporters that
+      # match its mime-type.
+      #
+      # Will yield each expoter to the passed in block.
+      #
+      #     array = []
+      #     puts asset.content_type # => "application/javascript"
+      #     exporters_for_asset(asset) do |exporter|
+      #       array << exporter
+      #     end
+      #     # puts array => [Exporters::FileExporter, Exporters::ZlibExporter]
+      def exporters_for_asset(asset)
+        exporters = [Exporters::FileExporter]
+
+        environment.exporters.each do |mime_type, exporter_list|
+          next unless asset.content_type
+          next unless environment.match_mime_type? asset.content_type, mime_type
+          exporter_list.each do |exporter|
+            exporters << exporter
+          end
         end
-        logger.warn "Compiled #{logical_path}  (#{ms}ms)"
-        asset
-      end
 
-      # Persist manfiest back to FS
-      def save
-        FileUtils.mkdir_p dir
-        File.open(path, 'w') do |f|
-          f.write MultiJson.encode(@data)
+        exporters.uniq!
+
+        exporters.each do |exporter|
+          yield exporter.new(asset: asset, environment: environment, directory: dir)
         end
       end
 
-    private
+      def json_decode(obj)
+        JSON.parse(obj, create_additions: false)
+      end
+
+      def json_encode(obj)
+        JSON.generate(obj)
+      end
+
       def logger
-        environment.logger
+        if environment
+          environment.logger
+        else
+          logger = Logger.new($stderr)
+          logger.level = Logger::FATAL
+          logger
+        end
       end
 
-      def benchmark
-        start_time = Time.now.to_f
-        yield
-        ((Time.now.to_f - start_time) * 1000).to_i
+      def executor
+        @executor ||= environment.export_concurrent ? :fast : :immediate
       end
   end
 end

data/lib/sprockets/manifest_utils.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+require 'securerandom'
+require 'logger'
+
+module Sprockets
+  # Public: Manifest utilities.
+  module ManifestUtils
+    extend self
+
+    MANIFEST_RE = /^\.sprockets-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, logger = Logger.new($stderr))
+      entries = File.directory?(dirname) ? Dir.entries(dirname) : []
+      manifest_entries = entries.select { |e| e =~ MANIFEST_RE }
+      if manifest_entries.length > 1
+        manifest_entries.sort!
+        logger.warn("Found multiple manifests: #{manifest_entries}. Choosing the first alphabetically: #{manifest_entries.first}")
+      end
+      entry = manifest_entries.first || generate_manifest_path
+      File.join(dirname, entry)
+    end
+  end
+end

data/lib/sprockets/mime.rb

@@ -1,48 +1,96 @@
-require 'rack/mime'
+# frozen_string_literal: true
+require 'sprockets/encoding_utils'
+require 'sprockets/http_utils'
+require 'sprockets/utils'
 
 module Sprockets
   module Mime
-    # Returns a `Hash` of registered mime types registered on the
-    # environment and those part of `Rack::Mime`.
+    include HTTPUtils, Utils
+
+    # Public: Mapping of MIME type Strings to properties Hash.
     #
-    # If an `ext` is given, it will lookup the mime type for that extension.
-    def mime_types(ext = nil)
-      if ext.nil?
-        Rack::Mime::MIME_TYPES.merge(@mime_types)
-      else
-        ext = Sprockets::Utils.normalize_extension(ext)
-        @mime_types[ext] || Rack::Mime::MIME_TYPES[ext]
-      end
+    # key   - MIME Type String
+    # value - Hash
+    #   extensions - Array of extnames
+    #   charset    - Default Encoding or function to detect encoding
+    #
+    # Returns Hash.
+    def mime_types
+      config[:mime_types]
+    end
+
+    # Internal: Mapping of MIME extension Strings to MIME type Strings.
+    #
+    # Used for internal fast lookup purposes.
+    #
+    # Examples:
+    #
+    #   mime_exts['.js'] #=> 'application/javascript'
+    #
+    # key   - MIME extension String
+    # value - MIME Type String
+    #
+    # Returns Hash.
+    def mime_exts
+      config[:mime_exts]
     end
 
-    if {}.respond_to?(:key)
-      def extension_for_mime_type(type)
-        mime_types.key(type)
+    # Public: Register a new mime type.
+    #
+    # mime_type  - String MIME Type
+    # extensions - Array of String extnames
+    # charset    - Proc/Method that detects the charset of a file.
+    #              See EncodingUtils.
+    #
+    # Returns nothing.
+    def register_mime_type(mime_type, extensions: [], charset: nil)
+      extnames = Array(extensions)
+
+      charset ||= :default if mime_type.start_with?('text/')
+      charset = EncodingUtils::CHARSET_DETECT[charset] if charset.is_a?(Symbol)
+
+      self.config = hash_reassoc(config, :mime_exts) do |mime_exts|
+        extnames.each do |extname|
+          mime_exts[extname] = mime_type
+        end
+        mime_exts
       end
-    else
-      def extension_for_mime_type(type)
-        mime_types.index(type)
+
+      self.config = hash_reassoc(config, :mime_types) do |mime_types|
+        type = { extensions: extnames }
+        type[:charset] = charset if charset
+        mime_types.merge(mime_type => type)
       end
     end
 
-    # Register a new mime type.
-    def register_mime_type(mime_type, ext)
-      ext = Sprockets::Utils.normalize_extension(ext)
-      @mime_types[ext] = mime_type
+    # Internal: Get detecter function for MIME type.
+    #
+    # mime_type - String MIME type
+    #
+    # Returns Proc detector or nil if none is available.
+    def mime_type_charset_detecter(mime_type)
+      if type = config[:mime_types][mime_type]
+        if detect = type[:charset]
+          return detect
+        end
+      end
     end
 
-    if defined? Encoding
-      # Returns the correct encoding for a given mime type, while falling
-      # back on the default external encoding, if it exists.
-      def encoding_for_mime_type(type)
-        encoding = Encoding::BINARY if type =~ %r{^(image|audio|video)/}
-        encoding ||= default_external_encoding if respond_to?(:default_external_encoding)
-        encoding
+    # Public: Read file on disk with MIME type specific encoding.
+    #
+    # filename     - String path
+    # content_type - String MIME type
+    #
+    # Returns String file contents transcoded to UTF-8 or in its external
+    # encoding.
+    def read_file(filename, content_type = nil)
+      data = File.binread(filename)
+
+      if detect = mime_type_charset_detecter(content_type)
+        detect.call(data).encode(Encoding::UTF_8, universal_newline: true)
+      else
+        data
       end
     end
   end
-
-  # Extend Sprockets module to provide global registry
-  extend Mime
-  @mime_types = {}
 end

data/lib/sprockets/npm.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+require 'json'
+
+module Sprockets
+  module Npm
+    # Internal: Override resolve_alternates to install package.json behavior.
+    #
+    # load_path    - String environment path
+    # logical_path - String path relative to base
+    #
+    # Returns candiate filenames.
+    def resolve_alternates(load_path, logical_path)
+      candidates, deps = super
+
+      dirname = File.join(load_path, logical_path)
+
+      if directory?(dirname)
+        filename = File.join(dirname, 'package.json')
+
+        if self.file?(filename)
+          deps << build_file_digest_uri(filename)
+          read_package_directives(dirname, filename) do |path|
+            if file?(path)
+              candidates << path
+            end
+          end
+        end
+      end
+
+      return candidates, deps
+    end
+
+    # Internal: Read package.json's main and style directives.
+    #
+    # dirname  - String path to component directory.
+    # filename - String path to package.json.
+    #
+    # Returns nothing.
+    def read_package_directives(dirname, filename)
+      package = JSON.parse(File.read(filename), create_additions: false)
+
+      case package['main']
+      when String
+        yield File.expand_path(package['main'], dirname)
+      when nil
+        yield File.expand_path('index.js', dirname)
+      end
+
+      yield File.expand_path(package['style'], dirname) if package['style']
+    end
+  end
+end