sprockets 2.6.0 → 4.2.2

data/bin/sprockets

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+$VERBOSE = nil
 
 require 'sprockets'
 require 'optparse'
@@ -11,7 +12,7 @@ unless ARGV.delete("--noenv")
   end
 end
 
-filenames = []
+paths = []
 environment = Sprockets::Environment.new(Dir.pwd)
 manifest = nil
 
@@ -40,9 +41,21 @@ OptionParser.new do |opts|
     manifest = Sprockets::Manifest.new(environment, directory)
   end
 
+  opts.on("--css-compressor=COMPRESSOR", "Use CSS compressor") do |compressor|
+    environment.css_compressor = compressor.to_sym
+  end
+
+  opts.on("--js-compressor=COMPRESSOR", "Use JavaScript compressor") do |compressor|
+    environment.js_compressor = compressor.to_sym
+  end
+
   opts.on("--noenv", "Disables .sprocketsrc file") do
   end
 
+  opts.on("--cache=DIRECTORY", "Enables the FileStore cache using the specified directory") do |directory|
+    environment.cache = Sprockets::Cache::FileStore.new(directory)
+  end
+
   opts.on_tail("-h", "--help", "Shows this help message") do
     opts.show_usage
   end
@@ -55,8 +68,8 @@ OptionParser.new do |opts|
   opts.show_usage if ARGV.empty?
 
   begin
-    opts.order(ARGV) do |filename|
-      filenames << File.expand_path(filename)
+    opts.order(ARGV) do |path|
+      paths << path
     end
   rescue OptionParser::ParseError => e
     opts.warn e.message
@@ -66,14 +79,14 @@ end
 
 if environment.paths.empty?
   warn "No load paths given"
-  warn "Usage: sprockets -Ijavascripts/ filename"
+  warn "Usage: sprockets -Ijavascripts/ path"
   exit 1
 end
 
 if manifest
-  manifest.compile(filenames)
-elsif filenames.length == 1
-  puts environment.find_asset(filenames.first).to_s
+  manifest.compile(paths)
+elsif paths.length == 1
+  puts environment.find_asset(paths.first).to_s
 else
   warn "Only one file can be compiled to stdout at a time"
   exit 1

data/lib/rake/sprocketstask.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rake'
 require 'rake/tasklib'
 
@@ -37,6 +38,25 @@ module Rake
     end
     attr_writer :environment
 
+    # Returns cached cached environment
+    def cached
+      @cached ||= environment.cached if environment
+    end
+    alias_method :index, :cached
+
+    # `Manifest` instance used for already compiled assets.
+    #
+    # Will be created by default if an environment and output
+    # directory are given
+    def manifest
+      if !@manifest.is_a?(Sprockets::Manifest) && @manifest.respond_to?(:call)
+        @manifest = @manifest.call
+      else
+        @manifest
+      end
+    end
+    attr_writer :manifest
+
     # Directory to write compiled assets too. As well as the manifest file.
     #
     #   t.output = "./public/assets"
@@ -49,9 +69,12 @@ module Rake
     #
     attr_accessor :assets
 
-    # Number of old assets to keep.
+    # Minimum number of old assets to keep. See Sprockets::Manifest#clean for more information.
     attr_accessor :keep
 
+    # Assets created within this age will be kept. See Sprockets::Manifest#clean for more information.
+    attr_accessor :age
+
     # Logger to use during rake tasks. Defaults to using stderr.
     #
     #   t.logger = Logger.new($stdout)
@@ -79,9 +102,11 @@ module Rake
     def initialize(name = :assets)
       @name         = name
       @environment  = lambda { Sprockets::Environment.new(Dir.pwd) }
+      @manifest     = lambda { Sprockets::Manifest.new(cached, output) }
       @logger       = Logger.new($stderr)
       @logger.level = Logger::INFO
       @keep         = 2
+      @age          = 3600
 
       yield self if block_given?
 
@@ -104,37 +129,29 @@ module Rake
         end
       end
 
-      task :clobber => ["clobber_#{name}"]
+      task clobber: ["clobber_#{name}"]
 
       desc name == :assets ? "Clean old assets" : "Clean old #{name} assets"
       task "clean_#{name}" do
         with_logger do
