sprockets 2.11.3 → 3.7.2

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

data/lib/sprockets/processor.rb

@@ -1,32 +0,0 @@
-require 'tilt'
-
-module Sprockets
-  # `Processor` creates an anonymous processor class from a block.
-  #
-  #     register_preprocessor 'text/css', :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,58 +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)
-            gz.mtime = mtime.to_i
-            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