sprockets 2.6.0 → 4.2.2

data/lib/sprockets/context.rb

@@ -1,15 +1,13 @@
-require 'base64'
+# frozen_string_literal: true
 require 'rack/utils'
-require 'sprockets/errors'
-require 'sprockets/utils'
-require 'pathname'
 require 'set'
+require 'sprockets/errors'
+require 'delegate'
 
 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.
+  # 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,102 +19,118 @@ 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
-
-      @_required_paths    = []
-      @_stubbed_assets    = Set.new
-      @_dependency_paths  = Set.new
-      @_dependency_assets = Set.new([pathname.to_s])
+    # Internal: Proxy for ENV that keeps track of the environment variables used
+    class ENVProxy < SimpleDelegator
+      def initialize(context)
+        @context = context
+        super(ENV)
+      end
+
+      def [](key)
+        @context.depend_on_env(key)
+        super
+      end
+
+      def fetch(key, *)
+        @context.depend_on_env(key)
+        super
+      end
+    end
+
+    attr_reader :environment, :filename
+
+    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)
+      @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
+
+    def metadata
+      { required: @required,
+        stubbed: @stubbed,
+        links: @links,
+        dependencies: @dependencies }
+    end
+
+    def env_proxy
+      ENVProxy.new(self)
     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?
-        if environment.stat(pathname)
-          pathname
-        else
-          raise FileNotFound, "couldn't find file '#{pathname}'"
-        end
-
-      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
-
-        raise FileNotFound, "couldn't find file '#{path}'"
-      else
-        environment.resolve(path, {:base_path => self.pathname.dirname}.merge(options), &block)
-      end
+    # path   - String logical or absolute path
+    # accept - String content accept type
+    #
+    # Returns an Asset URI String.
+    def resolve(path, **kargs)
+      kargs[:base_path] = @dirname
+      uri, deps = environment.resolve!(path, **kargs)
+      @dependencies.merge(deps)
+      uri
+    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
     # including it.
     #
     # This is used for caching purposes. Any changes made to
-    # the dependency file with invalidate the cache of the
+    # the dependency file will invalidate the cache of the
     # source file.
     def depend_on(path)
-      @_dependency_paths << resolve(path).to_s
+      if environment.absolute_path?(path) && environment.stat(path)
+        @dependencies << environment.build_file_digest_uri(path)
+      else
+        resolve(path)
+      end
       nil
     end
 
@@ -125,12 +139,19 @@ module Sprockets
     #
     # This is used for caching purposes. Any changes that would
     # invalidate the dependency asset will invalidate the source
-    # file. Unlike `depend_on`, this will include recursively include
+    # file. Unlike `depend_on`, this will recursively include
     # the target asset's dependencies.
     def depend_on_asset(path)
-      filename = resolve(path).to_s
-      @_dependency_assets << filename
-      nil
+      load(resolve(path))
+    end
+
+    # `depend_on_env` allows you to state a dependency on an environment
+    # variable.
+    #
+    # This is used for caching purposes. Any changes in the value of the
+    # environment variable will invalidate the cache of the source file.
+    def depend_on_env(key)
+      @dependencies << "env:#{key}"
     end
 
     # `require_asset` declares `path` as a dependency of the file. The
@@ -143,9 +164,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)
       nil
     end
 
@@ -153,60 +172,25 @@ 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)
       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.
-    #
-    # This allows you to capture the result of an asset and include it
-    # directly in another.
-    #
-    #     <%= evaluate "bar.js" %>
+    # `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.
     #
-    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
-    # asset at the specified path, and marks that path as a dependency
-    # of the current file.
+    # Returns a `data:` URI with the contents of the asset at the specified
+    # path, and marks that path as a dependency of the current file.
+    #
+    # Uses URI encoding for SVG files, base64 encoding for all the other files.
     #
     # Use `asset_data_uri` from ERB with CSS or JavaScript assets:
     #