-          manifest.clean(keep)
+          manifest.clean(keep, age)
         end
       end
 
-      task :clean => ["clean_#{name}"]
+      task clean: ["clean_#{name}"]
     end
 
     private
-      # Returns cached indexed environment
-      def index
-        @index ||= environment.index
-      end
-
-      # Returns manifest for tasks
-      def manifest
-        @manifest ||= Sprockets::Manifest.new(index, output)
-      end
-
       # Sub out environment logger with our rake task logger that
       # writes to stderr.
       def with_logger
-        old_logger = index.logger
-        index.logger = @logger
+        if env = manifest.environment
+          old_logger = env.logger
+          env.logger = @logger
+        end
         yield
       ensure
-        index.logger = old_logger
+        env.logger = old_logger if env
       end
   end
 end

data/lib/sprockets/add_source_map_comment_to_asset_processor.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require 'sprockets/uri_utils'
+require 'sprockets/path_utils'
+
+module Sprockets
+  # This is a processor designed to add a source map "comment"
+  # to the bottom of a css or JS file that is serving a source
+  # map. An example of a comment might look like this
+  #
+  #    //# application.js-80af0efcc960fc2ac93eda2f7b12e3db40ab360bf6ea269ceed3bea3678326f9.map
+  #
+  # As an asset is built it gets source map information added
+  # to the `asset.to_hash[:metadata][:map]` key. This contains all the
+  # information that is needed to build a source map file.
+  #
+  # To add this comment we must have an asset we can link to.
+  # To do this we ensure that the original asset is loaded, then
+  # we use a use a special mime type. For example `application/js-sourcemap+json`
+  # for a JS source map.
+  #
+  # This will trigger a new asset to be loaded and generated by the
+  # `SourceMapProcessor` processor.
+  #
+  # Finally once we have that file, we can generate a link to it
+  # with it's full fingerprint. This is done and then
+  # added to the original asset as a comment at the bottom.
+  #
+  class AddSourceMapCommentToAssetProcessor
+    def self.call(input)
+
+      case input[:content_type]
+      when "application/javascript"
+        comment = "\n//# sourceMappingURL=%s"
+        map_type = "application/js-sourcemap+json"
+      when "text/css"
+        comment = "\n/*# sourceMappingURL=%s */"
+        map_type = "application/css-sourcemap+json"
+      else
+        fail input[:content_type]
+      end
+
+      env = input[:environment]
+
+      uri, _ = env.resolve!(input[:filename], accept: input[:content_type])
+      asset = env.load(uri)
+
+      uri, _ = env.resolve!(input[:filename], accept: map_type)
+      map = env.load(uri)
+
+      uri, params = URIUtils.parse_asset_uri(input[:uri])
+      uri = env.expand_from_root(params[:index_alias]) if params[:index_alias]
+      path = PathUtils.relative_path_from(PathUtils.split_subpath(input[:load_path], uri), map.digest_path)
+
+      asset.metadata.merge(
+        data: asset.source + (comment % path) + "\n",
+        links: asset.links + [asset.uri, map.uri]
+      )
+    end
+  end
+end

data/lib/sprockets/asset.rb

@@ -1,264 +1,212 @@
-require 'time'
-require 'set'
+# frozen_string_literal: true
+require 'fileutils'
+require 'sprockets/digest_utils'
 
 module Sprockets
-  # `Asset` is the base class for `BundledAsset` and `StaticAsset`.
   class Asset
-    # Internal initializer to load `Asset` from serialized `Hash`.
-    def self.from_hash(environment, hash)
-      return unless hash.is_a?(Hash)
+    attr_reader :logical_path
 
