sprockets 2.11.3 → 3.7.2

data/lib/sprockets/ejs_template.rb

@@ -1,37 +1,17 @@
-require 'tilt'
+require 'sprockets/ejs_processor'
 
 module Sprockets
-  # Tilt engine class for the EJS compiler. Depends on the `ejs` gem.
-  #
-  # For more infomation see:
-  #
-  #   https://github.com/sstephenson/ruby-ejs
-  #
-  class EjsTemplate < Tilt::Template
-    # Check to see if EJS is loaded
-    def self.engine_initialized?
-      defined? ::EJS
-    end
-
-    # Autoload ejs library. If the library isn't loaded, Tilt will produce
-    # a thread safetly warning. If you intend to use `.ejs` files, you
-    # should explicitly require it.
-    def initialize_engine
-      require_template_library 'ejs'
-    end
+  # Deprecated
+  module EjsTemplate
+    VERSION = EjsProcessor::VERSION
 
-    def prepare
+    def self.cache_key
+      EjsProcessor.cache_key
     end
 
-    # Compile template data with EJS compiler.
-    #
-    # Returns a JS function definition String. The result should be
-    # assigned to a JS variable.
-    #
-    #     # => "function(obj){...}"
-    #
-    def evaluate(scope, locals, &block)
-      EJS.compile(data)
+    def self.call(*args)
+      Deprecation.new.warn "EjsTemplate is deprecated please use EjsProcessor instead"
+      EjsProcessor.call(*args)
     end
   end
 end

data/lib/sprockets/encoding_utils.rb

@@ -0,0 +1,261 @@
+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/engines.rb

@@ -1,22 +1,19 @@
-require 'sprockets/eco_template'
-require 'sprockets/ejs_template'
-require 'sprockets/jst_processor'
+require 'sprockets/legacy_tilt_processor'
 require 'sprockets/utils'
-require 'tilt'
 
 module Sprockets
   # `Engines` provides a global and `Environment` instance registry.
   #
-  # An engine is a type of processor that is bound to an filename
+  # An engine is a type of processor that is bound to a filename
   # extension. `application.js.coffee` indicates that the
-  # `CoffeeScriptTemplate` engine will be ran on the file.
+  # `CoffeeScriptProcessor` engine will be ran on the file.
   #
   # Extensions can be stacked and will be evaulated from right to
-  # left. `application.js.coffee.erb` will first run `ERBTemplate`
-  # then `CoffeeScriptTemplate`.
+  # left. `application.js.coffee.erb` will first run `ERBProcessor`
+  # then `CoffeeScriptProcessor`.
   #
-  # All `Engine`s must follow the `Tilt::Template` interface. It is
-  # recommended to subclass `Tilt::Template`.
+  # All `Engine`s must follow the `Template` interface. It is
+  # recommended to subclass `Template`.
   #
   # Its recommended that you register engine changes on your local
   # `Environment` instance.
@@ -25,50 +22,71 @@ module Sprockets
   #
   # The global registry is exposed for plugins to register themselves.
   #
-  #     Sprockets.register_engine '.sass', SassTemplate
+  #     Sprockets.register_engine '.sass', SassProcessor
   #
   module Engines
+    include Utils
+
     # Returns a `Hash` of `Engine`s registered on the `Environment`.
     # If an `ext` argument is supplied, the `Engine` associated with
     # that extension will be returned.
     #
     #     environment.engines
-    #     # => {".coffee" => CoffeeScriptTemplate, ".sass" => SassTemplate, ...}
-    #
-    #     environment.engines('.coffee')
-    #     # => CoffeeScriptTemplate
+    #     # => {".coffee" => CoffeeScriptProcessor, ".sass" => SassProcessor, ...}
     #
-    def engines(ext = nil)
-      if ext
-        ext = Sprockets::Utils.normalize_extension(ext)
-        @engines[ext]
-      else
-        @engines.dup
-      end
+    def engines
+      config[:engines]
     end
 
-    # Returns an `Array` of engine extension `String`s.
+    # Internal: Returns a `Hash` of engine extensions to mime types.
     #
-    #     environment.engine_extensions
-    #     # => ['.coffee', '.sass', ...]
-    def engine_extensions
-      @engines.keys
+    # # => { '.coffee' => 'application/javascript' }
+    def engine_mime_types
+      config[:engine_mime_types]
     end
 
     # Registers a new Engine `klass` for `ext`. If the `ext` already
     # has an engine registered, it will be overridden.
     #
