sprockets 2.2.3 → 4.0.0

data/lib/sprockets/caching.rb

@@ -1,96 +0,0 @@
-module Sprockets
-  # `Caching` is an internal mixin whose public methods are exposed on
-  # the `Environment` and `Index` classes.
-  module Caching
-    protected
-      # Cache helper method. Takes a `path` argument which maybe a
-      # logical path or fully expanded path. The `&block` is passed
-      # for finding and building the asset if its not in cache.
-      def cache_asset(path)
-        # If `cache` is not set, return fast
-        if cache.nil?
-          yield
-
-        # Check cache for `path`
-        elsif (asset = Asset.from_hash(self, cache_get_hash(path.to_s))) && asset.fresh?(self)
-          asset
-
-         # Otherwise yield block that slowly finds and builds the asset
-        elsif asset = yield
-          hash = {}
-          asset.encode_with(hash)
-
-          # Save the asset to its path
-          cache_set_hash(path.to_s, hash)
-
-          # Since path maybe a logical or full pathname, save the
-          # asset its its full path too
-          if path.to_s != asset.pathname.to_s
-            cache_set_hash(asset.pathname.to_s, hash)
-          end
-
-          asset
-        end
-      end
-
-    private
-      # Strips `Environment#root` from key to make the key work
-      # consisently across different servers. The key is also hashed
-      # so it does not exceed 250 characters.
-      def expand_cache_key(key)
-        File.join('sprockets', digest_class.hexdigest(key.sub(root, '')))
-      end
-
-      def cache_get_hash(key)
-        hash = cache_get(expand_cache_key(key))
-        if hash.is_a?(Hash) && digest.hexdigest == hash['_version']
-          hash
-        end
-      end
-
-      def cache_set_hash(key, hash)
-        hash['_version'] = digest.hexdigest
-        cache_set(expand_cache_key(key), hash)
-        hash
-      end
-
-      # Low level cache getter for `key`. Checks a number of supported
-      # cache interfaces.
-      def cache_get(key)
-        # `Cache#get(key)` for Memcache
-        if cache.respond_to?(:get)
-          cache.get(key)
-
-        # `Cache#[key]` so `Hash` can be used
-        elsif cache.respond_to?(:[])
-          cache[key]
-
-        # `Cache#read(key)` for `ActiveSupport::Cache` support
-        elsif cache.respond_to?(:read)
-          cache.read(key)
-
-        else
-          nil
-        end
-      end
-
-      # Low level cache setter for `key`. Checks a number of supported
-      # cache interfaces.
-      def cache_set(key, value)
-        # `Cache#set(key, value)` for Memcache
-        if cache.respond_to?(:set)
-          cache.set(key, value)
-
-        # `Cache#[key]=value` so `Hash` can be used
-        elsif cache.respond_to?(:[]=)
-          cache[key] = value
-
-        # `Cache#write(key, value)` for `ActiveSupport::Cache` support
-        elsif cache.respond_to?(:write)
-          cache.write(key, value)
-        end
-
-        value
-      end
-  end
-end

data/lib/sprockets/charset_normalizer.rb

@@ -1,41 +0,0 @@
-require 'tilt'
-
-module Sprockets
-  # Some browsers have issues with stylesheets that contain multiple
-  # `@charset` definitions. The issue surfaces while using Sass since
-  # it inserts a `@charset` at the top of each file. Then Sprockets
-  # concatenates them together.
-  #
-  # The `CharsetNormalizer` processor strips out multiple `@charset`
-  # definitions.
-  #
-  # The current implementation is naive. It picks the first `@charset`
-  # it sees and strips the others. This works for most people because
-  # the other definitions are usually `UTF-8`. A more sophisticated
-  # approach would be to re-encode stylesheets with mixed encodings.
-  #
-  # This behavior can be disabled with:
-  #
-  #     environment.unregister_bundle_processor 'text/css', Sprockets::CharsetNormalizer
-  #
-  class CharsetNormalizer < Tilt::Template
-    def prepare
-    end
-
-    def evaluate(context, locals, &block)
-      charset = nil
-
-      # Find and strip out any `@charset` definitions
-      filtered_data = data.gsub(/^@charset "([^"]+)";$/) {
-        charset ||= $1; ""
-      }
-
-      if charset
-        # If there was a charset, move it to the top
-        "@charset \"#{charset}\";#{filtered_data}"
-      else
-        data
-      end
-    end
-  end
-end

data/lib/sprockets/eco_template.rb