-      klass = case hash['class']
-        when 'BundledAsset'
-          BundledAsset
-        when 'ProcessedAsset'
-          ProcessedAsset
-        when 'StaticAsset'
-          StaticAsset
-        else
-          nil
-        end
-
-      if klass
-        asset = klass.allocate
-        asset.init_with(environment, hash)
-        asset
-      end
-    rescue UnserializeError
-      nil
-    end
-
-    attr_reader :logical_path, :pathname
-    attr_reader :content_type, :mtime, :length, :digest
-    alias_method :bytesize, :length
-
-    def initialize(environment, logical_path, pathname)
-      raise ArgumentError, "Asset logical path has no extension: #{logical_path}" if File.extname(logical_path) == ""
-
-      @root         = environment.root
-      @logical_path = logical_path.to_s
-      @pathname     = Pathname.new(pathname)
-      @content_type = environment.content_type_of(pathname)
-      @mtime        = environment.stat(pathname).mtime
-      @length       = environment.stat(pathname).size
-      @digest       = environment.file_digest(pathname).hexdigest
+    # Private: Initialize Asset wrapper from attributes Hash.
+    #
+    # Asset wrappers should not be initialized directly, only
+    # Environment#find_asset should vend them.
+    #
+    # attributes - Hash of ivars
+    #
+    # Returns Asset.
+    def initialize(attributes = {})
+      @attributes   = attributes
+      @content_type = attributes[:content_type]
+      @filename     = attributes[:filename]
+      @id           = attributes[:id]
+      @load_path    = attributes[:load_path]
+      @logical_path = attributes[:logical_path]
+      @metadata     = attributes[:metadata]
+      @name         = attributes[:name]
+      @source       = attributes[:source]
+      @uri          = attributes[:uri]
+    end
+
+    # Internal: Return all internal instance variables as a hash.
+    #
+    # Returns a Hash.
+    def to_hash
+      @attributes
     end
 
-    # Initialize `Asset` from serialized `Hash`.
-    def init_with(environment, coder)
-      @root = environment.root
-
-      @logical_path = coder['logical_path']
-      @content_type = coder['content_type']
-      @digest       = coder['digest']
-
-      if pathname = coder['pathname']
-        # Expand `$root` placeholder and wrapper string in a `Pathname`
-        @pathname = Pathname.new(expand_root_path(pathname))
-      end
+    # Public: Metadata accumulated from pipeline process.
+    #
+    # The API status of the keys is dependent on the pipeline processors
+    # itself. So some values maybe considered public and others internal.
+    # See the pipeline processor documentation itself.
+    #
+    # Returns Hash.
+    attr_reader :metadata
 
-      if mtime = coder['mtime']
-        # Parse time string
-        @mtime = Time.parse(mtime)
-      end
+    # Public: Returns String path of asset.
+    attr_reader :filename
 
-      if length = coder['length']
-        # Convert length to an `Integer`
-        @length = Integer(length)
-      end
-    end
+    # Internal: Unique asset object ID.
+    #
+    # Returns a String.
+    attr_reader :id
 
-    # Copy serialized attributes to the coder object
-    def encode_with(coder)
-      coder['class']        = self.class.name.sub(/Sprockets::/, '')
-      coder['logical_path'] = logical_path
-      coder['pathname']     = relativize_root_path(pathname).to_s
-      coder['content_type'] = content_type
-      coder['mtime']        = mtime.iso8601
-      coder['length']       = length
-      coder['digest']       = digest
-    end
+    # Public: Internal URI to lookup asset by.
+    #
+    # NOT a publicly accessible URL.
+    #
+    # Returns URI.
+    attr_reader :uri
 
-    # Return logical path with digest spliced in.
+    # Public: Return logical path with digest spliced in.
     #
     #   "foo/bar-37b51d194a7513e45b56f6524f2d51f2.js"
     #
+    # Returns String.
     def digest_path
-      logical_path.sub(/\.(\w+)$/) { |ext| "-#{digest}#{ext}" }
+      if DigestUtils.already_digested?(@name)
+        logical_path
+      else
+        logical_path.sub(/\.(\w+)$/) { |ext| "-#{etag}#{ext}" }
+      end
     end
 
-    # Return an `Array` of `Asset` files that are declared dependencies.
-    def dependencies
-      []
+    # Public: Return load path + logical path with digest spliced in.
+    #
+    # Returns String.
+    def full_digest_path
+      File.join(@load_path, digest_path)
     end
 
