sprockets 2.12.5 → 3.0.0.beta.1

data/lib/sprockets/asset.rb

@@ -1,269 +1,230 @@
-require 'time'
-require 'set'
+require 'fileutils'
+require 'pathname'
 
 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
+    # 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
+      attributes.each do |name, value|
+        instance_variable_set("@#{name}", value)
       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)
-      # drop precision to 1 second, same pattern followed elsewhere
-      @mtime        = Time.at(environment.stat(pathname).mtime.to_i)
-      @length       = environment.stat(pathname).size
-      @digest       = environment.file_digest(pathname).hexdigest
+    # 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']
-        @mtime = Time.at(mtime)
-      end
+    # Public: Returns String path of asset.
+    attr_reader :filename
 
-      if length = coder['length']
-        # Convert length to an `Integer`
-        @length = Integer(length)
-      end
+    # Deprecated: Use #filename instead.
+    #
+    # Returns Pathname.
+    def pathname
+      @pathname ||= Pathname.new(filename)
     end
 
-    # 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.to_i
-      coder['length']       = length
-      coder['digest']       = digest
-    end
+    # Internal: Unique asset object ID.
+    #
+    # Returns String SHA1 String.
+    attr_reader :id
+
+    # 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}" }
     end
 
-    # Return an `Array` of `Asset` files that are declared dependencies.
-    def dependencies
-      []
+    # 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.
+    #
+    # All linked assets should be compiled anytime this asset is.
+    #
+    # Returns Set of String asset URIs.
+    def links
+      metadata[:links] || Set.new
     end
 
-    # Expand asset into an `Array` of parts.
+    # Public: Get all internally required assets that were concated into this
+    # asset.
+    #
+    # Returns Array of String asset URIs.
+    def included
+      metadata[:included]
+    end
+
+    # Deprecated: Expand asset into an `Array` of parts.
     #
     # Appending all of an assets body parts together should give you
     # the asset's contents as a whole.
     #
     # This allows you to link to individual files for debugging
     # purposes.
+    #
+    # Use Asset#included instead. Keeping a full copy of the bundle's processed
+    # assets in memory (and in cache) is expensive and redundant. The common use
+    # case is to relink to the assets anyway.
+    #
+    # Returns Array of Assets.
     def to_a
-      [self]
+      if metadata[:included]
+        metadata[:included].map { |uri| @environment.find_asset_by_uri(uri) }
+      else
+        [self]
+      end
     end
 
-    # `body` is aliased to source by default if it can't have any dependencies.
-    def body
-      source
+    # Deprecated: Get all required Assets.
+    #
+    # See Asset#to_a
+    #
+    # Returns Array of Assets.
+    def dependencies
+      to_a.reject { |a| a.filename.eql?(self.filename) }
+    end
+
+    # Public: Return `String` of concatenated source.
+    #
+    # Returns String.
+    def source
+      if defined? @source
+        @source
+      else
+        # File is read everytime to avoid memory bloat of large binary files
+        File.open(filename, 'rb') { |f| f.read }
+      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: HTTP encoding for Asset, "deflate", "gzip", etc.
+    #
+    # Note: This is not the Ruby Encoding of the source. See Asset#charset.
+    #
+    # Returns a String or nil if encoding is "identity".
+    def encoding
+      metadata[:encoding]
     end
 
-    # Checks if Asset is fresh by comparing the actual mtime and
-    # digest to the inmemory model.
+    # Public: Get charset of source.
     #
-    # Used to test if cached models need to be rebuilt.
-    def fresh?(environment)
-      # Check current mtime and digest
-      dependency_fresh?(environment, self)
-    end
+    # Returns a String charset name or nil if binary.
+    attr_reader :charset
 
-    # Checks if Asset is stale by comparing the actual mtime and
-    # digest to the inmemory model.
+    # Public: Returns Integer length of source.
+    attr_reader :length
+    alias_method :bytesize, :length
+
+    # Deprecated: Returns Time of the last time the source was modified.
+    #
+    # Time resolution is normalized to the nearest second.
     #
-    # Subclass must override `fresh?` or `stale?`.
-    def stale?(environment)
-      !fresh?(environment)
+    # Returns Time.
+    def mtime
+      Time.at(@mtime)
     end
 
-    # Save asset to disk.
-    def write_to(filename, options = {})
-      # Gzip contents if filename has '.gz'
-      unless options.key?(:compress)
-        options[:compress] = File.extname(filename) == '.gz' && File.extname(logical_path) != '.gz'
-      end
+    # Public: Returns String hexdigest of source.
+    attr_reader :digest
 
+    # Pubic: ETag String of Asset.
+    alias_method :etag, :digest
+
+    # 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
+
+    # Public: 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.mtime = mtime.to_i
-          gz.write to_s
-          gz.close
-        else
-          # Write out as is
-          f.write to_s
-        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}, " +
+      "#<#{self.class}:#{id} " +
+        "filename=#{filename.inspect}, " +
         "digest=#{digest.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 mtime 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.
-        #
-        # Note: to_i is used in eql? and write_to we assume fidelity of 1 second
-        #  if people save files more frequently than 1 second sprockets may
-        #  not pick it up, by design
-        if mtime.to_i >= stat.mtime.to_i
-          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/asset_uri.rb

@@ -0,0 +1,64 @@
+require 'sprockets/errors'
+require 'uri'
+
+module Sprockets
+  module AssetURI
+    # Internal: Parse Asset URI.
+    #
+    # Examples
+    #
+    #   parse("file:///tmp/js/application.coffee?type=application/javascript")
+    #   # => "/tmp/js/application.coffee", {type: "application/javascript"}
+    #
+    # str - String asset URI
+    #
+    # Returns String path and Hash of symbolized parameters.
+    def self.parse(str)
+      uri = URI(str)
+
+      unless uri.scheme == 'file'
+        raise URI::InvalidURIError, "expected file:// scheme: #{str}"
+      end
+
+      path = URI::Generic::DEFAULT_PARSER.unescape(uri.path)
+      path.force_encoding(Encoding::UTF_8)
+
+      params = uri.query.to_s.split('&').reduce({}) do |h, p|
+        k, v = p.split('=', 2)
+        h.merge(k.to_sym => v || true)
+      end
+
+      return path, params
+    end
+
+    # Internal: Build Asset URI.
+    #
+    # Examples
+    #
+    #   build("/tmp/js/application.coffee", type: "application/javascript")
+    #   # => "file:///tmp/js/application.coffee?type=application/javascript"
+    #
+    # path   - String file path
+    # params - Hash of optional parameters
+    #
+    # Returns String URI.
+    def self.build(path, params = {})
+      query = []
+      params.each do |key, value|
+        case value
+        when String
+          query << "#{key}=#{value}"
+        when TrueClass
+          query << "#{key}"
+        when FalseClass, NilClass
+        else
+          raise TypeError, "unexpected type: #{value.class}"
+        end
+      end
+
+      uri = "file://#{URI::Generic::DEFAULT_PARSER.escape(path)}"
+      uri << "?#{query.join('&')}" if query.any?
+      uri
+    end
+  end
+end