@@ -1,38 +0,0 @@
-require 'tilt'
-
-module Sprockets
-  # Tilt 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
-
-    # Compile template data with Eco compiler.
-    #
-    # Returns a JS function definition String. The result should be
-    # assigned to a JS variable.
-    #
-    #     # => "function(...) {...}"
-    #
-    def evaluate(scope, locals, &block)
-      Eco.compile(data)
-    end
-  end
-end

data/lib/sprockets/ejs_template.rb

@@ -1,37 +0,0 @@
-require 'tilt'
-
-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
-
-    def prepare
-    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)
-    end
-  end
-end

data/lib/sprockets/engines.rb

@@ -1,74 +0,0 @@
-require 'sprockets/eco_template'
-require 'sprockets/ejs_template'
-require 'sprockets/jst_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
-  # extension. `application.js.coffee` indicates that the
-  # `CoffeeScriptTemplate` 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`.
-  #
-  # All `Engine`s must follow the `Tilt::Template` interface. It is
-  # recommended to subclass `Tilt::Template`.
-  #
-  # Its recommended that you register engine changes on your local
-  # `Environment` instance.
-  #
-  #     environment.register_engine '.foo', FooProcessor
-  #
-  # The global registry is exposed for plugins to register themselves.
-  #
-  #     Sprockets.register_engine '.sass', SassTemplate
-  #
-  module Engines
-    # Returns an `Array` of `Engine`s registered on the
-    # `Environment`. If an `ext` argument is supplied, the `Engine`
-    # register under that extension will be returned.
-    #
-    #     environment.engines
-    #     # => [CoffeeScriptTemplate, SassTemplate, ...]
-    #
-    #     environment.engines('.coffee')
-    #     # => CoffeeScriptTemplate
-    #
-    def engines(ext = nil)
-      if ext
-        ext = Sprockets::Utils.normalize_extension(ext)
-        @engines[ext]
-      else
-        @engines.dup
-      end
-    end
-
-    # Returns an `Array` of engine extension `String`s.
-    #
-    #     environment.engine_extensions
-    #     # => ['.coffee', '.sass', ...]
-    def engine_extensions
-      @engines.keys
-    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
-    #
-    def register_engine(ext, klass)
-      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 }
-      end
-  end
-end

data/lib/sprockets/index.rb

@@ -1,99 +0,0 @@
-require 'sprockets/base'
-
-module Sprockets
-  # `Index` is a special cached version of `Environment`.
-  #
-  # The expection is that all of its file system methods are cached
-  # for the instances lifetime. This makes `Index` much faster. This
-  # behavior is ideal in production environments where the file system
-  # is immutable.
-  #
-  # `Index` should not be initialized directly. Instead use
-  # `Environment#index`.
-  class Index < Base
-    def initialize(environment)
-      @environment = environment
-
-      if environment.respond_to?(:default_external_encoding)
-        @default_external_encoding = environment.default_external_encoding
-      end
-
-      # Copy environment attributes
-      @logger            = environment.logger
-      @context_class     = environment.context_class
-      @cache             = environment.cache
-      @trail             = environment.trail.index
-      @digest            = environment.digest
-      @digest_class      = environment.digest_class
-      @version           = environment.version
-      @mime_types        = environment.mime_types
-      @engines           = environment.engines
-      @preprocessors     = environment.preprocessors
-      @postprocessors    = environment.postprocessors
-      @bundle_processors = environment.bundle_processors
-
-      # Initialize caches
-      @assets  = {}
-      @digests = {}
-    end
-
-    # No-op return self as index
-    def index
-      self
-    end
-
-    # Cache calls to `file_digest`
-    def file_digest(pathname)
-      key = pathname.to_s
-      if @digests.key?(key)
-        @digests[key]
-      else
-        @digests[key] = super
-      end
-    end
-
-    # Cache `find_asset` calls
-    def find_asset(path, options = {})
-      options[:bundle] = true unless options.key?(:bundle)
-      if asset = @assets[cache_key_for(path, options)]
-        asset
-      elsif asset = super
-        logical_path_cache_key = cache_key_for(path, options)
-        full_path_cache_key    = cache_key_for(asset.pathname, options)
-
-        # Cache on Index
-        @assets[logical_path_cache_key] = @assets[full_path_cache_key] = asset
-
-        # Push cache upstream to Environment
-        @environment.instance_eval do
-          @assets[logical_path_cache_key] = @assets[full_path_cache_key] = asset
-        end
-
-        asset
-      end
-    end
-
-    protected
-      # Index is immutable, any methods that try to clear the cache
-      # should bomb.
-      def expire_index!
-        raise TypeError, "can't modify immutable index"
-      end
-
-      # Cache asset building in memory and in persisted cache.
-      def build_asset(path, pathname, options)
-        # Memory cache
-        key = cache_key_for(pathname, options)
-        if @assets.key?(key)
-          @assets[key]
-        else
-          @assets[key] = begin
-            # Persisted cache
-            cache_asset(key) do
-              super
-            end
-          end
-        end
-      end
-  end
-end

