bpm 0.1.4 → 1.0.0.beta.4

data/vendor/sprockets/lib/sprockets/bundled_asset.rb

@@ -8,6 +8,11 @@ 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
+    # Define extra attributes to be serialized.
+    def self.serialized_attributes
+      super + %w( content_type mtime )
+    end
+
     def initialize(environment, logical_path, pathname, options)
       super(environment, logical_path, pathname)
       @options = options || {}
@@ -15,21 +20,20 @@ module Sprockets
 
     # Initialize `BundledAsset` from serialized `Hash`.
     def init_with(environment, coder)
-      super
-
       @options = {}
 
+      super
+
       @body   = coder['body']
-      @source = coder['source']
       @assets = coder['asset_paths'].map { |p|
         p = expand_root_path(p)
         p == pathname.to_s ? self : environment[p, @options]
       }
 
-      @dependency_files = coder['dependency_files'].map { |h|
+      @dependency_paths = coder['dependency_paths'].map { |h|
         h.merge('path' => expand_root_path(h['path']))
       }
-      @dependency_files.each do |dep|
+      @dependency_paths.each do |dep|
         dep['mtime'] = Time.parse(dep['mtime']) if dep['mtime'].is_a?(String)
       end
     end
@@ -39,9 +43,8 @@ module Sprockets
       super
 
       coder['body']        = body
-      coder['source']      = to_s
       coder['asset_paths'] = to_a.map { |a| relativize_root_path(a.pathname) }
-      coder['dependency_files'] = dependency_files.map { |h|
+      coder['dependency_paths'] = dependency_paths.map { |h|
         h.merge('path' => relativize_root_path(h['path']))
       }
     end
@@ -50,22 +53,22 @@ module Sprockets
     # dependencies but does run any processors or engines on the
     # original file.
     def body
-      @body ||= dependency_context_and_body[1]
+      @body ||= build_dependency_context_and_body[1]
     end
 
     # Get latest mtime of all its dependencies.
     def mtime
-      @mtime ||= dependency_files.map { |h| h['mtime'] }.max
+      @mtime ||= dependency_paths.map { |h| h['mtime'] }.max
     end
 
     # Get size of concatenated source.
     def length
-      @length ||= Rack::Utils.bytesize(to_s)
+      @length ||= build_source['length']
     end
 
     # Compute digest of concatenated source.
     def digest
-      @digest ||= environment.digest.update(to_s).hexdigest
+      @digest ||= build_source['digest']
     end
 
     # Return an `Array` of `Asset` files that are declared dependencies.
@@ -75,24 +78,19 @@ module Sprockets
 
     # Expand asset into an `Array` of parts.
     def to_a
-      @assets ||= compute_assets
+      @assets ||= build_dependencies_paths_and_assets[1]
     end
 
     # Checks if Asset is stale by comparing the actual mtime and
     # digest to the inmemory model.
     def fresh?
-      # Check if environment has changed first
-      if environment.digest.hexdigest != environment_hexdigest
-        return false
-      end
-
       # Check freshness of all declared dependencies
-      dependency_files.all? { |h| dependency_fresh?(h) }
+      dependency_paths.all? { |h| dependency_fresh?(h) }
     end
 
     # Return `String` of concatenated source.
     def to_s
-      @source ||= build_source
+      @source ||= build_source['source']
     end
 
     # Save asset to disk.
@@ -131,24 +129,16 @@ module Sprockets
         environment.context_class.new(environment, logical_path.to_s, pathname)
       end
 
-      def dependency_context_and_body
-        @dependency_context_and_body ||= build_dependency_context_and_body
-      end
-
       # Get `Context` after processors have been ran on it. This
       # trackes any dependencies that processors have added to it.
       def dependency_context
-        dependency_context_and_body[0]
+        @dependency_context ||= build_dependency_context_and_body[0]
       end
 
-      # All files that this asset depends on. This list may include
+      # All paths that this asset depends on. This list may include
       # non-assets like directories.
-      def dependency_files
-        @dependency_files ||= dependency_context._dependency_paths.to_a.map do |path|
-          { 'path'      => path,
-            'mtime'     => environment.stat(path).mtime,
-            'hexdigest' => environment.file_digest(path).hexdigest }
-        end
+      def dependency_paths
+        @dependency_paths ||= build_dependencies_paths_and_assets[0]
       end
 
     private
@@ -174,24 +164,15 @@ module Sprockets
         # Runs all processors on `Context`
         body = context.evaluate(pathname, :data => data)
 
-        return context, body
-      end
+        @dependency_context, @body = context, body
 
-      def build_source
-        data = ""
-
-        # Explode Asset into parts and gather the dependency bodies
-        to_a.each { |dependency| data << dependency.body }
-
-        # Run bundle processors on concatenated source
-        blank_context.evaluate(pathname, :data => data,
-          :processors => environment.bundle_processors(content_type))
+        return context, body
       end
 
-      def compute_assets
+      def build_dependencies_paths_and_assets
         check_circular_dependency!
 
-        assets = []
+        paths, assets = {}, []
 
         # Define an `add_dependency` helper
         add_dependency = lambda do |asset|
@@ -216,7 +197,53 @@ module Sprockets
         # Ensure self is added to the dependency list
         add_dependency.call(self)
 
-        assets
+        dependency_context._dependency_paths.each do |path|
+          paths[path] ||= {
+            'path'      => path,
+            'mtime'     => environment.stat(path).mtime,
+            'hexdigest' => environment.file_digest(path).hexdigest
+          }
+        end
+
+        dependency_context._dependency_assets.each do |path|
+          # Skip if depending on self
+          next if path == pathname.to_s
+
+          # Recursively lookup required asset
+          environment[path, @options].to_a.each do |asset|
+            asset.dependency_paths.each do |dep|
+              paths[dep['path']] ||= dep
+            end
+          end
+        end
+
+        @dependency_paths, @assets = paths.values, assets
+
+        return @dependency_paths, @assets
+      end
+
+      def build_source
+        hash = environment.cache_hash("#{pathname}:source", id) do
+          data = ""
+
+          # Explode Asset into parts and gather the dependency bodies
+          to_a.each { |dependency| data << dependency.body }
+
+          # Run bundle processors on concatenated source
+          data = blank_context.evaluate(pathname, :data => data,
+            :processors => environment.bundle_processors(content_type))
+
+          { 'length' => Rack::Utils.bytesize(data),
+            'digest' => environment.digest.update(data).hexdigest,
+            'source' => data }
+        end
+        hash['length'] = Integer(hash['length']) if hash['length'].is_a?(String)
+
+        @length = hash['length']
+        @digest = hash['digest']
+        @source = hash['source']
+
+        hash
       end
   end
 end

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

@@ -7,6 +7,7 @@ module Sprockets
   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)
@@ -17,6 +18,17 @@ module Sprockets
       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
@@ -27,18 +39,21 @@ module Sprockets
           yield
 
         # Check cache for `path`
-        elsif asset = cache_get_asset(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_asset(path.to_s, asset)
+          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_asset(asset.pathname.to_s, asset)
+            cache_set_hash(asset.pathname.to_s, digest.hexdigest, hash)
           end
 
           asset
@@ -52,31 +67,21 @@ module Sprockets
 
       # Removes `Environment#root` from key and prepends
       # `Environment#cache_key_namespace`.
-      def cache_key_for(path)
-        File.join(cache_key_namespace, path.sub(root, ''))
+      def cache_key_for(key)
+        File.join(cache_key_namespace, key.sub(root, ''))
       end
 
-      # Gets asset from cache and unserializes it
-      def cache_get_asset(path)
-        hash = cache_get(cache_key_for(path))
-
-        if hash.is_a?(Hash)
-          asset = asset_from_hash(hash)
-
-          if asset.fresh?
-            asset
-          end
-        else
-          nil
+      def cache_get_hash(key, version)
+        hash = cache_get(cache_key_for(key))
+        if hash.is_a?(Hash) && version == hash['_version']
+          hash
         end
       end
 
-      # Serializes and saves asset to cache
-      def cache_set_asset(path, asset)
-        hash = {}
-        asset.encode_with(hash)
-        cache_set(cache_key_for(path), hash)
-        asset
+      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

data/vendor/sprockets/lib/sprockets/context.rb

@@ -1,3 +1,5 @@
+require 'base64'
+require 'rack/utils'
 require 'sprockets/errors'
 require 'sprockets/utils'
 require 'pathname'
@@ -20,7 +22,7 @@ module Sprockets
   # assets. See `DirectiveProcessor` for an example of this.
   class Context
     attr_reader :environment, :pathname
-    attr_reader :_required_paths, :_dependency_paths
+    attr_reader :_required_paths, :_dependency_paths, :_dependency_assets
     attr_writer :__LINE__
 
     def initialize(environment, logical_path, pathname)
@@ -29,8 +31,9 @@ module Sprockets
       @pathname     = pathname
       @__LINE__     = nil
 
-      @_required_paths   = []
-      @_dependency_paths = Set.new([pathname.to_s])
+      @_required_paths    = []
+      @_dependency_paths  = Set.new([pathname.to_s])
+      @_dependency_assets = Set.new
     end
 
     # Returns the environment path that contains the file.
@@ -108,6 +111,44 @@ module Sprockets
     # 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.
@@ -145,32 +186,21 @@ module Sprockets
       result
     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
-
-    # `require_asset` declares `path` as a dependency of the file. The
-    # dependency will be inserted before the file and will only be
-    # included once.
+    # 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.
     #
-    # If ERB processing is enabled, you can use it to dynamically
-    # require assets.
+    # Use `asset_data_uri` from ERB with CSS or JavaScript assets:
     #
-    #     <%= require_asset "#{framework}.js" %>
+    #     #logo { background: url(<%= asset_data_uri 'logo.png' %>) }
     #
-    def require_asset(path)
-      pathname = resolve(path, :content_type => :self)
-
-      unless @_required_paths.include?(pathname.to_s)
-        @_dependency_paths << pathname.to_s
-        @_required_paths << pathname.to_s
-      end
-
-      pathname
+    #     $('<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

data/vendor/sprockets/lib/sprockets/directive_processor.rb

@@ -270,7 +270,9 @@ module Sprockets
       #     //= include "header"
       #
       def process_include_directive(path)
-        included_pathnames << context.resolve(path)
+        pathname = context.resolve(path)
+        context.depend_on_asset(pathname)
+        included_pathnames << pathname
       end
 
       # `require_directory` requires all the files inside a single
@@ -326,7 +328,7 @@ module Sprockets
       # including it.
       #
       # This is used for caching purposes. Any changes made to
-      # the dependency file with invalidate the cache of the
+      # the dependency file will invalidate the cache of the
       # source file.
       #
       # This is useful if you are using ERB and File.read to pull
@@ -335,7 +337,22 @@ module Sprockets
       #     //= depend_on "foo.png"
       #
       def process_depend_on_directive(path)
-        context.depend_on(context.resolve(path))
+        context.depend_on(path)
+      end
+
+      # Allows you to state a dependency on an asset without including
+      # it.
+      #
+      # This is used for caching purposes. Any changes that would
+      # invalid the asset dependency will invalidate the cache our the
+      # source file.
+      #
+      # Unlike `depend_on`, the path must be a requirable asset.
+      #
+      #     //= depend_on_asset "bar.js"
+      #
+      def process_depend_on_asset_directive(path)
+        context.depend_on_asset(path)
       end
 
       # Enable Sprockets 1.x compat mode.
@@ -376,5 +393,5 @@ module Sprockets
       def relative?(path)
         path =~ /^\.($|\.?\/)/
       end
-    end
+  end
 end

data/vendor/sprockets/lib/sprockets/eco_template.rb

@@ -9,10 +9,9 @@ module Sprockets
   #   https://github.com/sstephenson/eco
   #
   class EcoTemplate < Tilt::Template
-    # Eco templates always produced compiled JS. We can set Tilt's
-    # default mime type hint.
-    def self.default_mime_type
-      'application/javascript'
+    # Check to see if Eco is loaded
+    def self.engine_initialized?
+      defined? ::Eco
     end
 
     # Autoload eco library. If the library isn't loaded, Tilt will produce

data/vendor/sprockets/lib/sprockets/ejs_template.rb

@@ -8,10 +8,9 @@ module Sprockets
   #   https://github.com/sstephenson/ruby-ejs
   #
   class EjsTemplate < Tilt::Template
-    # EJS templates always produced compiled JS. We can set Tilt's
-    # default mime type hint.
-    def self.default_mime_type
-      'application/javascript'
+    # Check to see if EJS is loaded
+    def self.engine_initialized?
+      defined? ::EJS
     end
 
     # Autoload ejs library. If the library isn't loaded, Tilt will produce

data/vendor/sprockets/lib/sprockets/engines.rb

@@ -1,6 +1,7 @@
 require 'sprockets/eco_template'
 require 'sprockets/ejs_template'
 require 'sprockets/jst_processor'
+require 'sprockets/mime'
 require 'sprockets/utils'
 require 'tilt'
 
@@ -47,6 +48,15 @@ module Sprockets
       end
     end
 
+    def engine_formats(ext = nil)
+      if ext
+        ext = Sprockets::Utils.normalize_extension(ext)
+        @engine_formats[ext]
+      else
+        deep_copy_hash(@engine_formats)
+      end
+    end
+
     # Returns an `Array` of engine extension `String`s.
     #
     #     environment.engine_extensions
@@ -62,13 +72,28 @@ module Sprockets
     #
     def register_engine(ext, klass)
       ext = Sprockets::Utils.normalize_extension(ext)
-      @engines ||= {}
       @engines[ext] = klass
+
+      if klass.respond_to?(:default_mime_type) && klass.default_mime_type
+        if format_ext = extension_for_mime_type(klass.default_mime_type)
+          @engine_formats[format_ext] << ext
+        end
+      end
+
+      klass
     end
+
+    private
+      def deep_copy_hash(hash)
+        initial = Hash.new { |h, k| h[k] = [] }
+        hash.inject(initial) { |h, (k, a)| h[k] = a.dup; h }
+      end
   end
 
   # Extend Sprockets module to provide global registry
   extend Engines
+  @engines = {}
+  @engine_formats = Hash.new { |h, k| h[k] = [] }
 
   # Cherry pick the default Tilt engines that make sense for
   # Sprockets. We don't need ones that only generate html like HAML.

data/vendor/sprockets/lib/sprockets/environment.rb

@@ -33,7 +33,8 @@ module Sprockets
 
       @static_root = nil
 
-      @engines = Sprockets.engines
+      @engines        = Sprockets.engines
+      @engine_formats = Sprockets.engine_formats
       @trail.extensions.replace(engine_extensions)
 
       @mime_types = {}

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

@@ -26,6 +26,7 @@ module Sprockets
       @preprocessors     = environment.preprocessors
       @postprocessors    = environment.postprocessors
       @bundle_processors = environment.bundle_processors
+      @engine_formats    = environment.engine_formats
 
       # Initialize caches
       @assets  = {}

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

@@ -0,0 +1,38 @@
+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,33 +1,20 @@
 require 'sprockets/engines'
+require 'sprockets/mime'
 require 'sprockets/processor'
 require 'sprockets/utils'
-require 'rack/mime'
 
 module Sprockets
   # `Processing` is an internal mixin whose public methods are exposed on
   # the `Environment` and `Index` classes.
   module Processing
-    include Engines
-
-    # 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
+    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!
-      ext = Sprockets::Utils.normalize_extension(ext)
       @trail.extensions << ext
-      @mime_types[ext] = mime_type
+      super
     end
 
     # Returns an `Array` of format extension `String`s.
@@ -278,33 +265,5 @@ module Sprockets
         compressor.compress(data)
       end
     end
-
-    protected
-      def compute_digest
-        digest = super
-
-        # Add mime types to environment digest
-        digest << @mime_types.keys.join(',')
-
-        # Add engines to environment digest
-        digest << @engines.map { |e, k| "#{e}:#{k.name}" }.join(',')
-
-        # Add preprocessors to environment digest
-        digest << @preprocessors.map { |m, a| "#{m}:#{a.map(&:name)}" }.join(',')
-
-        # Add postprocessors to environment digest
-        digest << @postprocessors.map { |m, a| "#{m}:#{a.map(&:name)}" }.join(',')
-
-        # Add bundle processors to environment digest
-        digest << @bundle_processors.map { |m, a| "#{m}:#{a.map(&:name)}" }.join(',')
-
-        digest
-      end
-
-    private
-      def deep_copy_hash(hash)
-        initial = Hash.new { |h, k| h[k] = [] }
-        hash.inject(initial) { |h, (k, a)| h[k] = a.dup; h }
-      end
   end
 end