sprockets 2.2.3 → 4.0.0

data/lib/sprockets/closure_compressor.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+require 'sprockets/autoload'
+require 'sprockets/digest_utils'
+
+module Sprockets
+  # Public: Closure Compiler minifier.
+  #
+  # To accept the default options
+  #
+  #     environment.register_bundle_processor 'application/javascript',
+  #       Sprockets::ClosureCompressor
+  #
+  # Or to pass options to the Closure::Compiler class.
+  #
+  #     environment.register_bundle_processor 'application/javascript',
+  #       Sprockets::ClosureCompressor.new({ ... })
+  #
+  class ClosureCompressor
+    VERSION = '1'
+
+    # Public: Return singleton instance with default options.
+    #
+    # Returns ClosureCompressor object.
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.call(input)
+      instance.call(input)
+    end
+
+    def self.cache_key
+      instance.cache_key
+    end
+
+    attr_reader :cache_key
+
+    def initialize(options = {})
+      @options = options
+      @cache_key = "#{self.class.name}:#{Autoload::Closure::VERSION}:#{Autoload::Closure::COMPILER_VERSION}:#{VERSION}:#{DigestUtils.digest(options)}".freeze
+    end
+
+    def call(input)
+      @compiler ||= Autoload::Closure::Compiler.new(@options)
+      @compiler.compile(input[:data])
+    end
+  end
+end

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