sprockets 2.3.2 → 3.0.0

data/lib/sprockets/context.rb

@@ -1,15 +1,13 @@
-require 'base64'
-require 'rack/utils'
-require 'sprockets/errors'
-require 'sprockets/utils'
 require 'pathname'
+require 'rack/utils'
 require 'set'
+require 'sprockets/errors'
 
 module Sprockets
-  # `Context` provides helper methods to all `Tilt` processors. They
-  # are typically accessed by ERB templates. You can mix in custom
-  # helpers by injecting them into `Environment#context_class`. Do not
-  # mix them into `Context` directly.
+  # Deprecated: `Context` provides helper methods to all processors.
+  # They are typically accessed by ERB templates. You can mix in custom helpers
+  # by injecting them into `Environment#context_class`. Do not mix them into
+  # `Context` directly.
   #
   #     environment.context_class.class_eval do
   #       include MyHelper
@@ -21,88 +19,86 @@ module Sprockets
   # The `Context` also collects dependencies declared by
   # assets. See `DirectiveProcessor` for an example of this.
   class Context
-    attr_reader :environment, :pathname
-    attr_reader :_required_paths, :_stubbed_assets
-    attr_reader :_dependency_paths, :_dependency_assets
-    attr_writer :__LINE__
-
-    def initialize(environment, logical_path, pathname)
-      @environment  = environment
-      @logical_path = logical_path
-      @pathname     = pathname
-      @__LINE__     = nil
+    attr_reader :environment, :filename, :pathname
+
+    # Deprecated
+    attr_accessor :__LINE__
+
+    def initialize(input)
+      @environment  = input[:environment]
+      @metadata     = input[:metadata]
+      @load_path    = input[:load_path]
+      @logical_path = input[:name]
+      @filename     = input[:filename]
+      @dirname      = File.dirname(@filename)
+      @pathname     = Pathname.new(@filename)
+      @content_type = input[:content_type]
+
+      @required     = Set.new(@metadata[:required])
+      @stubbed      = Set.new(@metadata[:stubbed])
+      @links        = Set.new(@metadata[:links])
+      @dependencies = Set.new(input[:metadata][:dependencies])
+    end
 
-      @_required_paths    = []
-      @_stubbed_assets    = Set.new
-      @_dependency_paths  = Set.new
-      @_dependency_assets = Set.new([pathname.to_s])
+    def metadata
+      { required: @required,
+        stubbed: @stubbed,
+        links: @links,
+        dependencies: @dependencies }
     end
 
     # Returns the environment path that contains the file.
     #
     # If `app/javascripts` and `app/stylesheets` are in your path, and
-    # current file is `app/javascripts/foo/bar.js`, `root_path` would
+    # current file is `app/javascripts/foo/bar.js`, `load_path` would
     # return `app/javascripts`.
-    def root_path
-      environment.paths.detect { |path| pathname.to_s[path] }
-    end
+    attr_reader :load_path
+    alias_method :root_path, :load_path
 
     # Returns logical path without any file extensions.
     #
     #     'app/javascripts/application.js'
     #     # => 'application'
     #
-    def logical_path
-      @logical_path.chomp(File.extname(@logical_path))
-    end
+    attr_reader :logical_path
 
     # Returns content type of file
     #
     #     'application/javascript'
     #     'text/css'
     #
-    def content_type
-      environment.content_type_of(pathname)
-    end
+    attr_reader :content_type
 
-    # Given a logical path, `resolve` will find and return the fully
-    # expanded path. Relative paths will also be resolved. An optional
-    # `:content_type` restriction can be supplied to restrict the
-    # search.
+    # Public: Given a logical path, `resolve` will find and return an Asset URI.
+    # Relative paths will also be resolved. An accept type maybe given to
+    # restrict the search.
     #
     #     resolve("foo.js")
-    #     # => "/path/to/app/javascripts/foo.js"
+    #     # => "file:///path/to/app/javascripts/foo.js?type=application/javascript"
     #
     #     resolve("./bar.js")
-    #     # => "/path/to/app/javascripts/bar.js"
+    #     # => "file:///path/to/app/javascripts/bar.js?type=application/javascript"
     #
