sprockets 2.2.3 → 4.0.0

data/lib/sprockets/encoding_utils.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+require 'base64'
+require 'stringio'
+require 'zlib'
+
+module Sprockets
+  # Internal: HTTP transport encoding and charset detecting related functions.
+  # Mixed into Environment.
+  module EncodingUtils
+    extend self
+
+    ## Binary encodings ##
+
+    # Public: Use deflate to compress data.
+    #
+    # str - String data
+    #
+    # Returns a compressed String
+    def deflate(str)
+      deflater = Zlib::Deflate.new(
+        Zlib::BEST_COMPRESSION,
+        -Zlib::MAX_WBITS,
+        Zlib::MAX_MEM_LEVEL,
+        Zlib::DEFAULT_STRATEGY
+      )
+      deflater << str
+      deflater.finish
+    end
+
+    # Internal: Unmarshal optionally deflated data.
+    #
+    # Checks leading marshal header to see if the bytes are uncompressed
+    # otherwise inflate the data an unmarshal.
+    #
+    # str - Marshaled String
+    # window_bits - Integer deflate window size. See ZLib::Inflate.new()
+    #
+    # Returns unmarshaled Object or raises an Exception.
+    def unmarshaled_deflated(str, window_bits = -Zlib::MAX_WBITS)
+      major, minor = str[0], str[1]
+      if major && major.ord == Marshal::MAJOR_VERSION &&
+          minor && minor.ord <= Marshal::MINOR_VERSION
+        marshaled = str
+      else
+        begin
+          marshaled = Zlib::Inflate.new(window_bits).inflate(str)
+        rescue Zlib::DataError
+          marshaled = str
+        end
+      end
+      Marshal.load(marshaled)
+    end
+
+    # Public: Use gzip to compress data.
+    #
+    # str - String data
+    #
+    # Returns a compressed String
+    def gzip(str)
+      io = StringIO.new
+      gz = Zlib::GzipWriter.new(io, Zlib::BEST_COMPRESSION)
+      gz.mtime = 1
+      gz << str
+      gz.finish
+      io.string
+    end
+
+    # Public: Use base64 to encode data.
+    #
+    # str - String data
+    #
+    # Returns a encoded String
+    def base64(str)
+      Base64.strict_encode64(str)
+    end
+
+
+    ## Charset encodings ##
+
+    # Internal: Shorthand aliases for detecter functions.
+    CHARSET_DETECT = {}
+
+    # Internal: Mapping unicode encodings to byte order markers.
+    BOM = {
+      Encoding::UTF_32LE => [0xFF, 0xFE, 0x00, 0x00],
+      Encoding::UTF_32BE => [0x00, 0x00, 0xFE, 0xFF],
+      Encoding::UTF_8    => [0xEF, 0xBB, 0xBF],
+      Encoding::UTF_16LE => [0xFF, 0xFE],
+      Encoding::UTF_16BE => [0xFE, 0xFF]
+    }
+
+    # Public: Basic string detecter.
+    #
+    # Attempts to parse any Unicode BOM otherwise falls back to the
+    # environment's external encoding.
+    #
+    # str - ASCII-8BIT encoded String
+    #
+    # Returns encoded String.
+    def detect(str)
+      str = detect_unicode_bom(str)
+
+      # Attempt Charlock detection
+      if str.encoding == Encoding::BINARY
+        charlock_detect(str)
+      end
+
+      # Fallback to environment's external encoding
+      if str.encoding == Encoding::BINARY
+        str.force_encoding(Encoding.default_external)
+      end
+
+      str
+    end
+    CHARSET_DETECT[:default] = method(:detect)
+
+    # Internal: Use Charlock Holmes to detect encoding.
+    #
+    # To enable this code path, require 'charlock_holmes'
+    #
+    # Returns encoded String.
+    def charlock_detect(str)
+      if defined? CharlockHolmes::EncodingDetector
+        if detected = CharlockHolmes::EncodingDetector.detect(str)
+          str.force_encoding(detected[:encoding]) if detected[:encoding]
+        end
+      end
+
+      str
+    end
+
+    # Public: Detect Unicode string.
+    #
+    # Attempts to parse Unicode BOM and falls back to UTF-8.
+    #
+    # str - ASCII-8BIT encoded String
+    #
+    # Returns encoded String.
+    def detect_unicode(str)
+      str = detect_unicode_bom(str)
+
+      # Fallback to UTF-8
+      if str.encoding == Encoding::BINARY
+        str.force_encoding(Encoding::UTF_8)
+      end
+
+      str
+    end
+    CHARSET_DETECT[:unicode] = method(:detect_unicode)
+
+    # Public: Detect and strip BOM from possible unicode string.
+    #
+    # str - ASCII-8BIT encoded String
+    #
+    # Returns UTF 8/16/32 encoded String without BOM or the original String if
+    # no BOM was present.
+    def detect_unicode_bom(str)
+      bom_bytes = str.byteslice(0, 4).bytes.to_a
+
+      BOM.each do |encoding, bytes|
+        if bom_bytes[0, bytes.size] == bytes
+          str = str.dup
+          str.force_encoding(Encoding::BINARY)
+          str.slice!(0, bytes.size)
+          str.force_encoding(encoding)
+          return str
+        end
+      end
+
+      return str
+    end
+
+    # Public: Detect and strip @charset from CSS style sheet.
+    #
+    # str - String.
+    #
+    # Returns a encoded String.
+    def detect_css(str)
+      str = detect_unicode_bom(str)
+
+      if name = scan_css_charset(str)
+        encoding = Encoding.find(name)
+        str = str.dup
+        str.force_encoding(encoding)
+        len = "@charset \"#{name}\";".encode(encoding).size
+        str.slice!(0, len)
+        str
+      end
+
+      # Fallback to UTF-8
+      if str.encoding == Encoding::BINARY
+        str.force_encoding(Encoding::UTF_8)
+      end
+
+      str
+    end
+    CHARSET_DETECT[:css] = method(:detect_css)
+
+    # Internal: @charset bytes
+    CHARSET_START = [0x40, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x20, 0x22]
+    CHARSET_SIZE  = CHARSET_START.size
+
+    # Internal: Scan binary CSS string for @charset encoding name.
+    #
+    # str - ASCII-8BIT encoded String
+    #
+    # Returns encoding String name or nil.
+    def scan_css_charset(str)
+      buf = []
+      i = 0
+
+      str.each_byte.each do |byte|
+        # Halt on line breaks
+        break if byte == 0x0A || byte == 0x0D
+
+        # Only ascii bytes
+        next unless 0x0 < byte && byte <= 0xFF
+
+        if i < CHARSET_SIZE
+        elsif i == CHARSET_SIZE
+          if buf == CHARSET_START
+            buf = []
+          else
+            break
+          end
+        elsif byte == 0x22
+          return buf.pack('C*')
+        end
+
+        buf << byte
+        i += 1
+      end
+
+      nil
+    end
+
+    # Public: Detect charset from HTML document.
+    #
+    # Attempts to parse any Unicode BOM otherwise attempt Charlock detection
+    # and finally falls back to the environment's external encoding.
+    #
+    # str - String.
+    #
+    # Returns a encoded String.
+    def detect_html(str)
+      str = detect_unicode_bom(str)
+
+      # Attempt Charlock detection
+      if str.encoding == Encoding::BINARY
+        charlock_detect(str)
+      end
+
+      # Fallback to environment's external encoding
+      if str.encoding == Encoding::BINARY
+        str.force_encoding(Encoding.default_external)
+      end
+
+      str
+    end
+    CHARSET_DETECT[:html] = method(:detect_html)
+  end
+end

