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

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

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

@@ -1,86 +0,0 @@
-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
-    # Define extra attributes to be serialized.
-    def self.serialized_attributes
-      super + %w( content_type mtime length digest )
-    end
-
-    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 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
-      end
-  end
-end

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

@@ -1,74 +0,0 @@
-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)
-          else
-            # Otherwise use fnmatch glob syntax
-            next unless File.fnmatch(path.to_s, logical_path)
-          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
-
-    private
-      # Get all reachable files in environment path
-      def files
-        files = Set.new
-        paths.each do |base_path|
-          Dir["#{base_path}/**/*"].each do |filename|
-            files << attributes_for(filename).logical_path
-          end
-        end
-        files
-      end
-  end
-end

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

@@ -1,123 +0,0 @@
-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?
-        args = attributes_for(logical_path).search_paths + [options]
-        trail.find(*args) 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

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

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

data/vendor/sprockets/lib/sprockets.rb

@@ -1,31 +0,0 @@
-require 'sprockets/version'
-
-module Sprockets
-  autoload :ArgumentError,           "sprockets/errors"
-  autoload :Asset,                   "sprockets/asset"
-  autoload :AssetAttributes,         "sprockets/asset_attributes"
-  autoload :BundledAsset,            "sprockets/bundled_asset"
-  autoload :CharsetNormalizer,       "sprockets/charset_normalizer"
-  autoload :CircularDependencyError, "sprockets/errors"
-  autoload :ContentTypeMismatch,     "sprockets/errors"
-  autoload :Context,                 "sprockets/context"
-  autoload :DirectiveProcessor,      "sprockets/directive_processor"
-  autoload :EcoTemplate,             "sprockets/eco_template"
-  autoload :EjsTemplate,             "sprockets/ejs_template"
-  autoload :EngineError,             "sprockets/errors"
-  autoload :Engines,                 "sprockets/engines"
-  autoload :Environment,             "sprockets/environment"
-  autoload :Error,                   "sprockets/errors"
-  autoload :FileNotFound,            "sprockets/errors"
-  autoload :Index,                   "sprockets/index"
-  autoload :JstProcessor,            "sprockets/jst_processor"
-  autoload :Processing,              "sprockets/processing"
-  autoload :Processor,               "sprockets/processor"
-  autoload :Server,                  "sprockets/server"
-  autoload :StaticAsset,             "sprockets/static_asset"
-  autoload :Utils,                   "sprockets/utils"
-
-  module Cache
-    autoload :FileStore, "sprockets/cache/file_store"
-  end
-end

data/vendor/sprockets/sprockets.gemspec

@@ -1,30 +0,0 @@
-unless defined? Sprockets::VERSION
-  $:.unshift File.expand_path("../lib", __FILE__)
-  require "sprockets/version"
-end
-
-Gem::Specification.new do |s|
-  s.name = "sprockets"
-  s.version = Sprockets::VERSION
-  s.summary = "Rack-based asset packaging system"
-  s.description = "Sprockets is a Rack-based asset packaging system that concatenates and serves JavaScript, CoffeeScript, CSS, LESS, Sass, and SCSS."
-
-  s.files = Dir["README.md", "LICENSE", "lib/**/*.rb"]
-
-  s.add_dependency "hike", "~> 1.1"
-  s.add_dependency "rack", "~> 1.0"
-  s.add_dependency "tilt", ["~> 1.1", "!= 1.3.0"]
-
-  s.add_development_dependency "coffee-script", "~> 2.0"
-  s.add_development_dependency "eco", "~> 1.0"
-  s.add_development_dependency "ejs", "~> 1.0"
-  s.add_development_dependency "execjs", "~> 1.0"
-  s.add_development_dependency "json"
-  s.add_development_dependency "rack-test"
-  s.add_development_dependency "rake"
-
-  s.authors = ["Sam Stephenson", "Joshua Peek"]
-  s.email = "sstephenson@gmail.com"
-  s.homepage = "http://getsprockets.org/"
-  s.rubyforge_project = "sprockets"
-end

data/vendor/sprockets/test/fixtures/asset/application.js

@@ -1,6 +0,0 @@
-// =require "project"
-// =require "users"
-
-document.on('dom:loaded', function() {
-  $('search').focus();
-});