-    def resolve(path, options = {}, &block)
-      pathname   = Pathname.new(path)
-      attributes = environment.attributes_for(pathname)
-
-      if pathname.absolute?
-        pathname
-
-      elsif content_type = options[:content_type]
-        content_type = self.content_type if content_type == :self
-
-        if attributes.format_extension
-          if content_type != attributes.content_type
-            raise ContentTypeMismatch, "#{path} is " +
-              "'#{attributes.content_type}', not '#{content_type}'"
-          end
-        end
-
-        resolve(path) do |candidate|
-          if self.content_type == environment.content_type_of(candidate)
-            return candidate
-          end
-        end
+    # path - String logical or absolute path
+    # options
+    #   accept - String content accept type
+    #
+    # Returns an Asset URI String.
+    def resolve(path, options = {})
+      uri, deps = environment.resolve!(path, options.merge(base_path: @dirname))
+      @dependencies.merge(deps)
+      uri
+    end
 
-        raise FileNotFound, "couldn't find file '#{path}'"
-      else
-        environment.resolve(path, {:base_path => self.pathname.dirname}.merge(options), &block)
-      end
+    # Public: Load Asset by AssetURI and track it as a dependency.
+    #
+    # uri - AssetURI
+    #
+    # Returns Asset.
+    def load(uri)
+      asset = environment.load(uri)
+      @dependencies.merge(asset.metadata[:dependencies])
+      asset
     end
 
     # `depend_on` allows you to state a dependency on a file without
@@ -112,7 +108,11 @@ module Sprockets
     # the dependency file with invalidate the cache of the
     # source file.
     def depend_on(path)
-      @_dependency_paths << resolve(path).to_s
+      if environment.absolute_path?(path) && environment.directory?(path)
+        @dependencies << environment.build_file_digest_uri(path)
+      else
+        resolve(path, compat: false)
+      end
       nil
     end
 
@@ -124,9 +124,7 @@ module Sprockets
     # file. Unlike `depend_on`, this will include recursively include
     # the target asset's dependencies.
     def depend_on_asset(path)
-      filename = resolve(path).to_s
-      @_dependency_assets << filename
-      nil
+      load(resolve(path, compat: false))
     end
 
     # `require_asset` declares `path` as a dependency of the file. The
@@ -139,9 +137,7 @@ module Sprockets
     #     <%= require_asset "#{framework}.js" %>
     #
     def require_asset(path)
-      pathname = resolve(path, :content_type => :self)
-      depend_on_asset(pathname)
-      @_required_paths << pathname.to_s
+      @required << resolve(path, accept: @content_type, pipeline: :self, compat: false)
       nil
     end
 
@@ -149,55 +145,19 @@ module Sprockets
     # `path` must be an asset which may or may not already be included
     # in the bundle.
     def stub_asset(path)
-      @_stubbed_assets << resolve(path, :content_type => :self).to_s
+      @stubbed << resolve(path, accept: @content_type, pipeline: :self, compat: false)
       nil
     end
 
-    # Tests if target path is able to be safely required into the
-    # current concatenation.
-    def asset_requirable?(path)
-      pathname = resolve(path)
-      content_type = environment.content_type_of(pathname)
-      stat = environment.stat(path)
-      return false unless stat && stat.file?
-      self.content_type.nil? || self.content_type == content_type
-    end
-
-    # Reads `path` and runs processors on the file.
+    # `link_asset` declares an external dependency on an asset without directly
+    # including it. The target asset is returned from this function making it
+    # easy to construct a link to it.
     #
-    # This allows you to capture the result of an asset and include it
-    # directly in another.
-    #
-    #     <%= evaluate "bar.js" %>
-    #
-    def evaluate(path, options = {})
-      pathname   = resolve(path)
-      attributes = environment.attributes_for(pathname)
-      processors = options[:processors] || attributes.processors
-
-      if options[:data]
-        result = options[:data]
-      else
-        if environment.respond_to?(:default_external_encoding)
-          mime_type = environment.mime_types(pathname.extname)
-          encoding  = environment.encoding_for_mime_type(mime_type)
-          result    = Sprockets::Utils.read_unicode(pathname, encoding)
-        else
-          result = Sprockets::Utils.read_unicode(pathname)
-        end
-      end
-
-      processors.each do |processor|
-        begin
-          template = processor.new(pathname.to_s) { result }
-          result = template.render(self, {})
-        rescue Exception => e
-          annotate_exception! e
-          raise
-        end
-      end
-
-      result
+    # Returns an Asset or nil.
+    def link_asset(path)
+      asset = depend_on_asset(path)
+      @links << asset.uri
+      asset
     end
 
     # Returns a Base64-encoded `data:` URI with the contents of the
@@ -211,25 +171,59 @@ module Sprockets
     #     $('<img>').attr('src', '<%= asset_data_uri 'avatar.jpg' %>')
     #
     def asset_data_uri(path)