data/lib/sprockets/environment.rb

@@ -1,91 +1,46 @@
+# frozen_string_literal: true
 require 'sprockets/base'
-require 'sprockets/charset_normalizer'
-require 'sprockets/context'
-require 'sprockets/directive_processor'
-require 'sprockets/index'
-require 'sprockets/safety_colons'
-
-require 'hike'
-require 'logger'
-require 'pathname'
-require 'tilt'
+require 'sprockets/cache/memory_store'
+require 'sprockets/cached_environment'
 
 module Sprockets
   class Environment < Base
-    # `Environment` should initialized with your application's root
+    # `Environment` should be initialized with your application's root
     # directory. This should be the same as your Rails or Rack root.
     #
     #     env = Environment.new(Rails.root)
     #
     def initialize(root = ".")
-      @trail = Hike::Trail.new(root)
-
-      self.logger = Logger.new($stderr)
-      self.logger.level = Logger::FATAL
-
-      if respond_to?(:default_external_encoding)
-        self.default_external_encoding = Encoding::UTF_8
-      end
-
-      # Create a safe `Context` subclass to mutate
-      @context_class = Class.new(Context)
-
-      # Set MD5 as the default digest
-      require 'digest/md5'
-      @digest_class = ::Digest::MD5
-      @version = ''
-
-      @mime_types        = {}
-      @engines           = Sprockets.engines
-      @preprocessors     = Hash.new { |h, k| h[k] = [] }
-      @postprocessors    = Hash.new { |h, k| h[k] = [] }
-      @bundle_processors = Hash.new { |h, k| h[k] = [] }
-
-      @engines.each do |ext, klass|
-        add_engine_to_trail(ext, klass)
-      end
-
-      register_mime_type 'text/css', '.css'
-      register_mime_type 'application/javascript', '.js'
-
-      register_preprocessor 'text/css', DirectiveProcessor
-      register_preprocessor 'application/javascript', DirectiveProcessor
-
-      register_postprocessor 'application/javascript', SafetyColons
-      register_bundle_processor 'text/css', CharsetNormalizer
-
-      expire_index!
-
+      initialize_configuration(Sprockets)
+      self.root = root
+      self.cache = Cache::MemoryStore.new
       yield self if block_given?
     end
 
     # Returns a cached version of the environment.
     #
