sprockets 2.3.2 → 3.0.0

data/lib/sprockets/bundled_asset.rb

@@ -1,79 +0,0 @@
-require 'sprockets/asset'
-require 'sprockets/errors'
-require 'fileutils'
-require 'set'
-require 'zlib'
-
-module Sprockets
-  # `BundledAsset`s are used for files that need to be processed and
-  # concatenated with other assets. Use for `.js` and `.css` files.
-  class BundledAsset < Asset
-    attr_reader :source
-
-    def initialize(environment, logical_path, pathname)
-      super(environment, logical_path, pathname)
-
-      @processed_asset = environment.find_asset(pathname, :bundle => false)
-      @required_assets = @processed_asset.required_assets
-
-      @source = ""
-
-      # Explode Asset into parts and gather the dependency bodies
-      to_a.each { |dependency| @source << dependency.to_s }
-
-      # Run bundle processors on concatenated source
-      context = environment.context_class.new(environment, logical_path, pathname)
-      @source = context.evaluate(pathname, :data => @source,
-                  :processors => environment.bundle_processors(content_type))
-
-      @mtime  = to_a.map(&:mtime).max
-      @length = Rack::Utils.bytesize(source)
-      @digest = environment.digest.update(source).hexdigest
-    end
-
-    # Initialize `BundledAsset` from serialized `Hash`.
-    def init_with(environment, coder)
-      super
-
-      @processed_asset = environment.find_asset(pathname, :bundle => false)
-      @required_assets = @processed_asset.required_assets
-
-      if @processed_asset.dependency_digest != coder['required_assets_digest']
-        raise UnserializeError, "processed asset belongs to a stale environment"
-      end
-
-      @source = coder['source']
-    end
-
-    # Serialize custom attributes in `BundledAsset`.
-    def encode_with(coder)
-      super
-
-      coder['source'] = source
-      coder['required_assets_digest'] = @processed_asset.dependency_digest
-    end
-
-    # Get asset's own processed contents. Excludes any of its required
-    # dependencies but does run any processors or engines on the
-    # original file.
-    def body
-      @processed_asset.source
-    end
-
-    # Return an `Array` of `Asset` files that are declared dependencies.
-    def dependencies
-      to_a.reject { |a| a.eql?(@processed_asset) }
-    end
-
-    # Expand asset into an `Array` of parts.
-    def to_a
-      required_assets
-    end
-
-    # Checks if Asset is stale by comparing the actual mtime and
-    # digest to the inmemory model.
-    def fresh?(environment)
-      @processed_asset.fresh?(environment)
-    end
-  end
-end

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
-    # 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
-
-    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
-  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/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/scss_template.rb

@@ -1,13 +0,0 @@
-require 'sprockets/sass_template'
-
-module Sprockets
-  # Scss handler to replace Tilt's builtin one. See `SassTemplate` and
-  # `SassImporter` for more infomation.
-  class ScssTemplate < SassTemplate
-    self.default_mime_type = 'text/css'
-
-    def syntax
-      :scss
-    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

data/lib/sprockets/trail.rb

@@ -1,90 +0,0 @@
-require 'sprockets/errors'
-require 'pathname'
-
-module Sprockets
-  # `Trail` is an internal mixin whose public methods are exposed on
-  # the `Environment` and `Index` classes.
-  module Trail
-    # Returns `Environment` root.
-    #
-    # All relative paths are expanded with root as its base. To be
-    # useful set this to your applications root directory. (`Rails.root`)
-    def root
-      trail.root.dup
-    end
-
-    # Returns an `Array` of path `String`s.
-    #
-    # These paths will be used for asset logical path lookups.
-    #
-    # Note that a copy of the `Array` is returned so mutating will
-    # have no affect on the environment. See `append_path`,
-    # `prepend_path`, and `clear_paths`.
-    def paths
-      trail.paths.dup
-    end
-
-    # Prepend a `path` to the `paths` list.
-    #
-    # Paths at the end of the `Array` have the least priority.
-    def prepend_path(path)
-      expire_index!
-      @trail.prepend_path(path)
-    end
-
-    # Append a `path` to the `paths` list.
-    #
-    # Paths at the beginning of the `Array` have a higher priority.
-    def append_path(path)
-      expire_index!
-      @trail.append_path(path)
-    end
-
-    # Clear all paths and start fresh.
-    #
-    # There is no mechanism for reordering paths, so its best to
-    # completely wipe the paths list and reappend them in the order
-    # you want.
-    def clear_paths
-      expire_index!
-      @trail.paths.dup.each { |path| @trail.remove_path(path) }
-    end
-
-    # Returns an `Array` of extensions.
-    #
-    # These extensions maybe omitted from logical path searches.
-    #
-    #     # => [".js", ".css", ".coffee", ".sass", ...]
-    #
-    def extensions
-      trail.extensions.dup
-    end
-
-    # Finds the expanded real path for a given logical path by
-    # searching the environment's paths.
-    #
-    #     resolve("application.js")
-    #     # => "/path/to/app/javascripts/application.js.coffee"
-    #
-    # A `FileNotFound` exception is raised if the file does not exist.
-    def resolve(logical_path, options = {})
-      # If a block is given, preform an iterable search
-      if block_given?
-        args = attributes_for(logical_path).search_paths + [options]
-        trail.find(*args) do |path|
-          yield Pathname.new(path)
-        end
-      else
-        resolve(logical_path, options) do |pathname|
-          return pathname
-        end
-        raise FileNotFound, "couldn't find file '#{logical_path}'"
-      end
-    end
-
-    protected
-      def trail
-        @trail
-      end
-  end
-end