-      depend_on_asset(path)
-      asset  = environment.find_asset(path)
-      base64 = Base64.encode64(asset.to_s).gsub(/\s+/, "")
-      "data:#{asset.content_type};base64,#{Rack::Utils.escape(base64)}"
+      asset = depend_on_asset(path)
+      data = EncodingUtils.base64(asset.source)
+      "data:#{asset.content_type};base64,#{Rack::Utils.escape(data)}"
     end
 
-    private
-      # Annotates exception backtrace with the original template that
-      # the exception was raised in.
-      def annotate_exception!(exception)
-        location = pathname.to_s
-        location << ":#{@__LINE__}" if @__LINE__
+    # Expands logical path to full url to asset.
+    #
+    # NOTE: This helper is currently not implemented and should be
+    # customized by the application. Though, in the future, some
+    # basics implemention may be provided with different methods that
+    # are required to be overridden.
+    def asset_path(path, options = {})
+      message = <<-EOS
+Custom asset_path helper is not implemented
 
-        exception.extend(Sprockets::EngineError)
-        exception.sprockets_annotation = "  (in #{location})"
-      end
+Extend your environment context with a custom method.
 
-      def logger
-        environment.logger
+    environment.context_class.class_eval do
+      def asset_path(path, options = {})
       end
+    end
+      EOS
+      raise NotImplementedError, message
+    end
+
+    # Expand logical image asset path.
+    def image_path(path)
+      asset_path(path, type: :image)
+    end
+
+    # Expand logical video asset path.
+    def video_path(path)
+      asset_path(path, type: :video)
+    end
+
+    # Expand logical audio asset path.
+    def audio_path(path)
+      asset_path(path, type: :audio)
+    end
+
+    # Expand logical font asset path.
+    def font_path(path)
+      asset_path(path, type: :font)
+    end
+
+    # Expand logical javascript asset path.
+    def javascript_path(path)
+      asset_path(path, type: :javascript)
+    end
+
+    # Expand logical stylesheet asset path.
+    def stylesheet_path(path)
+      asset_path(path, type: :stylesheet)
+    end
   end
 end

data/lib/sprockets/dependencies.rb

@@ -0,0 +1,73 @@
+require 'sprockets/digest_utils'
+require 'sprockets/path_digest_utils'
+require 'sprockets/uri_utils'
+
+module Sprockets
+  # `Dependencies` is an internal mixin whose public methods are exposed on the
+  # `Environment` and `CachedEnvironment` classes.
+  module Dependencies
+    include DigestUtils, PathDigestUtils, URIUtils
+
+    # Public: Mapping dependency schemes to resolver functions.
+    #
+    # key   - String scheme
+    # value - Proc.call(Environment, String)
+    #
+    # Returns Hash.
+    def dependency_resolvers
+      config[:dependency_resolvers]
+    end
+
+    # Public: Default set of dependency URIs for assets.
+    #
+    # Returns Set of String URIs.
+    def dependencies
+      config[:dependencies]
+    end
+
+    # Public: Register new dependency URI resolver.
+    #
+    # scheme - String scheme
+    # block  -
+    #   environment - Environment
+    #   uri - String dependency URI
+    #
+    # Returns nothing.
+    def register_dependency_resolver(scheme, &block)
+      self.config = hash_reassoc(config, :dependency_resolvers) do |hash|
+        hash.merge(scheme => block)
+      end
+    end
+
+    # Public: Add environmental dependency inheirted by all assets.
+    #
+    # uri - String dependency URI
+    #
+    # Returns nothing.
+    def add_dependency(uri)
+      self.config = hash_reassoc(config, :dependencies) do |set|
+        set + Set.new([uri])
+      end
+    end
+    alias_method :depend_on, :add_dependency
+
+    # Internal: Resolve set of dependency URIs.
+    #
+    # Returns Array of resolved Objects.
+    def resolve_dependencies(uris)
+      uris.map { |uri| resolve_dependency(uri) }
+    end
+
+    # Internal: Resolve dependency URIs.
+    #
+    # Returns resolved Object.
+    def resolve_dependency(str)
+      scheme = str[/([^:]+)/, 1]
+      if resolver = config[:dependency_resolvers][scheme]
+        resolver.call(self, str)
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/sprockets/digest_utils.rb

