bpm 0.1.0 → 0.1.2

data/vendor/sprockets/lib/sprockets/asset_attributes.rb

@@ -0,0 +1,161 @@
+require 'pathname'
+
+module Sprockets
+  # `AssetAttributes` is a wrapper similar to `Pathname` that provides
+  # some helper accessors.
+  #
+  # These methods should be considered internalish.
+  class AssetAttributes
+    attr_reader :environment, :pathname
+
+    def initialize(environment, path)
+      @environment = environment
+      @pathname = path.is_a?(Pathname) ? path : Pathname.new(path.to_s)
+    end
+
+    # Returns `Array` of extension `String`s.
+    #
+    #     "foo.js.coffee"
+    #     # => [".js", ".coffee"]
+    #
+    def extensions
+      @extensions ||= @pathname.basename.to_s.scan(/\.[^.]+/)
+    end
+
+    # Returns basename alone.
+    #
+    #     "foo/bar.js"
+    #     # => "bar"
+    #
+    def basename_without_extensions
+      @pathname.basename(extensions.join)
+    end
+
+    # Replaces `$root` placeholder with actual environment root.
+    def expand_root
+      pathname.to_s.sub(/^\$root/, environment.root)
+    end
+
+    # Replaces environment root with `$root` placeholder.
+    def relativize_root
+      pathname.to_s.sub(/^#{Regexp.escape(environment.root)}/, '$root')
+    end
+
+    # Strips `$HOME` and environment root for a nicer output.
+    def pretty_path
+      @pretty_path ||= @pathname.
+        sub(/^#{Regexp.escape(ENV['HOME'] || '')}/, '~').
+        sub(/^#{Regexp.escape(environment.root)}\//, '')
+    end
+
+    # Returns the index location.
+    #
+    #     "foo/bar.js"
+    #     # => "foo/bar/index.js"
+    #
+    def index_path
+      if basename_without_extensions.to_s == 'index'
+        pathname.to_s
+      else
+        basename = "#{basename_without_extensions}/index#{extensions.join}"
+        pathname.dirname.to_s == '.' ? basename : pathname.dirname.join(basename).to_s
+      end
+    end
+
+    # Returns the format extension.
+    #
+    #     "foo.js.coffee"
+    #     # => ".js"
+    #
+    def format_extension
+      extensions.detect { |ext| @environment.mime_types(ext) }
+    end
+
+    # Returns an `Array` of engine extensions.
+    #
+    #     "foo.js.coffee.erb"
+    #     # => [".coffee", ".erb"]
+    #
+    def engine_extensions
+      exts = extensions
+
+      if offset = extensions.index(format_extension)
+        exts = extensions[offset+1..-1]
+      end
+
+      exts.select { |ext| @environment.engines(ext) }
+    end
+
+    # Returns path without any engine extensions.
+    #
+    #     "foo.js.coffee.erb"
+    #     # => "foo.js"
+    #
+    def without_engine_extensions
+      engine_extensions.inject(pathname) do |p, ext|
+        p.sub(ext, '')
+      end
+    end
+
+    # Returns engine classes.
+    def engines
+      engine_extensions.map { |ext| @environment.engines(ext) }
+    end
+
+    # Returns all processors to run on the path.
+    def processors
+      environment.preprocessors(content_type) +
+        engines.reverse +
+        environment.postprocessors(content_type)
+    end
+
+    # Returns implicit engine content type.
+    #
+    # `.coffee` files carry an implicit `application/javascript`
+    # content type.
+    def engine_content_type
+      engines.reverse.each do |engine|
+        if engine.respond_to?(:default_mime_type) && engine.default_mime_type
+          return engine.default_mime_type
+        end
+      end
+      nil
+    end
+
+    # Returns the content type for the pathname. Falls back to `application/octet-stream`.
+    def content_type
+      @content_type ||= begin
+        if format_extension.nil?
+          engine_content_type || 'application/octet-stream'
+        else
+          @environment.mime_types(format_extension) ||
+            engine_content_type ||
+            'application/octet-stream'
+        end
+      end
+    end
+
+    # Gets digest fingerprint.
+    #
+    #     "foo-0aa2105d29558f3eb790d411d7d8fb66.js"
+    #     # => "0aa2105d29558f3eb790d411d7d8fb66"
+    #
+    def path_fingerprint
+      pathname.basename(extensions.join).to_s =~ /-([0-9a-f]{7,40})$/ ? $1 : nil
+    end
+
+    # Injects digest fingerprint into path.
+    #
+    #     "foo.js"
+    #     # => "foo-0aa2105d29558f3eb790d411d7d8fb66.js"
+    #
+    def path_with_fingerprint(digest)
+      if path_fingerprint
+        path.sub($1, digest)
+      else
+        basename = "#{pathname.basename(extensions.join)}-#{digest}#{extensions.join}"
+        pathname.dirname.to_s == '.' ? basename : pathname.dirname.join(basename).to_s
+      end
+    end
+  end
+end

data/vendor/sprockets/lib/sprockets/base.rb

@@ -0,0 +1,147 @@
+require 'sprockets/asset_attributes'
+require 'sprockets/bundled_asset'
+require 'sprockets/caching'
+require 'sprockets/digest'
+require 'sprockets/processing'
+require 'sprockets/server'
+require 'sprockets/static_asset'
+require 'sprockets/static_compilation'
+require 'sprockets/trail'
+require 'pathname'
+
+module Sprockets
+  # `Base` class for `Environment` and `Index`.
+  class Base
+    include Digest
+    include Caching, Processing, Server, StaticCompilation, Trail
+
+    # Get and set `Logger` instance.
+    attr_accessor :logger
+
+    # Get `Context` class.
+    #
+    # This class maybe mutated and mixed in with custom helpers.
+    #
+    #     environment.context_class.instance_eval do
+    #       include MyHelpers
+    #       def asset_url; end
+    #     end
+    #
+    attr_reader :context_class
+
+    # Get persistent cache store
+    attr_reader :cache
+
+    # Set persistent cache store
+    #
+    # The cache store must implement a pair of getters and
+    # setters. Either `get(key)`/`set(key, value)`,
+    # `[key]`/`[key]=value`, `read(key)`/`write(key, value)`.
+    def cache=(cache)
+      expire_index!
+      @cache = cache
+    end
+
+    # Return an `Index`. Must be implemented by the subclass.
+    def index
+      raise NotImplementedError
+    end
+
+    # Works like `Dir.entries`.
+    #
+    # Subclasses may cache this method.
+    def entries(pathname)
+      trail.entries(pathname)
+    end
+
+    # Works like `File.stat`.
+    #
+    # Subclasses may cache this method.
+    def stat(path)
+      trail.stat(path)
+    end
+
+    # Read and compute digest of filename.
+    #
+    # Subclasses may cache this method.
+    def file_digest(path, data = nil)
+      if stat = self.stat(path)
+        # `data` maybe provided
+        if data
+          digest.update(data)
+
+        # If its a file, digest the contents
+        elsif stat.file?
+          digest.file(path)
+
+        # If its a directive, digest the list of filenames
+        elsif stat.directory?
+          contents = self.entries(path).join(',')
+          digest.update(contents)
+        end
+      end
+    end
+
+    # Internal. Return a `AssetAttributes` for `path`.
+    def attributes_for(path)
+      AssetAttributes.new(self, path)
+    end
+
+    # Internal. Return content type of `path`.
+    def content_type_of(path)
+      attributes_for(path).content_type
+    end
+
+    # Find asset by logical path or expanded path.
+    def find_asset(path, options = {})
+      pathname = Pathname.new(path)
+
+      if pathname.absolute?
+        build_asset(detect_logical_path(path).to_s, pathname, options)
+      else
+        find_asset_in_path(pathname, options)
+      end
+    end
+
+    # Preferred `find_asset` shorthand.
+    #
+    #     environment['application.js']
+    #
+    def [](*args)
+      find_asset(*args)
+    end
+
+    protected
+      # Clear index after mutating state. Must be implemented by the subclass.
+      def expire_index!
+        raise NotImplementedError
+      end
+
+      def build_asset(logical_path, pathname, options)
+        pathname = Pathname.new(pathname)
+
+        return unless stat(pathname)
+
+        # If there are any processors to run on the pathname, use
+        # `BundledAsset`. Otherwise use `StaticAsset` and treat is as binary.
+        if attributes_for(pathname).processors.any?
+          BundledAsset.new(self, logical_path, pathname, options)
+        else
+          StaticAsset.new(self, logical_path, pathname)
+        end
+      end
+
+      # Reverse guess logical path for fully expanded path.#
+      #
+      # This has some known issues. For an example if a file is
+      # shaddowed in the path, but is required relatively, its logical
+      # path will be incorrect.
+      def detect_logical_path(filename)
+        if root_path = paths.detect { |path| filename.to_s[path] }
+          root_pathname = Pathname.new(root_path)
+          logical_path  = Pathname.new(filename).relative_path_from(root_pathname)
+          attributes_for(logical_path).without_engine_extensions
+        end
+      end
+  end
+end

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

@@ -0,0 +1,222 @@
+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
+    def initialize(environment, logical_path, pathname, options)
+      super(environment, logical_path, pathname)
+      @options = options || {}
+    end
+
+    # Initialize `BundledAsset` from serialized `Hash`.
+    def init_with(environment, coder)
+      super
+
+      @options = {}
+
+      @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|
+        h.merge('path' => expand_root_path(h['path']))
+      }
+      @dependency_files.each do |dep|
+        dep['mtime'] = Time.parse(dep['mtime']) if dep['mtime'].is_a?(String)
+      end
+    end
+
+    # Serialize custom attributes in `BundledAsset`.
+    def encode_with(coder)
+      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|
+        h.merge('path' => relativize_root_path(h['path']))
+      }
+    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
+      @body ||= dependency_context_and_body[1]
+    end
+
+    # Get latest mtime of all its dependencies.
+    def mtime
+      @mtime ||= dependency_files.map { |h| h['mtime'] }.max
+    end
+
+    # Get size of concatenated source.
+    def length
+      @length ||= Rack::Utils.bytesize(to_s)
+    end
+
+    # Compute digest of concatenated source.
+    def digest
+      @digest ||= environment.digest.update(to_s).hexdigest
+    end
+
+    # Return an `Array` of `Asset` files that are declared dependencies.
+    def dependencies
+      to_a - [self]
+    end
+
+    # Expand asset into an `Array` of parts.
+    def to_a
+      @assets ||= compute_assets
+    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) }
+    end
+
+    # Return `String` of concatenated source.
+    def to_s
+      @source ||= build_source
+    end
+
+    # Save asset to disk.
+    def write_to(filename, options = {})
+      # Gzip contents if filename has '.gz'
+      options[:compress] ||= File.extname(filename) == '.gz'
+
+      File.open("#{filename}+", 'wb') do |f|
+        if options[:compress]
+          # Run contents through `Zlib`
+          gz = Zlib::GzipWriter.new(f, Zlib::BEST_COMPRESSION)
+          gz.write to_s
+          gz.close
+        else
+          # Write out as is
+          f.write to_s
+          f.close
+        end
+      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
+
+    protected
+      # Return new blank `Context` to evaluate processors in.
+      def blank_context
+        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]
+      end
+
+      # All files 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
+      end
+
+    private
+      # Check if self has already been required and raise a fast
+      # error. Otherwise you end up with a StackOverflow error.
+      def check_circular_dependency!
+        requires = @options[:_requires] ||= []
+        if requires.include?(pathname.to_s)
+          raise CircularDependencyError, "#{pathname} has already been required"
+        end
+        requires << pathname.to_s
+      end
+
+      def build_dependency_context_and_body
+        context = blank_context
+
+        # Read original data once and pass it along to `Context`
+        data = Sprockets::Utils.read_unicode(pathname)
+
+        # Prime digest cache with data, since we happen to have it
+        environment.file_digest(pathname, data)
+
+        # Runs all processors on `Context`
+        body = context.evaluate(pathname, :data => data)
+
+        return context, body
+      end
+
+      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))
+      end
+
+      def compute_assets
+        check_circular_dependency!
+
+        assets = []
+
+        # Define an `add_dependency` helper
+        add_dependency = lambda do |asset|
+          unless assets.any? { |a| a.pathname == asset.pathname }
+            assets << asset
+          end
+        end
+
+        # Iterate over all the declared require paths from the `Context`
+        dependency_context._required_paths.each do |required_path|
+          # Catch `require_self`
+          if required_path == pathname.to_s
+            add_dependency.call(self)
+          else
+            # Recursively lookup required asset
+            environment[required_path, @options].to_a.each do |asset|
+              add_dependency.call(asset)
+            end
+          end
+        end
+
+        # Ensure self is added to the dependency list
+        add_dependency.call(self)
+
+        assets
+      end
+  end
+end

