bpm 0.1.0 → 0.1.2

data/vendor/sprockets/lib/sprockets/processor.rb

@@ -0,0 +1,32 @@
+require 'tilt'
+
+module Sprockets
+  # `Processor` creates an anonymous processor class from a block.
+  #
+  #     register_preprocessor :my_processor do |context, data|
+  #       # ...
+  #     end
+  #
+  class Processor < Tilt::Template
+    # `processor` is a lambda or block
+    def self.processor
+      @processor
+    end
+
+    def self.name
+      "Sprockets::Processor (#{@name})"
+    end
+
+    def self.to_s
+      name
+    end
+
+    def prepare
+    end
+
+    # Call processor block with `context` and `data`.
+    def evaluate(context, locals)
+      self.class.processor.call(context, data)
+    end
+  end
+end

data/vendor/sprockets/lib/sprockets/safety_colons.rb

@@ -0,0 +1,28 @@
+require 'tilt'
+
+module Sprockets
+  # For JS developers who are colonfobic, concatenating JS files using
+  # the module pattern usually leads to syntax errors.
+  #
+  # The `SafetyColons` processor will insert missing semicolons to the
+  # end of the file.
+  #
+  # This behavior can be disabled with:
+  #
+  #     environment.unregister_postprocessor 'application/javascript', Sprockets::SafetyColons
+  #
+  class SafetyColons < Tilt::Template
+    def prepare
+    end
+
+    def evaluate(context, locals, &block)
+      # If the file is blank or ends in a semicolon, leave it as is
+      if data =~ /\A\s*\Z/m || data =~ /;\s*\Z/m
+        data
+      else
+        # Otherwise, append a semicolon and newline
+        "#{data};\n"
+      end
+    end
+  end
+end

data/vendor/sprockets/lib/sprockets/server.rb

