bpm 1.0.0.beta.8 → 1.0.0.beta.9

data/vendor/sprockets/lib/sprockets/index.rb

@@ -1,81 +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)
-      # Copy environment attributes
-      @logger            = environment.logger
-      @context_class     = environment.context_class
-      @cache             = environment.cache
-      @trail             = environment.trail.index
-      @static_root       = environment.static_root
-      @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
-      @engine_formats    = environment.engine_formats
-
-      # Initialize caches
-      @assets  = {}
-      @digests = {}
-    end
-
-    # No-op return self as index
-    def index
-      self
-    end
-
-    # Cache calls to `file_digest`
-    def file_digest(pathname, data = nil)
-      memoize(@digests, pathname.to_s) { super }
-    end
-
-    # Cache `find_asset` calls
-    def find_asset(path, options = {})
-      if asset = @assets[path.to_s]
-        asset
-      elsif asset = super
-        # Cache at logical path and expanded path
-        @assets[path.to_s] = @assets[asset.pathname.to_s] = asset
-        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
-        memoize(@assets, pathname.to_s) do
-          # Persisted cache
-          cache_asset(pathname.to_s) do
-            super
-          end
-        end
-      end
-
-    private
-      # Simple memoize helper that stores `nil` values
-      def memoize(hash, key)
-        hash.key?(key) ? hash[key] : hash[key] = yield
-      end
-  end
-end

data/vendor/sprockets/lib/sprockets/jst_processor.rb