-    # Expand asset into an `Array` of parts.
+    # Public: Returns String MIME type of asset. Returns nil if type is unknown.
+    attr_reader :content_type
+
+    # Public: Get all externally linked asset filenames from asset.
     #
-    # Appending all of an assets body parts together should give you
-    # the asset's contents as a whole.
+    # All linked assets should be compiled anytime this asset is.
     #
-    # This allows you to link to individual files for debugging
-    # purposes.
-    def to_a
-      [self]
+    # Returns Set of String asset URIs.
+    def links
+      metadata[:links] || Set.new
     end
 
-    # `body` is aliased to source by default if it can't have any dependencies.
-    def body
-      source
+    # Public: Return `String` of concatenated source.
+    #
+    # Returns String.
+    def source
+      if @source
+        @source
+      else
+        # File is read everytime to avoid memory bloat of large binary files
+        File.binread(filename)
+      end
     end
 
-    # Return `String` of concatenated source.
+    # Public: Alias for #source.
+    #
+    # Returns String.
     def to_s
       source
     end
 
-    # Add enumerator to allow `Asset` instances to be used as Rack
-    # compatible body objects.
-    def each
-      yield to_s
+    # Public: Get charset of source.
+    #
+    # Returns a String charset name or nil if binary.
+    def charset
+      metadata[:charset]
     end
 
-    # Checks if Asset is fresh by comparing the actual mtime and
-    # digest to the inmemory model.
-    #
-    # Used to test if cached models need to be rebuilt.
-    def fresh?(environment)
-      # Check current mtime and digest
-      dependency_fresh?(environment, self)
+    # Public: Returns Integer length of source.
+    def length
+      metadata[:length]
     end
+    alias_method :bytesize, :length
 
-    # Checks if Asset is stale by comparing the actual mtime and
-    # digest to the inmemory model.
-    #
-    # Subclass must override `fresh?` or `stale?`.
-    def stale?(environment)
-      !fresh?(environment)
+    # Public: Returns String byte digest of source.
+    def digest
+      metadata[:digest]
     end
 
-    # Save asset to disk.
-    def write_to(filename, options = {})
-      # Gzip contents if filename has '.gz'
-      options[:compress] ||= File.extname(filename) == '.gz'
+    # Private: Return the version of the environment where the asset was generated.
+    def environment_version
+      metadata[:environment_version]
+    end
 
-      FileUtils.mkdir_p File.dirname(filename)
+    # Public: Returns String hexdigest of source.
+    def hexdigest
+      DigestUtils.pack_hexdigest(digest)
+    end
+
+    # Public: ETag String of Asset.
+    def etag
+      version = environment_version
 
-      File.open("#{filename}+", 'wb') do |f|
-        if options[:compress]
-          # Run contents through `Zlib`
-          gz = Zlib::GzipWriter.new(f, Zlib::BEST_COMPRESSION)
-          gz.mtime = mtime.to_i
-          gz.write to_s
-          gz.close
-        else
-          # Write out as is
-          f.write to_s
-          f.close
-        end
+      if version && version != ""
+        DigestUtils.hexdigest(version + digest)
+      else
+        DigestUtils.pack_hexdigest(digest)
       end
+    end
+
+    # Public: Returns String base64 digest of source.
+    def base64digest
+      DigestUtils.pack_base64digest(digest)
+    end
+
+    # Public: A "named information" URL for subresource integrity.
+    def integrity
+      DigestUtils.integrity_uri(digest)
+    end
+
+    # Public: Add enumerator to allow `Asset` instances to be used as Rack
+    # compatible body objects.
+    #
+    # block
+    #   part - String body chunk
+    #
+    # Returns nothing.
+    def each
+      yield to_s
+    end
 
-      # Atomic write
-      FileUtils.mv("#{filename}+", filename)
+    # Deprecated: Save asset to disk.
+    #
+    # filename - String target
+    #
+    # Returns nothing.
+    def write_to(filename)
+      FileUtils.mkdir_p File.dirname(filename)
 
-      # Set mtime correctly
-      File.utime(mtime, mtime, filename)
+      PathUtils.atomic_write(filename) do |f|
+        f.write source
+      end
 
       nil