@@ -215,17 +199,19 @@ 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)
+      if asset.content_type == 'image/svg+xml'
+        svg_asset_data_uri(asset)
+      else
+        base64_asset_data_uri(asset)
+      end
     end
 
     # 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
+    # basic implementation may be provided with different methods that
     # are required to be overridden.
     def asset_path(path, options = {})
       message = <<-EOS
@@ -243,47 +229,77 @@ Extend your environment context with a custom method.
 
     # Expand logical image asset path.
     def image_path(path)
-      asset_path(path, :type => :image)
+      asset_path(path, type: :image)
     end
 
     # Expand logical video asset path.
     def video_path(path)
-      asset_path(path, :type => :video)
+      asset_path(path, type: :video)
     end
 
     # Expand logical audio asset path.
     def audio_path(path)
-      asset_path(path, :type => :audio)
+      asset_path(path, type: :audio)
     end
 
     # Expand logical font asset path.
     def font_path(path)
-      asset_path(path, :type => :font)
+      asset_path(path, type: :font)
     end
 
     # Expand logical javascript asset path.
     def javascript_path(path)
-      asset_path(path, :type => :javascript)
+      asset_path(path, type: :javascript)
     end
 
     # Expand logical stylesheet asset path.
     def stylesheet_path(path)
-      asset_path(path, :type => :stylesheet)
+      asset_path(path, type: :stylesheet)
     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__
+    protected
 
-        exception.extend(Sprockets::EngineError)
-        exception.sprockets_annotation = "  (in #{location})"
-      end
+    # Returns a URI-encoded data URI (always "-quoted).
+    def svg_asset_data_uri(asset)
+      svg = asset.source.dup
+      optimize_svg_for_uri_escaping!(svg)
+      data = Rack::Utils.escape(svg)
+      optimize_quoted_uri_escapes!(data)
+      "\"data:#{asset.content_type};charset=utf-8,#{data}\""
+    end
 
-      def logger
-        environment.logger
-      end
+    # Returns a Base64-encoded data URI.
+    def base64_asset_data_uri(asset)
+      data = Rack::Utils.escape(EncodingUtils.base64(asset.source))
+      "data:#{asset.content_type};base64,#{data}"
+    end
+
+    # Optimizes an SVG for being URI-escaped.
+    #
+    # This method only performs these basic but crucial optimizations:
+    # * Replaces " with ', because ' does not need escaping.
+    # * Removes comments, meta, doctype, and newlines.
+    # * Collapses whitespace.
+    def optimize_svg_for_uri_escaping!(svg)
+      # Remove comments, xml meta, and doctype
+      svg.gsub!(/<!--.*?-->|<\?.*?\?>|<!.*?>/m, '')
+      # Replace consecutive whitespace and newlines with a space
+      svg.gsub!(/\s+/, ' ')
+      # Collapse inter-tag whitespace
+      svg.gsub!('> <', '><')
+      # Replace " with '
+      svg.gsub!(/([\w:])="(.*?)"/, "\\1='\\2'")
+      svg.strip!
+    end
+
+    # Un-escapes characters in the given URI-escaped string that do not need
+    # escaping in "-quoted data URIs.
+    def optimize_quoted_uri_escapes!(escaped)
+      escaped.gsub!('%3D', '=')
+      escaped.gsub!('%3A', ':')
+      escaped.gsub!('%2F', '/')
+      escaped.gsub!('%27', "'")
+      escaped.tr!('+', ' ')
+    end
   end
 end

data/lib/sprockets/dependencies.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+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 inherited 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 dependency URIs.
+    #
+    # Returns resolved Object.
+    def resolve_dependency(str)
+      # Optimize for the most common scheme to
+      # save 22k allocations on an average Spree app.
+      scheme = if str.start_with?('file-digest:'.freeze)
+        'file-digest'.freeze
+      else
+        str[/([^:]+)/, 1]
+      end
+
+      if resolver = config[:dependency_resolvers][scheme]
+        resolver.call(self, str)
+      else
+        nil
+      end
+    end
+  end
+end