sprockets 2.12.5 → 3.0.0.beta.1

data/lib/sprockets/eco_template.rb

@@ -1,28 +1,15 @@
-require 'tilt'
+require 'eco'
 
 module Sprockets
-  # Tilt engine class for the Eco compiler. Depends on the `eco` gem.
+  # Template engine class for the Eco compiler. Depends on the `eco` gem.
   #
   # For more infomation see:
   #
   #   https://github.com/sstephenson/ruby-eco
   #   https://github.com/sstephenson/eco
   #
-  class EcoTemplate < Tilt::Template
-    # Check to see if Eco is loaded
-    def self.engine_initialized?
-      defined? ::Eco
-    end
-
-    # Autoload eco library. If the library isn't loaded, Tilt will produce
-    # a thread safetly warning. If you intend to use `.eco` files, you
-    # should explicitly require it.
-    def initialize_engine
-      require_template_library 'eco'
-    end
-
-    def prepare
-    end
+  module EcoTemplate
+    VERSION = '1'
 
     # Compile template data with Eco compiler.
     #
@@ -31,8 +18,12 @@ module Sprockets
     #
     #     # => "function(...) {...}"
     #
-    def evaluate(scope, locals, &block)
-      Eco.compile(data)
+    def self.call(input)
+      data = input[:data]
+      key  = ['EcoTemplate', ::Eco::Source::VERSION, VERSION, data]
+      input[:cache].fetch(key) do
+        ::Eco.compile(data)
+      end
     end
   end
 end

data/lib/sprockets/ejs_template.rb

@@ -1,27 +1,14 @@
-require 'tilt'
+require 'ejs'
 
 module Sprockets
-  # Tilt engine class for the EJS compiler. Depends on the `ejs` gem.
+  # Template 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
-
-    def prepare
-    end
+  module EjsTemplate
+    VERSION = '1'
 
     # Compile template data with EJS compiler.
     #
@@ -30,8 +17,12 @@ module Sprockets
     #
     #     # => "function(obj){...}"
     #
-    def evaluate(scope, locals, &block)
-      EJS.compile(data)
+    def self.call(input)
+      data = input[:data]
+      key  = ['EjsTemplate', VERSION, data]
+      input[:cache].fetch(key) do
+        ::EJS.compile(data)
+      end
     end
   end
 end

data/lib/sprockets/encoding_utils.rb

@@ -0,0 +1,246 @@
+require 'base64'
+require 'stringio'
+require 'zlib'
+
+module Sprockets
+  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
+
+    # Public: Alias for CodingUtils.deflate
+    DEFLATE = method(:deflate)
+
+    # 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: Alias for CodingUtils.gzip
+    GZIP = method(:gzip)
+
+    # Public: Use base64 to encode data.
+    #
+    # str - String data
+    #
+    # Returns a encoded String
+    def base64(str)
+      Base64.strict_encode64(str)
+    end
+
+    # Public: Alias for CodingUtils.base64
+    BASE64 = method(:base64)
+
+
+    ## Charset encodings ##
+
+    # 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 UTF-8
+      if str.encoding == Encoding::BINARY
+        str.force_encoding(Encoding.default_external)
+      end
+
+      str
+    end
+
+    # Public: Alias for EncodingUtils.detect_unicode
+    DETECT = 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
+
+    # Public: Alias for EncodingUtils.detect_unicode
+    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
+
+    # Public: Alias for EncodingUtils.detect_css
+    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. Defaults to ISO-8859-1.
+    #
+    # 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 ISO-8859-1
+      if str.encoding == Encoding::BINARY
+        str.force_encoding(Encoding::ISO_8859_1)
+      end
+
+      str
+    end
+
+    # Public: Alias for EncodingUtils.detect_html
+    DETECT_HTML = method(:detect_html)
+  end
+end

data/lib/sprockets/engines.rb

@@ -1,13 +1,11 @@
-require 'sprockets/eco_template'
-require 'sprockets/ejs_template'
-require 'sprockets/jst_processor'
+require 'sprockets/lazy_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.
   #
@@ -15,8 +13,8 @@ module Sprockets
   # left. `application.js.coffee.erb` will first run `ERBTemplate`
   # then `CoffeeScriptTemplate`.
   #
-  # 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.
@@ -35,24 +33,24 @@ module Sprockets
     #     environment.engines
     #     # => {".coffee" => CoffeeScriptTemplate, ".sass" => SassTemplate, ...}
     #
-    #     environment.engines('.coffee')
-    #     # => CoffeeScriptTemplate
+    attr_reader :engines
+
+    # Internal: Returns a `Hash` of engine extensions to mime types.
     #
-    def engines(ext = nil)
-      if ext
-        ext = Sprockets::Utils.normalize_extension(ext)
-        @engines[ext]
-      else
-        @engines.dup
-      end
-    end
+    # # => { '.coffee' => 'application/javascript' }
+    attr_reader :engine_mime_types
 
-    # Returns an `Array` of engine extension `String`s.
+    # Internal: Find and load engines by extension.
     #
-    #     environment.engine_extensions
-    #     # => ['.coffee', '.sass', ...]
-    def engine_extensions
-      @engines.keys
+    # extnames - Array of String extnames
+    #
+    # Returns Array of Procs.
+    def unwrap_engines(extnames)
+      extnames.map { |ext|
+        engines[ext]
+      }.map { |engine|
+        unwrap_processor(engine)
+      }
     end
 
     # Registers a new Engine `klass` for `ext`. If the `ext` already
@@ -60,15 +58,28 @@ module Sprockets
     #
     #     environment.register_engine '.coffee', CoffeeScriptTemplate
     #
-    def register_engine(ext, klass)
+    def register_engine(ext, klass, options = {})
       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 }
+      if klass.class == Sprockets::LazyProcessor || klass.respond_to?(:call)
+        mutate_config(:engines) do |engines|
+          engines.merge(ext => klass)
+        end
+        if options[:mime_type]
+          mutate_config(:engine_mime_types) do |mime_types|
+            mime_types.merge(ext.to_s => options[:mime_type])
+          end
+        end
+      else
+        mutate_config(:engines) do |engines|
+          engines.merge(ext => LegacyTiltProcessor.new(klass))
+        end
+        if klass.respond_to?(:default_mime_type) && klass.default_mime_type
+          mutate_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,5 @@
 require 'sprockets/base'
-require 'sprockets/context'
-require 'sprockets/index'
-
-require 'hike'
-require 'logger'
-require 'pathname'
-require 'tilt'
+require 'sprockets/cached_environment'
 
 module Sprockets
   class Environment < Base
@@ -15,74 +9,24 @@ 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)
+      @root = File.expand_path(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)
-
-      # 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_asset(*args)
+      cached.find_asset(*args)
     end
-
-    protected
-      def expire_index!
-        # Clear digest to be recomputed
-        @digest = nil
-        @assets = {}
-      end
   end
 end