-    ensure
-      # Ensure tmp file gets cleaned up
-      FileUtils.rm("#{filename}+") if File.exist?("#{filename}+")
     end
 
-    # Pretty inspect
+    # Public: Pretty inspect
+    #
+    # Returns String.
     def inspect
-      "#<#{self.class}:0x#{object_id.to_s(16)} " +
-        "pathname=#{pathname.to_s.inspect}, " +
-        "mtime=#{mtime.inspect}, " +
-        "digest=#{digest.inspect}" +
-        ">"
+      "#<#{self.class}:#{object_id.to_s(16)} #{uri.inspect}>"
     end
 
+    # Public: Implements Object#hash so Assets can be used as a Hash key or
+    # in a Set.
+    #
+    # Returns Integer hash of the id.
     def hash
-      digest.hash
+      id.hash
     end
 
-    # Assets are equal if they share the same path, mtime and digest.
+    # Public: Compare assets.
+    #
+    # Assets are equal if they share the same path and digest.
+    #
+    # Returns true or false.
     def eql?(other)
-      other.class == self.class &&
-        other.logical_path == self.logical_path &&
-        other.mtime.to_i == self.mtime.to_i &&
-        other.digest == self.digest
+      self.class == other.class && self.id == other.id
     end
     alias_method :==, :eql?
-
-    protected
-      # Internal: String paths that are marked as dependencies after processing.
-      #
-      # Default to an empty `Array`.
-      def dependency_paths
-        @dependency_paths ||= []
-      end
-
-      # Internal: `ProccessedAsset`s that are required after processing.
-      #
-      # Default to an empty `Array`.
-      def required_assets
-        @required_assets ||= []
-      end
-
-      # Get pathname with its root stripped.
-      def relative_pathname
-        @relative_pathname ||= Pathname.new(relativize_root_path(pathname))
-      end
-
-      # Replace `$root` placeholder with actual environment root.
-      def expand_root_path(path)
-        path.to_s.sub(/^\$root/, @root)
-      end
-
-      # Replace actual environment root with `$root` placeholder.
-      def relativize_root_path(path)
-        path.to_s.sub(/^#{Regexp.escape(@root)}/, '$root')
-      end
-
-      # Check if dependency is fresh.
-      #
-      # `dep` is a `Hash` with `path`, `mtime` and `hexdigest` keys.
-      #
-      # A `Hash` is used rather than other `Asset` object because we
-      # want to test non-asset files and directories.
-      def dependency_fresh?(environment, dep)
-        path, mtime, hexdigest = dep.pathname.to_s, dep.mtime, dep.digest
-
-        stat = environment.stat(path)
-
-        # If path no longer exists, its definitely stale.
-        if stat.nil?
-          return false
-        end
-
-        # Compare dependency mime to the actual mtime. If the
-        # dependency mtime is newer than the actual mtime, the file
-        # hasn't changed since we created this `Asset` instance.
-        #
-        # However, if the mtime is newer it doesn't mean the asset is
-        # stale. Many deployment environments may recopy or recheckout
-        # assets on each deploy. In this case the mtime would be the
-        # time of deploy rather than modified time.
-        if mtime >= stat.mtime
-          return true
-        end
-
-        digest = environment.file_digest(path)
-
-        # If the mtime is newer, do a full digest comparsion. Return
-        # fresh if the digests match.
-        if hexdigest == digest.hexdigest
-          return true
-        end
-
-        # Otherwise, its stale.
-        false
-      end
   end
 end

data/lib/sprockets/autoload/babel.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require 'babel/transpiler'
+
+module Sprockets
+  module Autoload
+    Babel = ::Babel
+  end
+end

data/lib/sprockets/autoload/closure.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require 'closure-compiler'
+
+module Sprockets
+  module Autoload
+    Closure = ::Closure
+  end
+end

data/lib/sprockets/autoload/coffee_script.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require 'coffee_script'
+
+module Sprockets
+  module Autoload
+    CoffeeScript = ::CoffeeScript
+  end
+end

data/lib/sprockets/autoload/eco.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require 'eco'
+
+module Sprockets
+  module Autoload
+    Eco = ::Eco
+  end
+end