sprockets 2.11.3 → 3.7.2

data/lib/sprockets/coffee_script_template.rb

@@ -0,0 +1,17 @@
+require 'sprockets/coffee_script_processor'
+
+module Sprockets
+  # Deprecated
+  module CoffeeScriptTemplate
+    VERSION = CoffeeScriptProcessor::VERSION
+
+    def self.cache_key
+      CoffeeScriptProcessor.cache_key
+    end
+
+    def self.call(*args)
+      Deprecation.new.warn "CoffeeScriptTemplate is deprecated please use CoffeeScriptProcessor instead"
+      CoffeeScriptProcessor.call(*args)
+    end
+  end
+end

data/lib/sprockets/compressing.rb

@@ -1,37 +1,41 @@
+require 'sprockets/utils'
+
 module Sprockets
   # `Compressing` is an internal mixin whose public methods are exposed on
-  # the `Environment` and `Index` classes.
+  # the `Environment` and `CachedEnvironment` classes.
   module Compressing
+    include Utils
+
     def compressors
-      deep_copy_hash(@compressors)
+      config[:compressors]
     end
 
     def register_compressor(mime_type, sym, klass)
-      @compressors[mime_type][sym] = klass
+      self.config = hash_reassoc(config, :compressors, mime_type) do |compressors|
+        compressors[sym] = klass
+        compressors
+      end
     end
 
     # Return CSS compressor or nil if none is set
     def css_compressor
-      @css_compressor if defined? @css_compressor
+      if defined? @css_compressor
+        @css_compressor
+      end
     end
 
     # Assign a compressor to run on `text/css` assets.
     #
     # The compressor object must respond to `compress`.
     def css_compressor=(compressor)
-      unregister_bundle_processor 'text/css', css_compressor if css_compressor
+      unregister_bundle_processor 'text/css', @css_compressor if defined? @css_compressor
       @css_compressor = nil
       return unless compressor
 
       if compressor.is_a?(Symbol)
-        compressor = compressors['text/css'][compressor] || raise(Error, "unknown compressor: #{compressor}")
-      end
-
-      if compressor.respond_to?(:compress)
-        klass = Class.new(Processor) do
-          @name = "css_compressor"
-          @processor = proc { |context, data| compressor.compress(data) }
-        end
+        @css_compressor = klass = config[:compressors]['text/css'][compressor] || raise(Error, "unknown compressor: #{compressor}")
+      elsif compressor.respond_to?(:compress)
+        klass = LegacyProcProcessor.new(:css_compressor, proc { |context, data| compressor.compress(data) })
         @css_compressor = :css_compressor
       else
         @css_compressor = klass = compressor
@@ -42,26 +46,23 @@ module Sprockets
 
     # Return JS compressor or nil if none is set
     def js_compressor
-      @js_compressor if defined? @js_compressor
+      if defined? @js_compressor
+        @js_compressor
+      end
     end
 
     # Assign a compressor to run on `application/javascript` assets.
     #
     # The compressor object must respond to `compress`.
     def js_compressor=(compressor)
-      unregister_bundle_processor 'application/javascript', js_compressor if js_compressor
+      unregister_bundle_processor 'application/javascript', @js_compressor if defined? @js_compressor
       @js_compressor = nil
       return unless compressor
 
       if compressor.is_a?(Symbol)
-        compressor = compressors['application/javascript'][compressor] || raise(Error, "unknown compressor: #{compressor}")
-      end
-
-      if compressor.respond_to?(:compress)
-        klass = Class.new(Processor) do
-          @name = "js_compressor"
-          @processor = proc { |context, data| compressor.compress(data) }
-        end
+        @js_compressor = klass = config[:compressors]['application/javascript'][compressor] || raise(Error, "unknown compressor: #{compressor}")
+      elsif compressor.respond_to?(:compress)
+        klass = LegacyProcProcessor.new(:js_compressor, proc { |context, data| compressor.compress(data) })
         @js_compressor = :js_compressor
       else
         @js_compressor = klass = compressor
@@ -69,5 +70,25 @@ module Sprockets
 
       register_bundle_processor 'application/javascript', klass
     end