data/vendor/sprockets/lib/sprockets/cache/file_store.rb

@@ -0,0 +1,41 @@
+require 'digest/md5'
+require 'fileutils'
+require 'pathname'
+
+module Sprockets
+  module Cache
+    # A simple file system cache store.
+    #
+    #     environment.cache = Sprockets::Cache::FileStore.new("tmp/sprockets")
+    #
+    class FileStore
+      def initialize(root)
+        @root = Pathname.new(root)
+
+        # Ensure directory exists
+        FileUtils.mkdir_p @root
+      end
+
+      # Lookup value in cache
+      def [](key)
+        pathname = path_for(key)
+        pathname.exist? ? pathname.open('rb') { |f| Marshal.load(f) } : nil
+      end
+
+      # Save value to cache
+      def []=(key, value)
+        path_for(key).open('w') { |f| Marshal.dump(value, f)}
+        value
+      end
+
+      private
+        # Returns path for cache key.
+        #
+        # The key may include some funky characters so hash it into
+        # safe hex.
+        def path_for(key)
+          @root.join(::Digest::MD5.hexdigest(key))
+        end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+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)
+      case hash['class']
+      when 'BundledAsset'
+        BundledAsset.from_hash(self, hash)
+      when 'StaticAsset'
+        StaticAsset.from_hash(self, hash)
+      else
+        nil
+      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 = cache_get_asset(path)
+          asset
+
+         # Otherwise yield block that slowly finds and builds the asset
+        elsif asset = yield
+          # Save the asset to at its path
+          cache_set_asset(path.to_s, asset)
+
+          # 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)
+          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(path)
+        File.join(cache_key_namespace, path.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
+        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
+      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