-    #     environment.register_engine '.coffee', CoffeeScriptTemplate
+    #     environment.register_engine '.coffee', CoffeeScriptProcessor
     #
-    def register_engine(ext, klass)
+    def register_engine(ext, klass, options = {})
+      unless options[:silence_deprecation]
+        msg = <<-MSG
+Sprockets method `register_engine` is deprecated.
+Please register a mime type using `register_mime_type` then
+use `register_compressor` or `register_transformer`.
+https://github.com/rails/sprockets/blob/master/guides/extending_sprockets.md#supporting-all-versions-of-sprockets-in-processors
+        MSG
+
+        Deprecation.new([caller.first]).warn(msg)
+      end
+
       ext = Sprockets::Utils.normalize_extension(ext)
-      @engines[ext] = klass
-    end
 
-    private
-      def deep_copy_hash(hash)
-        initial = Hash.new { |h, k| h[k] = [] }
-        hash.inject(initial) { |h, (k, a)| h[k] = a.dup; h }
+      self.computed_config = {}
+
+      if klass.respond_to?(:call)
+        processor = klass
+        self.config = hash_reassoc(config, :engines) do |engines|
+          engines.merge(ext => klass)
+        end
+        if options[:mime_type]
+          self.config = hash_reassoc(config, :engine_mime_types) do |mime_types|
+            mime_types.merge(ext.to_s => options[:mime_type])
+          end
+        end
+      else
+        processor = LegacyTiltProcessor.new(klass)
+        self.config = hash_reassoc(config, :engines) do |engines|
+          engines.merge(ext => processor)
+        end
+        if klass.respond_to?(:default_mime_type) && klass.default_mime_type
+          self.config = hash_reassoc(config, :engine_mime_types) do |mime_types|
+            mime_types.merge(ext.to_s => klass.default_mime_type)
+          end
+        end
       end
+    end
   end
 end

data/lib/sprockets/environment.rb

@@ -1,11 +1,6 @@
 require 'sprockets/base'
-require 'sprockets/context'
-require 'sprockets/index'
-
-require 'hike'
-require 'logger'
-require 'pathname'
-require 'tilt'
+require 'sprockets/cache/memory_store'
+require 'sprockets/cached_environment'
 
 module Sprockets
   class Environment < Base
@@ -15,74 +10,32 @@ module Sprockets
     #     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        = Sprockets.registered_mime_types
-      @engines           = Sprockets.engines
-      @preprocessors     = Sprockets.preprocessors
-      @postprocessors    = Sprockets.postprocessors
-      @bundle_processors = Sprockets.bundle_processors
-      @compressors       = Sprockets.compressors
-
-      Sprockets.paths.each do |path|
-        append_path(path)
-      end
-
-      @engines.each do |ext, klass|
-        add_engine_to_trail(ext, klass)
-      end
-
-      @mime_types.each do |ext, type|
-        @trail.append_extension(ext)
-      end
-
-      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 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)
+      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,30 @@
+require 'erb'
+
+module Sprockets
+  class 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)
+      engine = ::ERB.new(input[:data], nil, '<>')
+      context = input[:environment].context_class.new(input)
+      klass = (class << context; self; end)
+      klass.class_eval(&@block) if @block
+      engine.def_method(klass, :_evaluate_template, input[:filename])
+      data = context._evaluate_template
+      context.metadata.merge(data: data)
+    end
+  end
+end

data/lib/sprockets/erb_template.rb

@@ -0,0 +1,11 @@
+require 'sprockets/erb_processor'
+
+module Sprockets
+  # Deprecated
+  class ERBTemplate < ERBProcessor
+    def call(*args)
+      Deprecation.new.warn "ERBTemplate is deprecated please use ERBProcessor instead"
+      super
+    end
+  end
+end

data/lib/sprockets/errors.rb

@@ -2,19 +2,10 @@
 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 NotImplementedError     < Error; end
-  class UnserializeError        < Error; end
-
-  module EngineError
-    attr_accessor :sprockets_annotation
-
-    def message
-      [super, sprockets_annotation].compact.join("\n")
-    end
-  end
+  class NotFound                < Error; end
+  class ConversionError         < NotFound; end
+  class FileNotFound            < NotFound; end
+  class FileOutsidePaths        < NotFound; end
 end

data/lib/sprockets/file_reader.rb

@@ -0,0 +1,15 @@
+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