sprockets 2.3.2 → 3.0.0

data/bin/sprockets

@@ -40,6 +40,14 @@ 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
 

data/lib/rake/sprocketstask.rb

@@ -37,6 +37,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"
@@ -79,6 +98,7 @@ 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
@@ -117,24 +137,16 @@ module Rake
     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/asset.rb

@@ -1,261 +1,199 @@
-require 'time'
-require 'set'
+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)
-      @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: Intialize 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(environment, attributes = {})
+      @environment  = environment
+      @attributes   = attributes
+      @content_type = attributes[:content_type]
+      @filename     = attributes[:filename]
+      @id           = attributes[:id]
+      @integrity    = attributes[:integrity]
+      @load_path    = attributes[:load_path]
+      @logical_path = attributes[:logical_path]
+      @metadata     = attributes[:metadata]
+      @mtime        = attributes[:mtime]
+      @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 proccessor 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 publically 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}" }
+      logical_path.sub(/\.(\w+)$/) { |ext| "-#{etag}#{ext}" }
     end
 
-    # Return an `Array` of `Asset` files that are declared dependencies.
-    def dependencies
-      []
-    end
+    # Public: Returns String MIME type of asset. Returns nil if type is unknown.
+    attr_reader :content_type
 
-    # Expand asset into an `Array` of parts.
+    # 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: Get all internally required assets that were concated into this
+    # asset.
+    #
+    # Returns Array of String asset URIs.
+    def included
+      metadata[:included]
+    end
+
+    # 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.
+    # Public: Returns String hexdigest of source.
+    def hexdigest
+      DigestUtils.pack_hexdigest(metadata[:digest])
+    end
+
+    # Deprecated: Returns String hexdigest of source.
     #
-    # Subclass must override `fresh?` or `stale?`.
-    def stale?(environment)
-      !fresh?(environment)
+    # In 4.x this will be changed to return a raw Digest byte String.
+    alias_method :digest, :hexdigest
+
+    # Pubic: ETag String of Asset.
+    alias_method :etag, :hexdigest
+
+    # Public: Returns String base64 digest of source.
+    def base64digest
+      DigestUtils.pack_base64digest(metadata[:digest])
     end
 
-    # Save asset to disk.
-    def write_to(filename, options = {})
-      # Gzip contents if filename has '.gz'
-      options[:compress] ||= File.extname(filename) == '.gz'
+    # Public: A "named information" URL for subresource integrity.
+    attr_reader :integrity
+
+    # 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
 
+    # Deprecated: Save asset to disk.
+    #
+    # filename - String target
+    #
+    # Returns nothing.
+    def write_to(filename)
       FileUtils.mkdir_p File.dirname(filename)
 
-      File.open("#{filename}+", 'wb') do |f|
-        if options[:compress]
-          # Run contents through `Zlib`
-          gz = Zlib::GzipWriter.new(f, Zlib::BEST_COMPRESSION)
-          gz.write to_s
-          gz.close
-        else
-          # Write out as is
-          f.write to_s
-          f.close
-        end
+      PathUtils.atomic_write(filename) do |f|
+        f.write source
       end
 
-      # Atomic write
-      FileUtils.mv("#{filename}+", filename)
-
       # Set mtime correctly
       File.utime(mtime, mtime, filename)
 
       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/closure.rb

@@ -0,0 +1,7 @@
+require 'closure-compiler'
+
+module Sprockets
+  module Autoload
+    Closure = ::Closure
+  end
+end

data/lib/sprockets/autoload/coffee_script.rb

@@ -0,0 +1,7 @@
+require 'coffee_script'
+
+module Sprockets
+  module Autoload
+    CoffeeScript = ::CoffeeScript
+  end
+end

data/lib/sprockets/autoload/eco.rb

@@ -0,0 +1,7 @@
+require 'eco'
+
+module Sprockets
+  module Autoload
+    Eco = ::Eco
+  end
+end

data/lib/sprockets/autoload/ejs.rb

@@ -0,0 +1,7 @@
+require 'ejs'
+
+module Sprockets
+  module Autoload
+    EJS = ::EJS
+  end
+end

data/lib/sprockets/autoload/sass.rb

@@ -0,0 +1,7 @@
+require 'sass'
+
+module Sprockets
+  module Autoload
+    Sass = ::Sass
+  end
+end

data/lib/sprockets/autoload/uglifier.rb

@@ -0,0 +1,7 @@
+require 'uglifier'
+
+module Sprockets
+  module Autoload
+    Uglifier = ::Uglifier
+  end
+end

data/lib/sprockets/autoload/yui.rb

@@ -0,0 +1,7 @@
+require 'yui/compressor'
+
+module Sprockets
+  module Autoload
+    YUI = ::YUI
+  end
+end

data/lib/sprockets/autoload.rb

@@ -0,0 +1,11 @@
+module Sprockets
+  module Autoload
+    autoload :Closure, 'sprockets/autoload/closure'
+    autoload :CoffeeScript, 'sprockets/autoload/coffee_script'
+    autoload :Eco, 'sprockets/autoload/eco'
+    autoload :EJS, 'sprockets/autoload/ejs'
+    autoload :Sass, 'sprockets/autoload/sass'
+    autoload :Uglifier, 'sprockets/autoload/uglifier'
+    autoload :YUI, 'sprockets/autoload/yui'
+  end
+end