@@ -0,0 +1,156 @@
+require 'digest/md5'
+require 'digest/sha1'
+require 'digest/sha2'
+require 'set'
+
+module Sprockets
+  # Internal: Hash functions and digest related utilities. Mixed into
+  # Environment.
+  module DigestUtils
+    extend self
+
+    # Internal: Default digest class.
+    #
+    # Returns a Digest::Base subclass.
+    def digest_class
+      Digest::SHA256
+    end
+
+    # Internal: Maps digest bytesize to the digest class.
+    DIGEST_SIZES = {
+      16 => Digest::MD5,
+      20 => Digest::SHA1,
+      32 => Digest::SHA256,
+      48 => Digest::SHA384,
+      64 => Digest::SHA512
+    }
+
+    # Internal: Detect digest class hash algorithm for digest bytes.
+    #
+    # While not elegant, all the supported digests have a unique bytesize.
+    #
+    # Returns Digest::Base or nil.
+    def detect_digest_class(bytes)
+      DIGEST_SIZES[bytes.bytesize]
+    end
+
+    # Internal: Generate a hexdigest for a nested JSON serializable object.
+    #
+    # This is used for generating cache keys, so its pretty important its
+    # wicked fast. Microbenchmarks away!
+    #
+    # obj - A JSON serializable object.
+    #
+    # Returns a String digest of the object.
+    def digest(obj)
+      digest = digest_class.new
+      queue  = [obj]
+
+      while queue.length > 0
+        obj = queue.shift
+        klass = obj.class
+
+        if klass == String
+          digest << obj
+        elsif klass == Symbol
+          digest << 'Symbol'
+          digest << obj.to_s
+        elsif klass == Fixnum
+          digest << 'Fixnum'
+          digest << obj.to_s
+        elsif klass == Bignum
+          digest << 'Bignum'
+          digest << obj.to_s
+        elsif klass == TrueClass
+          digest << 'TrueClass'
+        elsif klass == FalseClass
+          digest << 'FalseClass'
+        elsif klass == NilClass
+          digest << 'NilClass'
+        elsif klass == Array
+          digest << 'Array'
+          queue.concat(obj)
+        elsif klass == Hash
+          digest << 'Hash'
+          queue.concat(obj.sort)
+        elsif klass == Set
+          digest << 'Set'
+          queue.concat(obj.to_a)
+        elsif klass == Encoding
+          digest << 'Encoding'
+          digest << obj.name
+        else
+          raise TypeError, "couldn't digest #{klass}"
+        end
+      end
+
+      digest.digest
+    end
+
+    # Internal: Pack a binary digest to a hex encoded string.
+    #
+    # bin - String bytes
+    #
+    # Returns hex String.
+    def pack_hexdigest(bin)
+      bin.unpack('H*').first
+    end
+
+    # Internal: Pack a binary digest to a base64 encoded string.
+    #
+    # bin - String bytes
+    #
+    # Returns base64 String.
+    def pack_base64digest(bin)
+      [bin].pack('m0')
+    end
+
+    # Internal: Pack a binary digest to a urlsafe base64 encoded string.
+    #
+    # bin - String bytes
+    #
+    # Returns urlsafe base64 String.
+    def pack_urlsafe_base64digest(bin)
+      str = pack_base64digest(bin)
+      str.tr!('+/'.freeze, '-_'.freeze)
+      str.tr!('='.freeze, ''.freeze)
+      str
+    end
+
+    # Internal: Maps digest class to the named information hash algorithm name.
+    #
+    # http://www.iana.org/assignments/named-information/named-information.xhtml
+    NI_HASH_ALGORITHMS = {
+      Digest::SHA256 => 'sha-256'.freeze,
+      Digest::SHA384 => 'sha-384'.freeze,
+      Digest::SHA512 => 'sha-512'.freeze
+    }
+
+    # Internal: Generate a "named information" URI for use in the `integrity`
+    # attribute of an asset tag as per the subresource integrity specification.
+    #
+    # digest       - The String byte digest of the asset content.
+    # content_type - The content-type the asset will be served with. This *must*
+    #                be accurate if provided. Otherwise, subresource integrity
+    #                will block the loading of the asset.
+    #
+    # Returns a String or nil if hash algorithm is incompatible.
+    def integrity_uri(digest, content_type = nil)
+      case digest
+      when Digest::Base
+        digest_class = digest.class
+        digest = digest.digest
+      when String
+        digest_class = DIGEST_SIZES[digest.bytesize]
+      else
+        raise TypeError, "unknown digest: #{digest.inspect}"
+      end
+
+      if hash_name = NI_HASH_ALGORITHMS[digest_class]
+        uri = "ni:///#{hash_name};#{pack_urlsafe_base64digest(digest)}"
+        uri << "?ct=#{content_type}" if content_type
+        uri
+      end
+    end
+  end
+end