sprockets 2.12.5 → 3.0.0.beta.1

data/lib/sprockets/bundled_asset.rb

@@ -1,78 +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
-      @dependency_paths = @processed_asset.dependency_paths
-
-      # Explode Asset into parts and gather the dependency bodies
-      @source = to_a.map { |dependency| dependency.to_s }.join
-
-      # 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 + @dependency_paths).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,100 +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
-      @compressors       = environment.compressors
-
-      # 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.debug "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