@@ -0,0 +1,270 @@
+require 'rack/request'
+require 'time'
+
+module Sprockets
+  # `Server` is a concern mixed into `Environment` and
+  # `Index` that provides a Rack compatible `call`
+  # interface and url generation helpers.
+  module Server
+    # `call` implements the Rack 1.x specification which accepts an
+    # `env` Hash and returns a three item tuple with the status code,
+    # headers, and body.
+    #
+    # Mapping your environment at a url prefix will serve all assets
+    # in the path.
+    #
+    #     map "/assets" do
+    #       run Sprockets::Environment.new
+    #     end
+    #
+    # A request for `"/assets/foo/bar.js"` will search your
+    # environment for `"foo/bar.js"`.
+    def call(env)
+      start_time = Time.now.to_f
+      time_elapsed = lambda { ((Time.now.to_f - start_time) * 1000).to_i }
+
+      msg = "Served asset #{env['PATH_INFO']} -"
+
+      # URLs containing a `".."` are rejected for security reasons.
+      if forbidden_request?(env)
+        return forbidden_response
+      end
+
+      # Mark session as "skipped" so no `Set-Cookie` header is set
+      env['rack.session.options'] ||= {}
+      env['rack.session.options'][:defer] = true
+      env['rack.session.options'][:skip] = true
+
+      # Extract the path from everything after the leading slash
+      path = env['PATH_INFO'].to_s.sub(/^\//, '')
+
+      # Look up the asset.
+      asset = find_asset(path)
+      asset.to_a if asset
+
+      # `find_asset` returns nil if the asset doesn't exist
+      if asset.nil?
+        logger.info "#{msg} 404 Not Found (#{time_elapsed.call}ms)"
+
+        # Return a 404 Not Found
+        not_found_response
+
+      # Check request headers `HTTP_IF_MODIFIED_SINCE` and
+      # `HTTP_IF_NONE_MATCH` against the assets mtime and digest
+      elsif not_modified?(asset, env) || etag_match?(asset, env)
+        logger.info "#{msg} 304 Not Modified (#{time_elapsed.call}ms)"
+
+        # Return a 304 Not Modified
+        not_modified_response(asset, env)
+
+      else
+        logger.info "#{msg} 200 OK (#{time_elapsed.call}ms)"
+
+        # Return a 200 with the asset contents
+        ok_response(asset, env)
+      end
+    rescue Exception => e
+      logger.error "Error compiling asset #{path}:"
+      logger.error "#{e.class.name}: #{e.message}"
+
+      case content_type_of(path)
+      when "application/javascript"
+        # Re-throw JavaScript asset exceptions to the browser
+        logger.info "#{msg} 500 Internal Server Error\n\n"
+        return javascript_exception_response(e)
+      when "text/css"
+        # Display CSS asset exceptions in the browser
+        logger.info "#{msg} 500 Internal Server Error\n\n"
+        return css_exception_response(e)
+      else
+        raise
+      end
+    end
+
+    # `path` is a url helper that looks up an asset given a
+    # `logical_path` and returns a path String. By default, the
+    # asset's digest fingerprint is spliced into the filename.
+    #
+    #     /assets/application-3676d55f84497cbeadfc614c1b1b62fc.js
+    #
+    # A third `prefix` argument can be pass along to be prepended to
+    # the string.
+    def path(logical_path, fingerprint = true, prefix = nil)
+      if fingerprint && asset = find_asset(logical_path.to_s.sub(/^\//, ''))
+        url = attributes_for(logical_path).path_with_fingerprint(asset.digest)
+      else
+        url = logical_path
+      end
+
+      url = File.join(prefix, url) if prefix
+      url = "/#{url}" unless url =~ /^\//
+
+      url
+    end
+
+    # Similar to `path`, `url` returns a full url given a Rack `env`
+    # Hash and a `logical_path`.
+    def url(env, logical_path, fingerprint = true, prefix = nil)
+      req = Rack::Request.new(env)
+
+      url = req.scheme + "://"
+      url << req.host
+
+      if req.scheme == "https" && req.port != 443 ||
+          req.scheme == "http" && req.port != 80
+        url << ":#{req.port}"
+      end
+
+      url << path(logical_path, fingerprint, prefix)
+
+      url
+    end
+
+    private
+      def forbidden_request?(env)
+        # Prevent access to files elsewhere on the file system
+        #
+        #     http://example.org/assets/../../../etc/passwd
+        #
+        env["PATH_INFO"].include?("..")
+      end
+
+      # Returns a 403 Forbidden response tuple
+      def forbidden_response
+        [ 403, { "Content-Type" => "text/plain", "Content-Length" => "9" }, [ "Forbidden" ] ]
+      end
+
+      # Returns a 404 Not Found response tuple
+      def not_found_response
+        [ 404, { "Content-Type" => "text/plain", "Content-Length" => "9", "X-Cascade" => "pass" }, [ "Not found" ] ]
+      end
+
+      # Returns a JavaScript response that re-throws a Ruby exception
+      # in the browser
+      def javascript_exception_response(exception)
+        err  = "#{exception.class.name}: #{exception.message}"
+        body = "throw Error(#{err.inspect})"
+        [ 200, { "Content-Type" => "application/javascript", "Content-Length" => Rack::Utils.bytesize(body).to_s }, [ body ] ]
+      end
+
+      # Returns a CSS response that hides all elements on the page and
+      # displays the exception
+      def css_exception_response(exception)
+        message   = "\n#{exception.class.name}: #{exception.message}"
+        backtrace = "\n  #{exception.backtrace.first}"
+
+        body = <<-CSS
+          html {
+            padding: 18px 36px;
+          }
+
+          head {
+            display: block;
+          }
+
+          body {
+            margin: 0;
+            padding: 0;
+          }
+
+          body > * {
+            display: none !important;
+          }
+
+          head:after, body:before, body:after {
+            display: block !important;
+          }
+
+          head:after {
+            font-family: sans-serif;
+            font-size: large;
+            font-weight: bold;
+            content: "Error compiling CSS asset";
+          }
+
+          body:before, body:after {
+            font-family: monospace;
+            white-space: pre-wrap;
+          }
+
+          body:before {
+            font-weight: bold;
+            content: "#{escape_css_content(message)}";
+          }
+
+          body:after {
+            content: "#{escape_css_content(backtrace)}";
+          }
+        CSS
+
+        [ 200, { "Content-Type" => "text/css;charset=utf-8", "Content-Length" => Rack::Utils.bytesize(body).to_s }, [ body ] ]
+      end
+
+      # Escape special characters for use inside a CSS content("...") string
+      def escape_css_content(content)
+        content.
+          gsub('\\', '\\\\005c ').
+          gsub("\n", '\\\\000a ').
+          gsub('"',  '\\\\0022 ').
+          gsub('/',  '\\\\002f ')
+      end
+
+      # Compare the requests `HTTP_IF_MODIFIED_SINCE` against the
+      # assets mtime
+      def not_modified?(asset, env)
+        env["HTTP_IF_MODIFIED_SINCE"] == asset.mtime.httpdate
+      end
+
+      # Compare the requests `HTTP_IF_NONE_MATCH` against the assets digest
+      def etag_match?(asset, env)
+        env["HTTP_IF_NONE_MATCH"] == etag(asset)
+      end
+
+      # Test if `?body=1` or `body=true` query param is set
+      def body_only?(env)
+        env["QUERY_STRING"].to_s =~ /body=(1|t)/
+      end
+
+      # Returns a 304 Not Modified response tuple
+      def not_modified_response(asset, env)
+        [ 304, {}, [] ]
+      end
+
+      # Returns a 200 OK response tuple
+      def ok_response(asset, env)
+        if body_only?(env)
+          [ 200, headers(env, asset, Rack::Utils.bytesize(asset.body)), [asset.body] ]
+        else
+          [ 200, headers(env, asset, asset.length), asset ]
+        end
+      end
+
+      def headers(env, asset, length)
+        Hash.new.tap do |headers|
+          # Set content type and length headers
+          headers["Content-Type"]   = asset.content_type
+          headers["Content-Length"] = length.to_s
+
+          # Set caching headers
+          headers["Cache-Control"]  = "public"
+          headers["Last-Modified"]  = asset.mtime.httpdate
+          headers["ETag"]           = etag(asset)
+
+          # If the request url contains a fingerprint, set a long
+          # expires on the response
+          if attributes_for(env["PATH_INFO"]).path_fingerprint
+            headers["Cache-Control"] << ", max-age=31536000"
+
+          # Otherwise set `must-revalidate` since the asset could be modified.
+          else
+            headers["Cache-Control"] << ", must-revalidate"
+          end
+        end
+      end
+
+      # Helper to quote the assets digest for use as an ETag.
+      def etag(asset)
+        %("#{asset.digest}")
+      end
+  end
+end

data/vendor/sprockets/lib/sprockets/static_asset.rb

@@ -0,0 +1,87 @@
+require 'sprockets/asset'
+require 'fileutils'
+require 'zlib'
+
+module Sprockets
+  # `StaticAsset`s are used for files that are served verbatim without
+  # any processing or concatenation. These are typical images and
+  # other binary files.
+  class StaticAsset < Asset
+    def initialize(environment, logical_path, pathname, digest = nil)
+      super(environment, logical_path, pathname)
+      @digest = digest
+      load!
+    end
+
+    # Returns file contents as its `body`.
+    def body
+      # File is read everytime to avoid memory bloat of large binary files
+      pathname.open('rb') { |f| f.read }
+    end
+
+    # Checks if Asset is fresh 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 current mtime and digest
+      dependency_fresh?('path' => pathname, 'mtime' => mtime, 'hexdigest' => digest)
+    end
+
+    # Implemented for Rack SendFile support.
+    def to_path
+      pathname.to_s
+    end
+
+    # `to_s` is aliased to body since static assets can't have any dependencies.
+    def to_s
+      body
+    end
+
+    # Save asset to disk.
+    def write_to(filename, options = {})
+      # Gzip contents if filename has '.gz'
+      options[:compress] ||= File.extname(filename) == '.gz'
+
+      if options[:compress]
+        # Open file and run it through `Zlib`
+        pathname.open('rb') do |rd|
+          File.open("#{filename}+", 'wb') do |wr|
+            gz = Zlib::GzipWriter.new(wr, Zlib::BEST_COMPRESSION)
+            buf = ""
+            while rd.read(16384, buf)
+              gz.write(buf)
+            end
+            gz.close
+          end
+        end
+      else
+        # If no compression needs to be done, we can just copy it into place.
+        FileUtils.cp(pathname, "#{filename}+")
+      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
+
+    private
+      def load!
+        content_type
+        mtime
+        length
+        digest
+        environment_hexdigest
+      end
+  end
+end

data/vendor/sprockets/lib/sprockets/static_compilation.rb

@@ -0,0 +1,82 @@
+require 'sprockets/static_asset'
+
+require 'fileutils'
+require 'pathname'
+
+module Sprockets
+  # `Caching` is an internal mixin whose public methods are exposed on
+  # the `Environment` and `Index` classes.
+  module StaticCompilation
+    # `static_root` is a special path where compiled assets are served
+    # from. This is usually set to a `/public` or `/static` directory.
+    #
+    # In a production environment, Apache or nginx should be
+    # configured to serve assets from the directory.
+    def static_root
+      @static_root
+    end
+
+    # Assign a static root directory.
+    def static_root=(root)
+      expire_index!
+      @static_root = root ? Pathname.new(root) : nil
+    end
+
+    # `precompile` takes a like of paths, globs, or `Regexp`s to
+    # compile into `static_root`.
+    #
+    #     precompile "application.js", "*.css", /.+\.(png|jpg)/
+    #
+    # This usually ran via a rake task.
+    def precompile(*paths)
+      raise "missing static root" unless static_root
+
+      paths.each do |path|
+        files.each do |logical_path|
+          if path.is_a?(Regexp)
+            # Match path against `Regexp`
+            next unless path.match(logical_path.to_s)
+          else
+            # Otherwise use fnmatch glob syntax
+            next unless logical_path.fnmatch(path.to_s)
+          end
+
+          if asset = find_asset(logical_path)
+            attributes  = attributes_for(logical_path)
+            digest_path = attributes.path_with_fingerprint(asset.digest)
+            filename    = static_root.join(digest_path)
+
+            # Ensure directory exists
+            FileUtils.mkdir_p filename.dirname
+
+            # Write file
+            asset.write_to(filename)
+
+            # Write compressed file if its a bundled asset like .js or .css
+            asset.write_to("#{filename}.gz") if asset.is_a?(BundledAsset)
+          end
+        end
+      end
+    end
+
+    protected
+      def compute_digest
+        # Add static root to environment digest
+        super.update(static_root.to_s)
+      end
+
+    private
+      # Get all reachable files in environment path
+      def files
+        files = Set.new
+        paths.each do |base_path|
+          base_pathname = Pathname.new(base_path)
+          Dir["#{base_pathname}/**/*"].each do |filename|
+            logical_path = Pathname.new(filename).relative_path_from(base_pathname)
+            files << attributes_for(logical_path).without_engine_extensions
+          end
+        end
+        files
+      end
+  end
+end

data/vendor/sprockets/lib/sprockets/trail.rb

@@ -0,0 +1,122 @@
+require 'sprockets/errors'
+require 'pathname'
+
+module Sprockets
+  # `Trail` is an internal mixin whose public methods are exposed on
+  # the `Environment` and `Index` classes.
+  module Trail
+    # Returns `Environment` root.
+    #
+    # All relative paths are expanded with root as its base. To be
+    # useful set this to your applications root directory. (`Rails.root`)
+    def root
+      trail.root.dup
+    end
+
+    # Returns an `Array` of path `String`s.
+    #
+    # These paths will be used for asset logical path lookups.
+    #
+    # Note that a copy of the `Array` is returned so mutating will
+    # have no affect on the environment. See `append_path`,
+    # `prepend_path`, and `clear_paths`.
+    def paths
+      trail.paths.dup
+    end
+
+    # Prepend a `path` to the `paths` list.
+    #
+    # Paths at the end of the `Array` have the least priority.
+    def prepend_path(path)
+      expire_index!
+      @trail.paths.unshift(path)
+    end
+
+    # Append a `path` to the `paths` list.
+    #
+    # Paths at the beginning of the `Array` have a higher priority.
+    def append_path(path)
+      expire_index!
+      @trail.paths.push(path)
+    end
+
+    # Clear all paths and start fresh.
+    #
+    # There is no mechanism for reordering paths, so its best to
+    # completely wipe the paths list and reappend them in the order
+    # you want.
+    def clear_paths
+      expire_index!
+      @trail.paths.clear
+    end
+
+    # Returns an `Array` of extensions.
+    #
+    # These extensions maybe omitted from logical path searches.
+    #
+    #     # => [".js", ".css", ".coffee", ".sass", ...]
+    #
+    def extensions
+      trail.extensions.dup
+    end
+
+    # Finds the expanded real path for a given logical path by
+    # searching the environment's paths.
+    #
+    #     resolve("application.js")
+    #     # => "/path/to/app/javascripts/application.js.coffee"
+    #
+    # A `FileNotFound` exception is raised if the file does not exist.
+    def resolve(logical_path, options = {})
+      # If a block is given, preform an iterable search
+      if block_given?
+        trail.find(logical_path.to_s, attributes_for(logical_path).index_path, options) do |path|
+          yield Pathname.new(path)
+        end
+      else
+        resolve(logical_path, options) do |pathname|
+          return pathname
+        end
+        raise FileNotFound, "couldn't find file '#{logical_path}'"
+      end
+    end
+
+    protected
+      def trail
+        @trail
+      end
+
+      def compute_digest
+        digest = super
+
+        # Add paths to environment digest.
+        digest << trail.paths.map { |p| attributes_for(p).relativize_root }.join(',')
+
+        digest
+      end
+
+      def find_asset_in_path(logical_path, options = {})
+        # Strip fingerprint on logical path if there is one.
+        # Not sure how valuable this feature is...
+        if fingerprint = attributes_for(logical_path).path_fingerprint
+          pathname = resolve(logical_path.to_s.sub("-#{fingerprint}", ''))
+        else
+          pathname = resolve(logical_path)
+        end
+      rescue FileNotFound
+        nil
+      else
+        # Build the asset for the actual pathname
+        asset = build_asset(logical_path, pathname, options)
+
+        # Double check request fingerprint against actual digest
+        # Again, not sure if this code path is even reachable
+        if fingerprint && fingerprint != asset.digest
+          logger.error "Nonexistent asset #{logical_path} @ #{fingerprint}"
+          asset = nil
+        end
+
+        asset
+      end
+  end
+end

data/vendor/sprockets/lib/sprockets/utils.rb

@@ -0,0 +1,67 @@
+module Sprockets
+  # `Utils`, we didn't know where else to put it!
+  module Utils
+    # If theres encoding support (aka Ruby 1.9)
+    if "".respond_to?(:valid_encoding?)
+      # Define UTF-8 BOM pattern matcher.
+      # Avoid using a Regexp literal because it inheirts the files
+      # encoding and we want to avoid syntax errors in other interpreters.
+      UTF8_BOM_PATTERN = Regexp.new("\\A\uFEFF".encode('utf-8'))
+
+      def self.read_unicode(pathname)
+        pathname.read.tap do |data|
+          # Eager validate the file's encoding. In most cases we
+          # expect it to be UTF-8 unless `default_external` is set to
+          # something else. An error is usually raised if the file is
+          # saved as UTF-16 when we expected UTF-8.
+          if !data.valid_encoding?
+            raise EncodingError, "#{pathname} has a invalid " +
+              "#{data.encoding} byte sequence"
+
+          # If the file is UTF-8 and theres a BOM, strip it for safe concatenation.
+          elsif data.encoding.name == "UTF-8" && data =~ UTF8_BOM_PATTERN
+            data.sub!(UTF8_BOM_PATTERN, "")
+          end
+        end
+      end
+
+    else
+      # Define UTF-8 and UTF-16 BOM pattern matchers.
+      # Avoid using a Regexp literal to prevent syntax errors in other interpreters.
+      UTF8_BOM_PATTERN  = Regexp.new("\\A\\xEF\\xBB\\xBF")
+      UTF16_BOM_PATTERN = Regexp.new("\\A(\\xFE\\xFF|\\xFF\\xFE)")
+
+      def self.read_unicode(pathname)
+        pathname.read.tap do |data|
+          # If the file is UTF-8 and theres a BOM, strip it for safe concatenation.
+          if data =~ UTF8_BOM_PATTERN
+            data.sub!(UTF8_BOM_PATTERN, "")
+
+          # If we find a UTF-16 BOM, theres nothing we can do on
+          # 1.8. Only UTF-8 is supported.
+          elsif data =~ UTF16_BOM_PATTERN
+            raise EncodingError, "#{pathname} has a UTF-16 BOM. " +
+              "Resave the file as UTF-8 or upgrade to Ruby 1.9."
+          end
+        end
+      end
+    end
+
+    # Prepends a leading "." to an extension if its missing.
+    #
+    #     normalize_extension("js")
+    #     # => ".js"
+    #
+    #     normalize_extension(".css")
+    #     # => ".css"
+    #
+    def self.normalize_extension(extension)
+      extension = extension.to_s
+      if extension[/^\./]
+        extension
+      else
+        ".#{extension}"
+      end
+    end
+  end
+end

data/vendor/sprockets/lib/sprockets/version.rb

@@ -0,0 +1,3 @@
+module Sprockets
+  VERSION = "2.0.0.beta.11"
+end