bpm 0.1.0 → 0.1.2

data/vendor/sprockets/lib/sprockets/charset_normalizer.rb

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

@@ -0,0 +1,191 @@
+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
+    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])
+    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
+    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
+
+    # 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.
+    #
+    # 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)
+
+      unless @_required_paths.include?(pathname.to_s)
+        @_dependency_paths << pathname.to_s
+        @_required_paths << pathname.to_s
+      end
+
+      pathname
+    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

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

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

@@ -0,0 +1,380 @@
+require 'pathname'
+require 'shellwords'
+require 'tilt'
+require 'yaml'
+
+module Sprockets
+  # The `DirectiveProcessor` is responsible for parsing and evaluating
+  # directive comments in a source file.
+  #
+  # A directive comment starts with a comment prefix, followed by an "=",
+  # then the directive name, then any arguments.
+  #
+  #     // JavaScript
+  #     //= require "foo"
+  #
+  #     # CoffeeScript
+  #     #= require "bar"
+  #
+  #     /* CSS
+  #      *= require "baz"
+  #      */
+  #
+  # The Processor is implemented as a `Tilt::Template` and is loosely
+  # coupled to Sprockets. This makes it possible to disable or modify
+  # the processor to do whatever you'd like. You could add your own
+  # custom directives or invent your own directive syntax.
+  #
+  # `Environment#processors` includes `DirectiveProcessor` by default.
+  #
+  # To remove the processor entirely:
+  #
+  #     env.unregister_processor('text/css', Sprockets::DirectiveProcessor)
+  #     env.unregister_processor('application/javascript', Sprockets::DirectiveProcessor)
+  #
+  # Then inject your own preprocessor:
+  #
+  #     env.register_processor('text/css', MyProcessor)
+  #
+  class DirectiveProcessor < Tilt::Template
+    attr_reader :pathname
+
+    def prepare
+      @pathname = Pathname.new(file)
+
+      @directive_parser   = Parser.new(data)
+      @included_pathnames = []
+      @compat             = false
+    end
+
+    # Implemented for Tilt#render.
+    #
+    # `context` is a `Context` instance with methods that allow you to
+    # access the environment and append to the bundle. See `Context`
+    # for the complete API.
+    def evaluate(context, locals, &block)
+      @context = context
+
+      @result = ""
+      @has_written_body = false
+
+      process_directives
+      process_source
+
+      @result
+    end
+
+    def processed_header
+      @directive_parser.processed_header
+    end
+
+    def processed_body
+      @directive_parser.body
+    end
+
+    def processed_source
+      @directive_parser.processed_source
+    end
+
+    def directives
+      @directive_parser.directives
+    end
+
+    protected
+      class Parser
+        # Directives will only be picked up if they are in the header
+        # of the source file. C style (/* */), JavaScript (//), and
+        # Ruby (#) comments are supported.
+        #
+        # Directives in comments after the first non-whitespace line
+        # of code will not be processed.
+        #
+        HEADER_PATTERN = /
+          \A (
+            (?m:\s*) (
+              (\/\* (?m:.*?) \*\/) |
+              (\#\#\# (?m:.*?) \#\#\#) |
+              (\/\/ .* \n?)+ |
+              (\# .* \n?)+
+            )
+          )+
+        /x
+
+        # Directives are denoted by a `=` followed by the name, then
+        # argument list.
+        #
+        # A few different styles are allowed:
+        #
+        #     // =require foo
+        #     //= require foo
+        #     //= require "foo"
+        #
+        DIRECTIVE_PATTERN = /
+          ^ [\W]* = \s* (\w+.*?) (\*\/)? $
+        /x
+
+        attr_reader :source, :header, :body
+
+        def initialize(source)
+          @source = source
+          @header = @source[HEADER_PATTERN, 0] || ""
+          @body   = $' || @source
+
+          # Ensure body ends in a new line
+          @body  += "\n" if @body != "" && @body !~ /\n\Z/m
+        end
+
+        def header_lines
+          @header_lines ||= header.split("\n")
+        end
+
+        # Returns the header String with any directives stripped.
+        def processed_header
+          header_lines.reject do |line|
+            extract_directive(line)
+          end.join("\n")
+        end
+
+        # Returns the source String with any directives stripped.
+        def processed_source
+          @processed_source ||= processed_header + body
+        end
+
+        # Returns an Array of directive structures. Each structure
+        # is an Array with the line number as the first element, the
+        # directive name as the second element, followed by any
+        # arguments.
+        #
+        #     [[1, "require", "foo"], [2, "require", "bar"]]
+        #
+        def directives
+          @directives ||= header_lines.each_with_index.map do |line, index|
+            if directive = extract_directive(line)
+              [index + 1, *Shellwords.shellwords(directive)]
+            end
+          end.compact
+        end
+
+        def extract_directive(line)
+          line[DIRECTIVE_PATTERN, 1]
+        end
+      end
+
+      attr_reader :included_pathnames
+      attr_reader :context
+
+      # Gathers comment directives in the source and processes them.
+      # Any directive method matching `process_*_directive` will
+      # automatically be available. This makes it easy to extend the
+      # processor.
+      #
+      # To implement a custom directive called `require_glob`, subclass
+      # `Sprockets::DirectiveProcessor`, then add a method called
+      # `process_require_glob_directive`.
+      #
+      #     class DirectiveProcessor < Sprockets::DirectiveProcessor
+      #       def process_require_glob_directive
+      #         Dir["#{pathname.dirname}/#{glob}"].sort.each do |filename|
+      #           require(filename)
+      #         end
+      #       end
+      #     end
+      #
+      # Replace the current processor on the environment with your own:
+      #
+      #     env.unregister_processor('text/css', Sprockets::DirectiveProcessor)
+      #     env.register_processor('text/css', DirectiveProcessor)
+      #
+      def process_directives
+        directives.each do |line_number, name, *args|
+          context.__LINE__ = line_number
+          send("process_#{name}_directive", *args)
+          context.__LINE__ = nil
+        end
+      end
+
+      def process_source
+        unless @has_written_body || processed_header.empty?
+          @result << processed_header << "\n"
+        end
+
+        included_pathnames.each do |pathname|
+          @result << context.evaluate(pathname)
+        end
+
+        unless @has_written_body
+          @result << processed_body
+        end
+
+        if compat? && constants.any?
+          @result.gsub!(/<%=(.*?)%>/) { constants[$1.strip] }
+        end
+      end
+
+      # The `require` directive functions similar to Ruby's own `require`.
+      # It provides a way to declare a dependency on a file in your path
+      # and ensures its only loaded once before the source file.
+      #
+      # `require` works with files in the environment path:
+      #
+      #     //= require "foo.js"
+      #
+      # Extensions are optional. If your source file is ".js", it
+      # assumes you are requiring another ".js".
+      #
+      #     //= require "foo"
+      #
+      # Relative paths work too. Use a leading `./` to denote a relative
+      # path:
+      #
+      #     //= require "./bar"
+      #
+      def process_require_directive(path)
+        if @compat
+          if path =~ /<([^>]+)>/
+            path = $1
+          else
+            path = "./#{path}" unless relative?(path)
+          end
+        end
+
+        context.require_asset(path)
+      end
+
+      # `require_self` causes the body of the current file to be
+      # inserted before any subsequent `require` or `include`
+      # directives. Useful in CSS files, where it's common for the
+      # index file to contain global styles that need to be defined
+      # before other dependencies are loaded.
+      #
+      #     /*= require "reset"
+      #      *= require_self
+      #      *= require_tree .
+      #      */
+      #
+      def process_require_self_directive
+        if @has_written_body
+          raise ArgumentError, "require_self can only be called once per source file"
+        end
+
+        context.require_asset(pathname)
+        process_source
+        included_pathnames.clear
+        @has_written_body = true
+      end
+
+      # The `include` directive works similar to `require` but
+      # inserts the contents of the dependency even if it already
+      # has been required.
+      #
+      #     //= include "header"
+      #
+      def process_include_directive(path)
+        included_pathnames << context.resolve(path)
+      end
+
+      # `require_directory` requires all the files inside a single
+      # directory. It's similar to `path/*` since it does not follow
+      # nested directories.
+      #
+      #     //= require_directory "./javascripts"
+      #
+      def process_require_directory_directive(path = ".")
+        if relative?(path)
+          root = pathname.dirname.join(path).expand_path
+          context.depend_on(root)
+
+          Dir["#{root}/*"].sort.each do |filename|
+            if filename == self.file
+              next
+            elsif context.asset_requirable?(filename)
+              context.require_asset(filename)
+            end
+          end
+        else
+          # The path must be relative and start with a `./`.
+          raise ArgumentError, "require_directory argument must be a relative path"
+        end
+      end
+
+      # `require_tree` requires all the nested files in a directory.
+      # Its glob equivalent is `path/**/*`.
+      #
+      #     //= require_tree "./public"
+      #
+      def process_require_tree_directive(path = ".")
+        if relative?(path)
+          root = pathname.dirname.join(path).expand_path
+          context.depend_on(root)
+
+          Dir["#{root}/**/*"].sort.each do |filename|
+            if filename == self.file
+              next
+            elsif File.directory?(filename)
+              context.depend_on(filename)
+            elsif context.asset_requirable?(filename)
+              context.require_asset(filename)
+            end
+          end
+        else
+          # The path must be relative and start with a `./`.
+          raise ArgumentError, "require_tree argument must be a relative path"
+        end
+      end
+
+      # 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.
+      #
+      # This is useful if you are using ERB and File.read to pull
+      # in contents from another file.
+      #
+      #     //= depend_on "foo.png"
+      #
+      def process_depend_on_directive(path)
+        context.depend_on(context.resolve(path))
+      end
+
+      # Enable Sprockets 1.x compat mode.
+      #
+      # Makes it possible to use the same JavaScript source
+      # file in both Sprockets 1 and 2.
+      #
+      #     //= compat
+      #
+      def process_compat_directive
+        @compat = true
+      end
+
+      # Checks if Sprockets 1.x compat mode enabled
+      def compat?
+        @compat
+      end
+
+      # Sprockets 1.x allowed for constant interpolation if a
+      # constants.yml was present. This is only available if
+      # compat mode is on.
+      def constants
+        if compat?
+          path = File.join(context.root_path, "constants.yml")
+          File.exist?(path) ? YAML.load_file(path) : {}
+        else
+          {}
+        end
+      end
+
+      # `provide` is stubbed out for Sprockets 1.x compat.
+      # Mutating the path when an asset is being built is
+      # not permitted.
+      def process_provide_directive(path)
+      end
+
+    private
+      def relative?(path)
+        path =~ /^\.($|\.?\/)/
+      end
+    end
+end