data/lib/sprockets/processed_asset.rb

@@ -1,152 +0,0 @@
-require 'sprockets/asset'
-require 'sprockets/utils'
-
-module Sprockets
-  class ProcessedAsset < Asset
-    def initialize(environment, logical_path, pathname)
-      super
-
-      start_time = Time.now.to_f
-
-      context = environment.context_class.new(environment, logical_path, pathname)
-      @source = context.evaluate(pathname)
-      @length = Rack::Utils.bytesize(source)
-      @digest = environment.digest.update(source).hexdigest
-
-      build_required_assets(environment, context)
-      build_dependency_paths(environment, context)
-
-      @dependency_digest = compute_dependency_digest(environment)
-
-      elapsed_time = ((Time.now.to_f - start_time) * 1000).to_i
-      environment.logger.info "Compiled #{logical_path}  (#{elapsed_time}ms)  (pid #{Process.pid})"
-    end
-
-    # Interal: Used to check equality
-    attr_reader :dependency_digest
-
-    attr_reader :source
-
-    # Initialize `BundledAsset` from serialized `Hash`.
-    def init_with(environment, coder)
-      super
-
-      @source = coder['source']
-      @dependency_digest = coder['dependency_digest']
-
-      @required_assets = coder['required_paths'].map { |p|
-        p = expand_root_path(p)
-
-        unless environment.paths.detect { |path| p[path] }
-          raise UnserializeError, "#{p} isn't in paths"
-        end
-
-        p == pathname.to_s ? self : environment.find_asset(p, :bundle => false)
-      }
-      @dependency_paths = coder['dependency_paths'].map { |h|
-        DependencyFile.new(expand_root_path(h['path']), h['mtime'], h['digest'])
-      }
-    end
-
-    # Serialize custom attributes in `BundledAsset`.
-    def encode_with(coder)
-      super
-
-      coder['source'] = source
-      coder['dependency_digest'] = dependency_digest
-
-      coder['required_paths'] = required_assets.map { |a|
-        relativize_root_path(a.pathname).to_s
-      }
-      coder['dependency_paths'] = dependency_paths.map { |d|
-        { 'path' => relativize_root_path(d.pathname).to_s,
-          'mtime' => d.mtime.iso8601,
-          'digest' => d.digest }
-      }
-    end
-
-    # Checks if Asset is stale by comparing the actual mtime and
-    # digest to the inmemory model.
-    def fresh?(environment)
-      # Check freshness of all declared dependencies
-      @dependency_paths.all? { |dep| dependency_fresh?(environment, dep) }
-    end
-
-    protected
-      class DependencyFile < Struct.new(:pathname, :mtime, :digest)
-        def initialize(pathname, mtime, digest)
-          pathname = Pathname.new(pathname) unless pathname.is_a?(Pathname)
-          mtime    = Time.parse(mtime) if mtime.is_a?(String)
-          super
-        end
-
-        def eql?(other)
-          other.is_a?(DependencyFile) &&
-            pathname.eql?(other.pathname) &&
-            mtime.eql?(other.mtime) &&
-            digest.eql?(other.digest)
-        end
-
-        def hash
-          pathname.to_s.hash
-        end
-      end
-
-    private
-      def build_required_assets(environment, context)
-        @required_assets = resolve_dependencies(environment, context._required_paths + [pathname.to_s]) -
-          resolve_dependencies(environment, context._stubbed_assets.to_a)
-      end
-
-      def resolve_dependencies(environment, paths)
-        assets = []
-        cache  = {}
-
-        paths.each do |path|
-          if path == self.pathname.to_s
-            unless cache[self]
-              cache[self] = true
-              assets << self
-            end
-          elsif asset = environment.find_asset(path, :bundle => false)
-            asset.required_assets.each do |asset_dependency|
-              unless cache[asset_dependency]
-                cache[asset_dependency] = true
-                assets << asset_dependency
-              end
-            end
-          end
-        end
-
-        assets
-      end
-
-      def build_dependency_paths(environment, context)
-        dependency_paths = {}
-
-        context._dependency_paths.each do |path|
-          dep = DependencyFile.new(path, environment.stat(path).mtime, environment.file_digest(path).hexdigest)
-          dependency_paths[dep] = true
-        end
-
-        context._dependency_assets.each do |path|
-          if path == self.pathname.to_s
-            dep = DependencyFile.new(pathname, environment.stat(path).mtime, environment.file_digest(path).hexdigest)
-            dependency_paths[dep] = true
-          elsif asset = environment.find_asset(path, :bundle => false)
-            asset.dependency_paths.each do |d|
-              dependency_paths[d] = true
-            end
-          end
-        end
-
-        @dependency_paths = dependency_paths.keys
-      end
-
-      def compute_dependency_digest(environment)
-        required_assets.inject(environment.digest) { |digest, asset|
-          digest.update asset.digest
-        }.hexdigest
-      end
-  end
-end