@@ -1,26 +0,0 @@
-require 'tilt'
-
-module Sprockets
-  class JstProcessor < Tilt::Template
-    def self.default_mime_type
-      'application/javascript'
-    end
-
-    def prepare
-    end
-
-    def evaluate(scope, locals, &block)
-      <<-JST
-(function() {
-  this.JST || (this.JST = {});
-  this.JST[#{scope.logical_path.inspect}] = #{indent(data)};
-}).call(this);
-      JST
-    end
-
-    private
-      def indent(string)
-        string.gsub(/$(.)/m, "\\1  ").strip
-      end
-  end
-end

data/vendor/sprockets/lib/sprockets/mime.rb

@@ -1,38 +0,0 @@
-require 'rack/mime'
-
-module Sprockets
-  module Mime
-    # Returns a `Hash` of registered mime types registered on the
-    # environment and those part of `Rack::Mime`.
-    #
-    # If an `ext` is given, it will lookup the mime type for that extension.
-    def mime_types(ext = nil)
-      if ext.nil?
-        Rack::Mime::MIME_TYPES.merge(@mime_types)
-      else
-        ext = Sprockets::Utils.normalize_extension(ext)
-        @mime_types[ext] || Rack::Mime::MIME_TYPES[ext]
-      end
-    end
-
-    if {}.respond_to?(:key)
-      def extension_for_mime_type(type)
-        mime_types.key(type)
-      end
-    else
-      def extension_for_mime_type(type)
-        mime_types.index(type)
-      end
-    end
-
-    # Register a new mime type.
-    def register_mime_type(mime_type, ext)
-      ext = Sprockets::Utils.normalize_extension(ext)
-      @mime_types[ext] = mime_type
-    end
-  end
-
-  # Extend Sprockets module to provide global registry
-  extend Mime
-  @mime_types = {}
-end

data/vendor/sprockets/lib/sprockets/processing.rb

@@ -1,269 +0,0 @@
-require 'sprockets/engines'
-require 'sprockets/mime'
-require 'sprockets/processor'
-require 'sprockets/utils'
-
-module Sprockets
-  # `Processing` is an internal mixin whose public methods are exposed on
-  # the `Environment` and `Index` classes.
-  module Processing
-    include Engines, Mime
-
-    # Register a new mime type.
-    def register_mime_type(mime_type, ext)
-      # Overrides the global behavior to expire the index
-      expire_index!
-      @trail.extensions << ext
-      super
-    end
-
-    # Returns an `Array` of format extension `String`s.
-    #
-    #     format_extensions
-    #     # => ['.js', '.css']
-    #
-    def format_extensions
-      @trail.extensions - @engines.keys
-    end
-
-    # Registers a new Engine `klass` for `ext`.
-    def register_engine(ext, klass)
-      # Overrides the global behavior to expire the index
-      expire_index!
-      @trail.extensions << ext.to_s
-      super
-    end
-
-    # Deprecated alias for `preprocessors`.
-    def processors(*args)
-      preprocessors(*args)
-    end
-
-    # Returns an `Array` of `Processor` classes. If a `mime_type`
-    # argument is supplied, the processors registered under that
-    # extension will be returned.
-    #
-    # Preprocessors are ran before Postprocessors and Engine
-    # processors.
-    #
-    # All `Processor`s must follow the `Tilt::Template` interface. It is
-    # recommended to subclass `Tilt::Template`.
-    def preprocessors(mime_type = nil)
-      if mime_type
-        @preprocessors[mime_type].dup
-      else
-        deep_copy_hash(@preprocessors)
-      end
-    end
-
-    # Returns an `Array` of `Processor` classes. If a `mime_type`
-    # argument is supplied, the processors registered under that
-    # extension will be returned.
-    #
-    # Postprocessors are ran after Postprocessors and Engine processors.
-    #
-    # All `Processor`s must follow the `Tilt::Template` interface. It is
-    # recommended to subclass `Tilt::Template`.
-    def postprocessors(mime_type = nil)
-      if mime_type
-        @postprocessors[mime_type].dup
-      else
-        deep_copy_hash(@postprocessors)
-      end
-    end
-
-    # Deprecated alias for `register_preprocessor`.
-    def register_processor(*args, &block)
-      register_preprocessor(*args, &block)
-    end
-
-    # Registers a new Preprocessor `klass` for `mime_type`.
-    #
-    #     register_preprocessor 'text/css', Sprockets::DirectiveProcessor
-    #
-    # A block can be passed for to create a shorthand processor.
-    #
-    #     register_preprocessor :my_processor do |context, data|
-    #       data.gsub(...)
-    #     end
-    #
-    def register_preprocessor(mime_type, klass, &block)
-      expire_index!
-
-      if block_given?
-        name  = klass.to_s
-        klass = Class.new(Processor) do
-          @name      = name
-          @processor = block
-        end
-      end
-
-      @preprocessors[mime_type].push(klass)
-    end
-
-    # Registers a new Postprocessor `klass` for `mime_type`.
-    #
-    #     register_postprocessor 'text/css', Sprockets::CharsetNormalizer
-    #
-    # A block can be passed for to create a shorthand processor.
-    #
-    #     register_postprocessor :my_processor do |context, data|
-    #       data.gsub(...)
-    #     end
-    #
-    def register_postprocessor(mime_type, klass, &block)
-      expire_index!
-
-      if block_given?
-        name  = klass.to_s
-        klass = Class.new(Processor) do
-          @name      = name
-          @processor = block
-        end
-      end
-
-      @postprocessors[mime_type].push(klass)
-    end
-
-    # Deprecated alias for `unregister_preprocessor`.
-    def unregister_processor(*args)
-      unregister_preprocessor(*args)
-    end
-
-    # Remove Preprocessor `klass` for `mime_type`.
-    #
-    #     unregister_preprocessor 'text/css', Sprockets::DirectiveProcessor
-    #
-    def unregister_preprocessor(mime_type, klass)
-      expire_index!
-
-      if klass.is_a?(String) || klass.is_a?(Symbol)
-        klass = @preprocessors[mime_type].detect { |cls|
-          cls.respond_to?(:name) &&
-            cls.name == "Sprockets::Processor (#{klass})"
-        }
-      end
-
-      @preprocessors[mime_type].delete(klass)
-    end
-
-    # Remove Postprocessor `klass` for `mime_type`.
-    #
-    #     unregister_postprocessor 'text/css', Sprockets::DirectiveProcessor
-    #
-    def unregister_postprocessor(mime_type, klass)
-      expire_index!
-
-      if klass.is_a?(String) || klass.is_a?(Symbol)
-        klass = @postprocessors[mime_type].detect { |cls|
-          cls.respond_to?(:name) &&
-            cls.name == "Sprockets::Processor (#{klass})"
-        }
-      end
-
-      @postprocessors[mime_type].delete(klass)
-    end
-
-    # Returns an `Array` of `Processor` classes. If a `mime_type`
-    # argument is supplied, the processors registered under that
-    # extension will be returned.
-    #
-    # Bundle Processors are ran on concatenated assets rather than
-    # individual files.
-    #
-    # All `Processor`s must follow the `Tilt::Template` interface. It is
-    # recommended to subclass `Tilt::Template`.
-    def bundle_processors(mime_type = nil)
-      if mime_type
-        @bundle_processors[mime_type].dup
-      else
-        deep_copy_hash(@bundle_processors)
-      end
-    end
-
-    # Registers a new Bundle Processor `klass` for `mime_type`.
-    #
-    #     register_bundle_processor  'text/css', Sprockets::CharsetNormalizer
-    #
-    # A block can be passed for to create a shorthand processor.
-    #
-    #     register_bundle_processor :my_processor do |context, data|
-    #       data.gsub(...)
-    #     end
-    #
-    def register_bundle_processor(mime_type, klass, &block)
-      expire_index!
-
-      if block_given?
-        name  = klass.to_s
-        klass = Class.new(Processor) do
-          @name      = name
-          @processor = block
-        end
-      end
-
-      @bundle_processors[mime_type].push(klass)
-    end
-
-    # Remove Bundle Processor `klass` for `mime_type`.
-    #
-    #     unregister_bundle_processor 'text/css', Sprockets::CharsetNormalizer
-    #
-    def unregister_bundle_processor(mime_type, klass)
-      expire_index!
-
-      if klass.is_a?(String) || klass.is_a?(Symbol)
-        klass = @bundle_processors[mime_type].detect { |cls|
-          cls.respond_to?(:name) &&
-            cls.name == "Sprockets::Processor (#{klass})"
-        }
-      end
-
-      @bundle_processors[mime_type].delete(klass)
-    end
-
-    # Return CSS compressor or nil if none is set
-    def css_compressor
-      bundle_processors('text/css').detect { |klass|
-        klass.respond_to?(:name) &&
-          klass.name == 'Sprockets::Processor (css_compressor)'
-      }
-    end
-
-    # Assign a compressor to run on `text/css` assets.
-    #
-    # The compressor object must respond to `compress` or `compile`.
-    def css_compressor=(compressor)
-      expire_index!
-
-      unregister_bundle_processor 'text/css', :css_compressor
-      return unless compressor
-
-      register_bundle_processor 'text/css', :css_compressor do |context, data|
-        compressor.compress(data)
-      end
-    end
-
-    # Return JS compressor or nil if none is set
-    def js_compressor
-      bundle_processors('application/javascript').detect { |klass|
-        klass.respond_to?(:name) &&
-          klass.name == 'Sprockets::Processor (js_compressor)'
-      }
-    end
-
-    # Assign a compressor to run on `application/javascript` assets.
-    #
-    # The compressor object must respond to `compress` or `compile`.
-    def js_compressor=(compressor)
-      expire_index!
-
-      unregister_bundle_processor 'application/javascript', :js_compressor
-      return unless compressor
-
-      register_bundle_processor 'application/javascript', :js_compressor do |context, data|
-        compressor.compress(data)
-      end
-    end
-  end
-end

data/vendor/sprockets/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/vendor/sprockets/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