+
+    # Public: Checks if Gzip is enabled.
+    def gzip?
+      config[:gzip_enabled]
+    end
+
+    # Public: Checks if Gzip is disabled.
+    def skip_gzip?
+      !gzip?
+    end
+
+    # Public: Enable or disable the creation of Gzip files.
+    #
+    # Defaults to true.
+    #
+    #     environment.gzip = false
+    #
+    def gzip=(gzip)
+      self.config = config.merge(gzip_enabled: gzip).freeze
+    end
   end
 end

data/lib/sprockets/configuration.rb

@@ -0,0 +1,83 @@
+require 'sprockets/compressing'
+require 'sprockets/dependencies'
+require 'sprockets/engines'
+require 'sprockets/mime'
+require 'sprockets/paths'
+require 'sprockets/processing'
+require 'sprockets/transformers'
+require 'sprockets/utils'
+
+module Sprockets
+  module Configuration
+    include Paths, Mime, Engines, Transformers, Processing, Compressing, Dependencies, Utils
+
+    def initialize_configuration(parent)
+      @config = parent.config
+      @computed_config = parent.computed_config
+      @logger = parent.logger
+      @context_class = Class.new(parent.context_class)
+    end
+
+    attr_reader :config
+
+    attr_accessor :computed_config
+
+    def config=(config)
+      raise TypeError, "can't assign mutable config" unless config.frozen?
+      @config = config
+    end
+
+    # Get and set `Logger` instance.
+    attr_accessor :logger
+
+    # The `Environment#version` is a custom value used for manually
+    # expiring all asset caches.
+    #
+    # Sprockets is able to track most file and directory changes and
+    # will take care of expiring the cache for you. However, its
+    # impossible to know when any custom helpers change that you mix
+    # into the `Context`.
+    #
+    # It would be wise to increment this value anytime you make a
+    # configuration change to the `Environment` object.
+    def version
+      config[:version]
+    end
+
+    # Assign an environment version.
+    #
+    #     environment.version = '2.0'
+    #
+    def version=(version)
+      self.config = hash_reassoc(config, :version) { version.dup }
+    end
+
+    # Public: Returns a `Digest` implementation class.
+    #
+    # Defaults to `Digest::SHA256`.
+    def digest_class
+      config[:digest_class]
+    end
+
+    # Deprecated: Assign a `Digest` implementation class. This maybe any Ruby
+    # `Digest::` implementation such as `Digest::SHA256` or
+    # `Digest::MD5`.
+    #
+    #     environment.digest_class = Digest::MD5
+    #
+    def digest_class=(klass)
+      self.config = config.merge(digest_class: klass).freeze
+    end
+
+    # Deprecated: Get `Context` class.
+    #
+    # This class maybe mutated and mixed in with custom helpers.
+    #
+    #     environment.context_class.instance_eval do
+    #       include MyHelpers
+    #       def asset_url; end
+    #     end
+    #
+    attr_reader :context_class
+  end
+end

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,92 +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__
+    attr_reader :environment, :filename, :pathname
+
+    # Deprecated
+    attr_accessor :__LINE__
 
-    def initialize(environment, logical_path, pathname)
-      @environment  = environment
-      @logical_path = logical_path
-      @pathname     = pathname
-      @__LINE__     = nil
+    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_paths    = []
-      @_stubbed_assets    = Set.new
-      @_dependency_paths  = Set.new
-      @_dependency_assets = Set.new([pathname.to_s])
+      @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
 
     # 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
+    # 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
@@ -116,7 +108,13 @@ module Sprockets
     # the dependency file with invalidate the cache of the
     # source file.
     def depend_on(path)
-      @_dependency_paths << resolve(path).to_s
+      path = path.to_s if path.is_a?(Pathname)
+
+      if environment.absolute_path?(path) && environment.stat(path)
+        @dependencies << environment.build_file_digest_uri(path)
+      else
+        resolve(path, compat: false)
+      end
       nil
     end
 
@@ -128,9 +126,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
@@ -143,9 +139,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
 
@@ -153,55 +147,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.
-    #
-    # 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
@@ -215,10 +173,9 @@ 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
 
     # Expands logical path to full url to asset.
@@ -243,47 +200,32 @@ 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__
-
-        exception.extend(Sprockets::EngineError)
-        exception.sprockets_annotation = "  (in #{location})"
-      end
-
-      def logger
-        environment.logger
-      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 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