data/lib/sprockets/processor.rb

@@ -1,32 +0,0 @@
-require 'tilt'
-
-module Sprockets
-  # `Processor` creates an anonymous processor class from a block.
-  #
-  #     register_preprocessor :my_processor do |context, data|
-  #       # ...
-  #     end
-  #
-  class Processor < Tilt::Template
-    # `processor` is a lambda or block
-    def self.processor
-      @processor
-    end
-
-    def self.name
-      "Sprockets::Processor (#{@name})"
-    end
-
-    def self.to_s
-      name
-    end
-
-    def prepare
-    end
-
-    # Call processor block with `context` and `data`.
-    def evaluate(context, locals)
-      self.class.processor.call(context, data)
-    end
-  end
-end

data/lib/sprockets/safety_colons.rb

@@ -1,28 +0,0 @@
-require 'tilt'
-
-module Sprockets
-  # For JS developers who are colonfobic, concatenating JS files using
-  # the module pattern usually leads to syntax errors.
-  #
-  # The `SafetyColons` processor will insert missing semicolons to the
-  # end of the file.
-  #
-  # This behavior can be disabled with:
-  #
-  #     environment.unregister_postprocessor 'application/javascript', Sprockets::SafetyColons
-  #
-  class SafetyColons < Tilt::Template
-    def prepare
-    end
-
-    def evaluate(context, locals, &block)
-      # If the file is blank or ends in a semicolon, leave it as is
-      if data =~ /\A\s*\Z/m || data =~ /;\s*\Z/m
-        data
-      else
-        # Otherwise, append a semicolon and newline
-        "#{data};\n"
-      end
-    end
-  end
-end

data/lib/sprockets/static_asset.rb

@@ -1,57 +0,0 @@
-require 'sprockets/asset'
-require 'fileutils'
-require 'zlib'
-
-module Sprockets
-  # `StaticAsset`s are used for files that are served verbatim without
-  # any processing or concatenation. These are typical images and
-  # other binary files.
-  class StaticAsset < Asset
-    # Returns file contents as its `source`.
-    def source
-      # File is read everytime to avoid memory bloat of large binary files
-      pathname.open('rb') { |f| f.read }
-    end
-
-    # Implemented for Rack SendFile support.
-    def to_path
-      pathname.to_s
-    end
-
-    # Save asset to disk.
-    def write_to(filename, options = {})
-      # Gzip contents if filename has '.gz'
-      options[:compress] ||= File.extname(filename) == '.gz'
-
-      FileUtils.mkdir_p File.dirname(filename)
-
-      if options[:compress]
-        # Open file and run it through `Zlib`
-        pathname.open('rb') do |rd|
-          File.open("#{filename}+", 'wb') do |wr|
-            gz = Zlib::GzipWriter.new(wr, Zlib::BEST_COMPRESSION)
-            buf = ""
-            while rd.read(16384, buf)
-              gz.write(buf)
-            end
-            gz.close
-          end
-        end
-      else
-        # If no compression needs to be done, we can just copy it into place.
-        FileUtils.cp(pathname, "#{filename}+")
-      end
-
-      # Atomic write
-      FileUtils.mv("#{filename}+", filename)
-
-      # Set mtime correctly
-      File.utime(mtime, mtime, filename)
-
-      nil
-    ensure
-      # Ensure tmp file gets cleaned up
-      FileUtils.rm("#{filename}+") if File.exist?("#{filename}+")
-    end
-  end
-end