sprockets 4.0.1

data/lib/sprockets/coffee_script_processor.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require 'sprockets/autoload'
+require 'sprockets/source_map_utils'
+
+module Sprockets
+  # Processor engine class for the CoffeeScript compiler.
+  # Depends on the `coffee-script` and `coffee-script-source` gems.
+  #
+  # For more infomation see:
+  #
+  #   https://github.com/rails/ruby-coffee-script
+  #
+  module CoffeeScriptProcessor
+    VERSION = '2'
+
+    def self.cache_key
+      @cache_key ||= "#{name}:#{Autoload::CoffeeScript::Source.version}:#{VERSION}".freeze
+    end
+
+    def self.call(input)
+      data = input[:data]
+
+      js, map = input[:cache].fetch([self.cache_key, data]) do
+        result = Autoload::CoffeeScript.compile(
+          data,
+          sourceMap: "v3",
+          sourceFiles: [File.basename(input[:filename])],
+          generatedFile: input[:filename]
+        )
+        [result['js'], JSON.parse(result['v3SourceMap'])]
+      end
+
+      map = SourceMapUtils.format_source_map(map, input)
+      map = SourceMapUtils.combine_source_maps(input[:metadata][:map], map)
+
+      { data: js, map: map }
+    end
+  end
+end

data/lib/sprockets/compressing.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+require 'sprockets/utils'
+
+module Sprockets
+  # `Compressing` is an internal mixin whose public methods are exposed on
+  # the `Environment` and `CachedEnvironment` classes.
+  module Compressing
+    include Utils
+
+    def compressors
+      config[:compressors]
+    end
+
+    # Public: Register a new compressor `klass` at `sym` for `mime_type`.
+    #
+    # Registering a processor allows it to be looked up by `sym` later when
+    # assigning a JavaScript or CSS compressor.
+    #
+    # Compressors only operate on JavaScript and CSS. If you want to compress a
+    # different type of asset, use a processor instead.
+    #
+    # Examples
+    #
+    #     register_compressor 'text/css', :my_sass, MySassCompressor
+    #     css_compressor = :my_sass
+    #
+    # mime_type - String MIME Type (one of: 'test/css' or 'application/javascript').
+    # sym       - Symbol registration address.
+    # klass     - The compressor class.
+    #
+    # Returns nothing.
+    def register_compressor(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
+      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 defined? @css_compressor
+      @css_compressor = nil
+      return unless compressor
+
+      if compressor.is_a?(Symbol)
+        @css_compressor = klass = config[:compressors]['text/css'][compressor] || raise(Error, "unknown compressor: #{compressor}")
+      elsif compressor.respond_to?(:compress)
+        klass = proc { |input| compressor.compress(input[:data]) }
+        @css_compressor = :css_compressor
+      else
+        @css_compressor = klass = compressor
+      end
+
+      register_bundle_processor 'text/css', klass
+    end
+
+    # Return JS compressor or nil if none is set
+    def 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 defined? @js_compressor
+      @js_compressor = nil
+      return unless compressor
+
+      if compressor.is_a?(Symbol)
+        @js_compressor = klass = config[:compressors]['application/javascript'][compressor] || raise(Error, "unknown compressor: #{compressor}")
+      elsif compressor.respond_to?(:compress)
+        klass = proc { |input| compressor.compress(input[:data]) }
+        @js_compressor = :js_compressor
+      else
+        @js_compressor = klass = compressor
+      end
+
+      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.
+    #
+    # To disable gzip generation set to a falsey value:
+    #
+    #     environment.gzip = false
+    #
+    # To enable set to a truthy value. By default zlib wil
+    # be used to gzip assets. If you have the Zopfli gem
+    # installed you can specify the zopfli algorithm to be used
+    # instead:
+    #
+    #     environment.gzip = :zopfli
+    #
+    def gzip=(gzip)
+      self.config = config.merge(gzip_enabled: gzip).freeze
+
+      case gzip
+      when false, nil
+        self.unregister_exporter Exporters::ZlibExporter
+        self.unregister_exporter Exporters::ZopfliExporter
+      when :zopfli
+        self.unregister_exporter Exporters::ZlibExporter
+        self.register_exporter '*/*', Exporters::ZopfliExporter
+      else
+        self.unregister_exporter Exporters::ZopfliExporter
+        self.register_exporter '*/*', Exporters::ZlibExporter
+      end
+
+      gzip
+    end
+  end
+end

data/lib/sprockets/configuration.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+require 'sprockets/compressing'
+require 'sprockets/dependencies'
+require 'sprockets/mime'
+require 'sprockets/paths'
+require 'sprockets/processing'
+require 'sprockets/exporting'
+require 'sprockets/transformers'
+require 'sprockets/utils'
+
+module Sprockets
+  module Configuration
+    include Paths, Mime, Transformers, Processing, Exporting, Compressing, Dependencies, Utils
+
+    def initialize_configuration(parent)
+      @config = parent.config
+      @logger = parent.logger
+      @context_class = Class.new(parent.context_class)
+    end
+
+    attr_reader :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
+
+    # 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

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+require 'rack/utils'
+require 'set'
+require 'sprockets/errors'
+
+module Sprockets
+  # 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
+  #       def asset_url; end
+  #     end
+  #
+  #     <%= asset_url "foo.png" %>
+  #
+  # The `Context` also collects dependencies declared by
+  # assets. See `DirectiveProcessor` for an example of this.
+  class Context
+    # 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`, `load_path` would
+    # return `app/javascripts`.
+    attr_reader :load_path
+    alias_method :root_path, :load_path
+
+    # Returns logical path without any file extensions.
+    #
+    #     'app/javascripts/application.js'
+    #     # => 'application'
+    #
+    attr_reader :logical_path
+
+    # Returns content type of file
+    #
+    #     'application/javascript'
+    #     'text/css'
+    #
+    attr_reader :content_type
+
+    # 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")
+    #     # => "file:///path/to/app/javascripts/foo.js?type=application/javascript"
+    #
+    #     resolve("./bar.js")
+    #     # => "file:///path/to/app/javascripts/bar.js?type=application/javascript"
+    #
+    # 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 will invalidate the cache of the
+    # source file.
+    def depend_on(path)
+      if environment.absolute_path?(path) && environment.stat(path)
+        @dependencies << environment.build_file_digest_uri(path)
+      else
+        resolve(path)
+      end
+      nil
+    end
+
+    # `depend_on_asset` allows you to state an asset dependency
+    # without including it.
+    #
+    # This is used for caching purposes. Any changes that would
+    # invalidate the dependency asset will invalidate the source
+    # file. Unlike `depend_on`, this will recursively include
+    # the target asset's dependencies.
+    def depend_on_asset(path)
+      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
+    # dependency will be inserted before the file and will only be
+    # included once.
+    #
+    # If ERB processing is enabled, you can use it to dynamically
+    # require assets.
+    #
+    #     <%= require_asset "#{framework}.js" %>
+    #
+    def require_asset(path)
+      @required << resolve(path, accept: @content_type, pipeline: :self)
+      nil
+    end
+
+    # `stub_asset` blacklists `path` from being included in the bundle.
+    # `path` must be an asset which may or may not already be included
+    # in the bundle.
+    def stub_asset(path)
+      @stubbed << resolve(path, accept: @content_type, pipeline: :self)
+      nil
+    end
+
+    # `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.
+    #
+    # Returns an Asset or nil.
+    def link_asset(path)
+      asset = depend_on_asset(path)
+      @links << asset.uri
+      asset
+    end
+
+    # 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:
+    #
+    #     #logo { background: url(<%= asset_data_uri 'logo.png' %>) }
+    #
+    #     $('<img>').attr('src', '<%= asset_data_uri 'avatar.jpg' %>')
+    #
+    def asset_data_uri(path)
+      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
+    # are required to be overridden.
+    def asset_path(path, options = {})
+      message = <<-EOS
+Custom asset_path helper is not implemented
+
+Extend your environment context with a custom method.
+
+    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
+
+    protected
+
+    # 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
+
+    # 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