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

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

@@ -1,178 +0,0 @@
-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
-
-    # 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 paths search the load path for.
-    def search_paths
-      paths = [pathname.to_s]
-
-      if format_extension && engine_extensions.empty?
-        environment.engine_formats(format_extension).each do |ext, engine|
-          paths << pathname.sub(format_extension, ext).to_s
-        end
-      end
-
-      if pathname.basename(extensions.join).to_s != 'index'
-        path_without_extensions = extensions.inject(pathname) { |p, ext| p.sub(ext, '') }
-        index_path = path_without_extensions.join("index#{extensions.join}").to_s
-
-        paths << index_path
-
-        if format_extension && engine_extensions.empty?
-          environment.engine_formats(format_extension).each do |ext, engine|
-            paths << index_path.sub(format_extension, ext).to_s
-          end
-        end
-      end
-
-      paths
-    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 logical_path
-      raise ArgumentError unless pathname.absolute?
-
-      if root_path = environment.paths.detect { |path| pathname.to_s[path] }
-        path = pathname.relative_path_from(Pathname.new(root_path)).to_s
-        path = engine_extensions.inject(path) { |p, ext| p.sub(ext, '') }
-        path = "#{path}#{engine_format_extension}" unless format_extension
-        path
-      end
-    end
-
-    # Returns `Array` of extension `String`s.
-    #
-    #     "foo.js.coffee"
-    #     # => [".js", ".coffee"]
-    #
-    def extensions
-      @extensions ||= @pathname.basename.to_s.scan(/\.[^.]+/)
-    end
-
-    # Returns the format extension.
-    #
-    #     "foo.js.coffee"
-    #     # => ".js"
-    #
-    def format_extension
-      extensions.detect { |ext|
-        @environment.mime_types(ext) && !@environment.engines(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 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 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
-
-    private
-      # 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
-
-      def engine_format_extension
-        if content_type = engine_content_type
-          environment.extension_for_mime_type(content_type)
-        end
-      end
-  end
-end

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

@@ -1,134 +0,0 @@
-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(attributes_for(pathname).logical_path, 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
-  end
-end

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

@@ -1,249 +0,0 @@
-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
-    # 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 || {}
-    end
-
-    # Initialize `BundledAsset` from serialized `Hash`.
-    def init_with(environment, coder)
-      @options = {}
-
-      super
-
-      @body   = coder['body']
-      @assets = coder['asset_paths'].map { |p|
-        p = expand_root_path(p)
-        p == pathname.to_s ? self : environment[p, @options]
-      }
-
-      @dependency_paths = coder['dependency_paths'].map { |h|
-        h.merge('path' => expand_root_path(h['path']))
-      }
-      @dependency_paths.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['asset_paths'] = to_a.map { |a| relativize_root_path(a.pathname) }
-      coder['dependency_paths'] = dependency_paths.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 ||= build_dependency_context_and_body[1]
-    end
-
-    # Get latest mtime of all its dependencies.
-    def mtime
-      @mtime ||= dependency_paths.map { |h| h['mtime'] }.max
-    end
-
-    # Get size of concatenated source.
-    def length
-      @length ||= build_source['length']
-    end
-
-    # Compute digest of concatenated source.
-    def digest
-      @digest ||= build_source['digest']
-    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 ||= 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 freshness of all declared dependencies
-      dependency_paths.all? { |h| dependency_fresh?(h) }
-    end
-
-    # Return `String` of concatenated source.
-    def to_s
-      @source ||= build_source['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
-
-      # Get `Context` after processors have been ran on it. This
-      # trackes any dependencies that processors have added to it.
-      def dependency_context
-        @dependency_context ||= build_dependency_context_and_body[0]
-      end
-
-      # All paths that this asset depends on. This list may include
-      # non-assets like directories.
-      def dependency_paths
-        @dependency_paths ||= build_dependencies_paths_and_assets[0]
-      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)
-
-        @dependency_context, @body = context, body
-
-        return context, body
-      end
-
-      def build_dependencies_paths_and_assets
-        check_circular_dependency!
-
-        paths, 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)
-
-        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/cache/file_store.rb

@@ -1,41 +0,0 @@
-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