-    # All its file system calls are cached which makes `index` much
+    # All of its file system calls are cached which makes `cached` much
     # faster. This behavior is ideal in production since the file
     # system only changes between deploys.
-    def index
-      Index.new(self)
+    def cached
+      CachedEnvironment.new(self)
     end
+    alias_method :index, :cached
 
-    # Cache `find_asset` calls
-    def find_asset(path, options = {})
-      options[:bundle] = true unless options.key?(:bundle)
+    def find_asset(*args, **options)
+      cached.find_asset(*args, **options)
+    end
+
+    def find_asset!(*args)
+      cached.find_asset!(*args)
+    end
 
-      # Ensure inmemory cached assets are still fresh on every lookup
-      if (asset = @assets[cache_key_for(path, options)]) && asset.fresh?(self)
-        asset
-      elsif asset = index.find_asset(path, options)
-        # Cache is pushed upstream by Index#find_asset
-        asset
-      end
+    def find_all_linked_assets(*args, &block)
+      cached.find_all_linked_assets(*args, &block)
     end
 
-    protected
-      def expire_index!
-        # Clear digest to be recomputed
-        @digest = nil
-        @assets = {}
-      end
+    def load(*args)
+      cached.load(*args)
+    end
   end
 end

data/lib/sprockets/erb_processor.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require 'erb'
+
+class Sprockets::ERBProcessor
+  # Public: Return singleton instance with default options.
+  #
+  # Returns ERBProcessor object.
+  def self.instance
+    @instance ||= new
+  end
+
+  def self.call(input)
+    instance.call(input)
+  end
+
+  def initialize(&block)
+    @block = block
+  end
+
+  def call(input)
+    match = ERB.version.match(/\Aerb\.rb \[(?<version>[^ ]+) /)
+    if match && match[:version] >= "2.2.0" # Ruby 2.6+
+      engine = ::ERB.new(input[:data], trim_mode: '<>')
+    else
+      engine = ::ERB.new(input[:data], nil, '<>')
+    end
+    engine.filename = input[:filename]
+
+    context = input[:environment].context_class.new(input)
+    klass = (class << context; self; end)
+    klass.const_set(:ENV, context.env_proxy)
+    klass.class_eval(&@block) if @block
+
+    data = engine.result(context.instance_eval('binding'))
+    context.metadata.merge(data: data)
+  end
+end

data/lib/sprockets/errors.rb

@@ -1,19 +1,12 @@
+# frozen_string_literal: true
 # Define some basic Sprockets error classes
 module Sprockets
   class Error           < StandardError; end
   class ArgumentError           < Error; end
-  class CircularDependencyError < Error; end
   class ContentTypeMismatch     < Error; end
-  class EncodingError           < Error; end
-  class FileNotFound            < Error; end
-  class FileOutsidePaths        < Error; end
-  class UnserializeError        < Error; end
-
-  module EngineError
-    attr_accessor :sprockets_annotation
-
-    def message
-      [super, sprockets_annotation].compact.join("\n")
-    end
-  end
+  class NotImplementedError     < Error; end
+  class NotFound                < Error; end
+  class ConversionError         < NotFound; end
+  class FileNotFound            < NotFound; end
+  class FileOutsidePaths        < NotFound; end
 end

data/lib/sprockets/exporters/base.rb

@@ -0,0 +1,72 @@
+module Sprockets
+  module Exporters
+    # Convienence class for all exporters to inherit from
+    #
+    # An exporter is responsible for exporting a Sprockets::Asset
+    # to a file system. For example the Exporters::File class
+    # writes the asset to it's destination. The Exporters::Zlib class
+    # writes a gzip copy of the asset to disk.
+    class Base
+      attr_reader :asset, :environment, :directory, :target
+
+      # Public: Creates new instance
+      #
+      # Initialize will be called with
+      # keyword arguments:
+      #
+      # - asset: An instance of Sprockets::Asset.
+      # - environment: An instance of Sprockets::Environment.
+      # - directory: String representing the target directory to write to.
+      #
+      # These will all be stored as accessible values. In addition a
+      # +target+ will be available which is the target directory and
+      # the asset's digest path combined.
+      def initialize(asset: nil, environment: nil, directory: nil)
+        @asset       = asset
+        @environment = environment
+        @directory   = directory
+        @target      = ::File.join(directory, asset.digest_path)
+        setup
+      end
+
+      # Public: Callback that is executed after intialization
+      #
+      # Any setup that needs to be done can be performed in the +setup+
+      # method. It will be called immediately after initialization.
+      def setup
+      end
+
+      # Public: Handles logic for skipping exporter and notifying logger
+      #
+      # The `skip?` will be called before anything will be written.
+      # If `skip?` returns truthy it will not continue. This method
+      # takes a `logger` that responds to +debug+ and +info+.  The `skip?`
+      # method is the only place expected to write to a logger, any other
+      # messages may produce jumbled logs.
+      def skip?(logger)
+        false
+      end
+
+      # Public: Contains logic for writing "exporting" asset to disk
+      #
+      # If the exporter is not skipped it then Sprockets will execute it's
+      # `call` method. This method takes no arguments and should only use
+      # elements passed in via initialize or stored in `setup`.
+      def call
+        raise "Must subclass and implement call"
+      end
+
+      # Public: Yields a file that can be written to with the input
+      #
+      # `filename`. Defaults to the `target`. Method
+      # is safe to use in forked or threaded environments.
+      def write(filename = target)
+        FileUtils.mkdir_p File.dirname(filename)
+        PathUtils.atomic_write(filename) do |f|
+          yield f
+        end
+      end
+    end
+  end
+end
+

data/lib/sprockets/exporters/file_exporter.rb

@@ -0,0 +1,24 @@
+require 'sprockets/exporters/base'
+
+module Sprockets
+  module Exporters
+    # Writes a an asset file to disk
+    class FileExporter < Exporters::Base
+      def skip?(logger)
+        if ::File.exist?(target)
+          logger.debug "Skipping #{ target }, already exists"
+          true
+        else
+          logger.info "Writing #{ target }"
+          false
+        end
+      end
+
+      def call
+        write(target) do |file|
+          file.write(asset.source)
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/exporters/zlib_exporter.rb

@@ -0,0 +1,33 @@
+require 'sprockets/exporters/base'
+require 'sprockets/utils/gzip'
+
+module Sprockets
+  module Exporters
+    # Generates a `.gz` file using the zlib algorithm built into
+    # Ruby's standard library.
+    class ZlibExporter < Exporters::Base
+      def setup
+        @gzip_target = "#{ target }.gz"
+        @gzip = Sprockets::Utils::Gzip.new(asset, archiver: Utils::Gzip::ZlibArchiver)
+      end
+
+      def skip?(logger)
+        return true if environment.skip_gzip?
+        return true if @gzip.cannot_compress?
+        if ::File.exist?(@gzip_target)
+          logger.debug "Skipping #{ @gzip_target }, already exists"
+          true
+        else
+          logger.info "Writing #{ @gzip_target }"
+          false
+        end
+      end
+
+      def call
+        write(@gzip_target) do |file|
+          @gzip.compress(file, target)
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/exporters/zopfli_exporter.rb

@@ -0,0 +1,14 @@
+require 'sprockets/exporters/zlib_exporter'
+
+module Sprockets
+  module Exporters
+    # Generates a `.gz` file using the zopfli algorithm from the
+    # Zopfli gem.
+    class ZopfliExporter < ZlibExporter
+      def setup
+        @gzip_target = "#{ target }.gz"
+        @gzip = Sprockets::Utils::Gzip.new(asset, archiver: Utils::Gzip::ZopfliArchiver)
+      end
+    end
+  end
+end

data/lib/sprockets/exporting.rb

@@ -0,0 +1,73 @@
+module Sprockets
+  # `Exporting` is an internal mixin whose public methods are exposed on
+  # the `Environment` and `CachedEnvironment` classes.
+  module Exporting
+    # Exporters are ran on the assets:precompile task
+    def exporters
+      config[:exporters]
+    end
+
+    # Public: Registers a new Exporter `klass` for `mime_type`.
+    #
+    # If your exporter depends on one or more other exporters you can
+    # specify this via the `depend_on` keyword.
+    #
+    #     register_exporter '*/*', Sprockets::Exporters::ZlibExporter
+    #
+    # This ensures that `Sprockets::Exporters::File` will always execute before
+    # `Sprockets::Exporters::Zlib`
+    def register_exporter(mime_types, klass = nil)
+      mime_types = Array(mime_types)
+
+      mime_types.each do |mime_type|
+        self.config = hash_reassoc(config, :exporters, mime_type) do |_exporters|
+          _exporters << klass
+        end
+      end
+    end
+
+    # Public: Remove Exporting processor `klass` for `mime_type`.
+    #
+    #     environment.unregister_exporter '*/*', Sprockets::Exporters::Zlib
+    #
+    # Can be called without a mime type
+    #
+    #     environment.unregister_exporter Sprockets::Exporters::Zlib
+    #
+    # Does not remove any exporters that depend on `klass`.
+    def unregister_exporter(mime_types, exporter = nil)
+      unless mime_types.is_a? Array
+        if mime_types.is_a? String
+          mime_types = [mime_types]
+        else # called with no mime type
+          exporter = mime_types
+          mime_types = nil
+        end
+      end
+
+      self.config = hash_reassoc(config, :exporters) do |_exporters|
+        _exporters.each do |mime_type, exporters_array|
+          next if mime_types && !mime_types.include?(mime_type)
+          if exporters_array.include? exporter
+            _exporters[mime_type] = exporters_array.dup.delete exporter
+          end
+        end
+      end
+    end
+
+    # Public: Checks if concurrent exporting is allowed
+    def export_concurrent
+      config[:export_concurrent]
+    end
+
+    # Public: Enable or disable the concurrently exporting files
+    #
+    # Defaults to true.
+    #
+    #     environment.export_concurrent = false
+    #
+    def export_concurrent=(export_concurrent)
+      self.config = config.merge(export_concurrent: export_concurrent).freeze
+    end
+  end
+end

data/lib/sprockets/file_reader.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require 'set'
+
+module Sprockets
+  # Internal: The first processor in the pipeline that reads the file into
+  # memory and passes it along as `input[:data]`.  
+  class FileReader
+    def self.call(input)
+      env = input[:environment]
+      data = env.read_file(input[:filename], input[:content_type])
+      dependencies = Set.new(input[:metadata][:dependencies])
+      dependencies += [env.build_file_digest_uri(input[:filename])]
+      { data: data, dependencies: dependencies }
+    end
+  end
+end