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

data/vendor/sprockets/lib/sprockets/caching.rb

@@ -1,126 +0,0 @@
-require 'sprockets/bundled_asset'
-require 'sprockets/static_asset'
-
-module Sprockets
-  # `Caching` is an internal mixin whose public methods are exposed on
-  # the `Environment` and `Index` classes.
-  module Caching
-    # Return `Asset` instance for serialized `Hash`.
-    def asset_from_hash(hash)
-      return unless hash.is_a?(Hash)
-      case hash['class']
-      when 'BundledAsset'
-        BundledAsset.from_hash(self, hash)
-      when 'StaticAsset'
-        StaticAsset.from_hash(self, hash)
-      else
-        nil
-      end
-    end
-
-    def cache_hash(key, version)
-      if cache.nil?
-        yield
-      elsif hash = cache_get_hash(key, version)
-        hash
-      elsif hash = yield
-        cache_set_hash(key, version, hash)
-        hash
-      end
-    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(cache_get_hash(path.to_s, digest.hexdigest))) && asset.fresh?
-          asset
-
-         # Otherwise yield block that slowly finds and builds the asset
-        elsif asset = yield
-          hash = {}
-          asset.encode_with(hash)
-
-          # Save the asset to at its path
-          cache_set_hash(path.to_s, digest.hexdigest, 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, digest.hexdigest, hash)
-          end
-
-          asset
-        end
-      end
-
-    private
-      def cache_key_namespace
-        'sprockets'
-      end
-
-      # Removes `Environment#root` from key and prepends
-      # `Environment#cache_key_namespace`.
-      def cache_key_for(key)
-        File.join(cache_key_namespace, key.sub(root, ''))
-      end
-
-      def cache_get_hash(key, version)
-        hash = cache_get(cache_key_for(key))
-        if hash.is_a?(Hash) && version == hash['_version']
-          hash
-        end
-      end
-
-      def cache_set_hash(key, version, hash)
-        hash['_version'] = version
-        cache_set(cache_key_for(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/vendor/sprockets/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/vendor/sprockets/lib/sprockets/context.rb

@@ -1,221 +0,0 @@
-require 'base64'
-require 'rack/utils'
-require 'sprockets/errors'
-require 'sprockets/utils'
-require 'pathname'
-require 'set'
-
-module Sprockets
-  # `Context` provides helper methods to all `Tilt` processors. They
-  # are typically accessed by ERB templates. You can mix in custom
-  # helpers by injecting them into `Environment#context_class`. Do not
-  # mix them into `Context` directly.
-  #
-  #     environment.instance_eval do
-  #       include MyHelper
-  #       def asset_url; end
-  #     end
-  #
-  #     <%= asset_url "foo.png" %>
-  #
-  # The `Context` also collects dependencies declared by
-  # assets. See `DirectiveProcessor` for an example of this.
-  class Context
-    attr_reader :environment, :pathname
-    attr_reader :_required_paths, :_dependency_paths, :_dependency_assets
-    attr_writer :__LINE__
-
-    def initialize(environment, logical_path, pathname)
-      @environment  = environment
-      @logical_path = logical_path
-      @pathname     = pathname
-      @__LINE__     = nil
-
-      @_required_paths    = []
-      @_dependency_paths  = Set.new([pathname.to_s])
-      @_dependency_assets = Set.new
-    end
-
-    # Returns the environment path that contains the file.
-    #
-    # If `app/javascripts` and `app/stylesheets` are in your path, and
-    # current file is `app/javascripts/foo/bar.js`, `root_path` would
-    # return `app/javascripts`.
-    def root_path
-      environment.paths.detect { |path| pathname.to_s[path] }
-    end
-
-    # Returns logical path without any file extensions.
-    #
-    #     'app/javascripts/application.js'
-    #     # => 'application'
-    #
-    def logical_path
-      @logical_path[/^([^.]+)/, 0]
-    end
-
-    # Returns content type of file
-    #
-    #     'application/javascript'
-    #     'text/css'
-    #
-    def content_type
-      environment.content_type_of(pathname)
-    end
-
-    # Given a logical path, `resolve` will find and return the fully
-    # expanded path. Relative paths will also be resolved. An optional
-    # `:content_type` restriction can be supplied to restrict the
-    # search.
-    #
-    #     resolve("foo.js")
-    #     # => "/path/to/app/javascripts/foo.js"
-    #
-    #     resolve("./bar.js")
-    #     # => "/path/to/app/javascripts/bar.js"
-    #
-    def resolve(path, options = {}, &block)
-      pathname   = Pathname.new(path)
-      attributes = environment.attributes_for(pathname)
-
-      if pathname.absolute?
-        pathname
-
-      elsif content_type = options[:content_type]
-        content_type = self.content_type if content_type == :self
-
-        if attributes.format_extension
-          if content_type != attributes.content_type
-            raise ContentTypeMismatch, "#{path} is " +
-              "'#{attributes.content_type}', not '#{content_type}'"
-          end
-        end
-
-        resolve(path) do |candidate|
-          if self.content_type == environment.content_type_of(candidate)
-            return candidate
-          end
-        end
-
-        raise FileNotFound, "couldn't find file '#{path}'"
-      else
-        environment.resolve(path, :base_path => self.pathname.dirname, &block)
-      end
-    end
-
-    # `depend_on` allows you to state a dependency on a file without
-    # including it.
-    #
-    # This is used for caching purposes. Any changes made to
-    # the dependency file with invalidate the cache of the
-    # source file.
-    def depend_on(path)
-      @_dependency_paths << resolve(path).to_s
-      nil
-    end
-
-    # `depend_on_asset` allows you to state an asset dependency
-    # without including it.
-    #
-    # This is used for caching purposes. Any changes that would
-    # invalidate the dependency asset will invalidate the source
-    # file. Unlike `depend_on`, this will include recursively include
-    # the target asset's dependencies.
-    def depend_on_asset(path)
-      filename = resolve(path).to_s
-      @_dependency_assets << filename
-      nil
-    end
-
-    # `require_asset` declares `path` as a dependency of the file. The
-    # dependency will be inserted before the file and will only be
-    # included once.
-    #
-    # If ERB processing is enabled, you can use it to dynamically
-    # require assets.
-    #
-    #     <%= require_asset "#{framework}.js" %>
-    #
-    def require_asset(path)
-      pathname = resolve(path, :content_type => :self)
-      depend_on_asset(pathname)
-      @_required_paths << pathname.to_s
-      nil
-    end
-
-    # Tests if target path is able to be safely required into the
-    # current concatenation.
-    def asset_requirable?(path)
-      pathname = resolve(path)
-      content_type = environment.content_type_of(pathname)
-      pathname.file? && (self.content_type.nil? || self.content_type == content_type)
-    end
-
-    # Reads `path` and runs processors on the file.
-    #
-    # This allows you to capture the result of an asset and include it
-    # directly in another.
-    #
-    #     <%= evaluate "bar.js" %>
-    #
-    def evaluate(path, options = {})
-      start_time = Time.now.to_f
-      pathname   = resolve(path)
-      attributes = environment.attributes_for(pathname)
-      processors = options[:processors] || attributes.processors
-
-      if options[:data]
-        result = options[:data]
-      else
-        result = Sprockets::Utils.read_unicode(pathname)
-      end
-
-      processors.each do |processor|
-        begin
-          template = processor.new(pathname.to_s) { result }
-          result = template.render(self, {})
-        rescue Exception => e
-          annotate_exception! e
-          raise
-        end
-      end
-
-      elapsed_time = ((Time.now.to_f - start_time) * 1000).to_i
-      logger.info "Compiled #{attributes.pretty_path}  (#{elapsed_time}ms)  (pid #{Process.pid})"
-
-      result
-    end
-
-    # Returns a Base64-encoded `data:` URI with the contents of the
-    # asset at the specified path, and marks that path as a dependency
-    # of the current file.
-    #
-    # Use `asset_data_uri` from ERB with CSS or JavaScript assets:
-    #
-    #     #logo { background: url(<%= asset_data_uri 'logo.png' %>) }
-    #
-    #     $('<img>').attr('src', '<%= asset_data_uri 'avatar.jpg' %>')
-    #
-    def asset_data_uri(path)
-      depend_on(path)
-      asset  = environment.find_asset(path)
-      base64 = Base64.encode64(asset.to_s).gsub(/\s+/, "")
-      "data:#{asset.content_type};base64,#{Rack::Utils.escape(base64)}"
-    end
-
-    private
-      # Annotates exception backtrace with the original template that
-      # the exception was raised in.
-      def annotate_exception!(exception)
-        location = pathname.to_s
-        location << ":#{@__LINE__}" if @__LINE__
-
-        exception.extend(Sprockets::EngineError)
-        exception.sprockets_annotation = "  (in #{location})"
-      end
-
-      def logger
-        environment.logger
-      end
-  end
-end

data/vendor/sprockets/lib/sprockets/digest.rb

@@ -1,73 +0,0 @@
-module Sprockets
-  # `Digest` is an internal mixin whose public methods are exposed on
-  # the `Environment` and `Index` classes.
-  module Digest
-    # Returns a `Digest` implementation class.
-    #
-    # Defaults to `Digest::MD5`.
-    def digest_class
-      @digest_class
-    end
-
-    # Assign a `Digest` implementation class. This maybe any Ruby
-    # `Digest::` implementation such as `Digest::MD5` or
-    # `Digest::SHA1`.
-    #
-    #     environment.digest_class = Digest::SHA1
-    #
-    def digest_class=(klass)
-      expire_index!
-      @digest_class = klass
-    end
-
-    # The `Environment#version` is a custom value used for manually
-    # expiring all asset caches.
-    #
-    # Sprockets is able to track most file and directory changes and
-    # will take care of expiring the cache for you. However, its
-    # impossible to know when any custom helpers change that you mix
-    # into the `Context`.
-    #
-    # It would be wise to increment this value anytime you make a
-    # configuration change to the `Environment` object.
-    def version
-      @version
-    end
-
-    # Assign an environment version.
-    #
-    #     environment.version = '2.0'
-    #
-    def version=(version)
-      expire_index!
-      @version = version
-    end
-
-    # Returns a `Digest` instance for the `Environment`.
-    #
-    # This value serves two purposes. If two `Environment`s have the
-    # same digest value they can be treated as equal. This is more
-    # useful for comparing environment states between processes rather
-    # than in the same. Two equal `Environment`s can share the same
-    # cached assets.
-    #
-    # The value also provides a seed digest for all `Asset`
-    # digests. Any change in the environment digest will affect all of
-    # its assets.
-    def digest
-      # Recompute digest for the first time or again after its been cleared
-      @digest ||= compute_digest
-
-      # Returned a dupped copy so the caller can safely mutate it with `.update`
-      @digest.dup
-    end
-
-    protected
-      def compute_digest
-        # Compute the initial digest using the implementation
-        # class. The Sprockets release version and custom environment
-        # version are mixed in.
-        digest_class.new.update(VERSION).update(version.to_s)
-      end
-  end
-end