rack-sprockets 0.1.0

data/README.rdoc

@@ -0,0 +1,116 @@
+= Rack::Sprockets
+
+== Description
+
+Sprockets javascript preprocessing for Rack apps.
+
+== Installation
+
+    gem install rack-sprockets
+    
+    # optional, for compression
+    gem install yui-compressor
+
+== Basic Usage
+
+Rack::Sprockets is implemented as a piece of Rack middleware and can be used with
+any Rack-based application. If your application includes a rackup (`.ru`) file
+or uses Rack::Builder to construct the application pipeline, simply require
+and use as follows:
+
+    require 'rack/sprockets'
+
+    # optional - use as necessary
+    Rack::Sprockets.configure do |config|
+      config.compress = true
+      # other configs ...
+    end
+
+    use Rack::Sprockets,
+      :load_path => 'app/scripts',
+      :hosted_at => '/'
+      # additional options ...
+
+    run app
+
+== Using with Rails
+
+Add this to your `config/environment.rb`:
+
+    config.middleware.use "Rack::Sprockets"
+
+Add any configs in an initializer (optional - use as necessary):
+
+    Rack::Sprockets.configure do |config|
+      config.cache = true
+      # additional configs ...
+    end
+
+You should now see `Rack::Sprockets` listed in the middleware pipeline:
+
+    rake middleware
+
+== Available Options
+These are similar to sprockets options and, where applicable, map directly to a corresponding Sprockets option.
+
+* :*root* ['.']
+  - The app root.  The reference point for the source and public options.  Maps to the `:root` Sprockets option.
+
+* :*public* ['public']
+  - The path where static files are located.  Maps to the `:asset_root` Sprockets option.
+
+* :*source* ["app/javascripts"]
+  - The path where Sprockets source files are located.  Notice this does not map to the `:source_files` Sprockets option.  It is assumed that any requested resource found in `:source` be treated as a Sprockets source file.
+  
+* :*hosted_at* ["/javascripts"]
+  - The public hosted HTTP path for static javascripts files.
+
+* :*load_path* [["app/javascripts/", "vendor/javascripts/"]]
+  - An ordered array of directory names to search for dependencies in.  Maps to the `:load_path` Sprockets option.
+  
+* :*expand_paths* [true]
+  - Whether or not to expand filenames according to shell glob rules.  Maps to the `:expand_paths` Sprockets option.
+
+== Available Configurations
+* .*cache* [false]
+  - Whether or not to cache the concatenation output to a corresponding static file.
+
+* .*compress* [false]
+  - Whether or not to apply compression to the concatenation output - uses YUI Compressor if available or will remove extraneous whitespace if not.
+
+== Links
+
+* *GitHub*
+  - http://github.com/kelredd/rack-sprockets
+
+* *Sprockets*
+  - http://getsprockets.org
+
+* *Yui* *Compressor*
+  - http://github.com/sstephenson/ruby-yui-compressor
+  - http://developer.yahoo.com/yui/compressor
+
+== License
+
+Copyright (c) 2010 Kelly Redding (mailto:kelly@kelredd.com)
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,61 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+require 'lib/rack/sprockets/version'
+
+spec = Gem::Specification.new do |s|
+  s.name             = 'rack-sprockets'
+  s.version          = RackSprockets::Version.to_s
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w(README.rdoc)
+  s.rdoc_options     = %w(--main README.rdoc)
+  s.summary          = "Sprockets javascript preprocessing for Rack apps."
+  s.author           = 'Kelly Redding'
+  s.email            = 'kelly@kelredd.com'
+  s.homepage         = 'http://github.com/kelredd/rack-sprockets'
+  s.files            = %w(README.rdoc Rakefile) + Dir.glob("{lib}/**/*")
+  # s.executables    = ['rack-sprockets']
+
+  s.add_development_dependency("shoulda", [">= 2.10.0"])
+  s.add_development_dependency("sinatra", [">= 0.9.4"])
+  s.add_development_dependency("rack-test", [">= 0.5.3"])
+  s.add_development_dependency("webrat", [">= 0.6.0"])
+
+  s.add_dependency("rack", [">= 0.4"])
+  s.add_dependency("sprockets", [">= 1.0.0"])
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+
+  Rcov::RcovTask.new(:coverage) do |t|
+    t.libs       = ['test']
+    t.test_files = FileList["test/**/*_test.rb"]
+    t.verbose    = true
+    t.rcov_opts  = ['--text-report', "-x #{Gem.path}", '-x /Library/Ruby', '-x /usr/lib/ruby']
+  end
+  
+  task :default => :coverage
+  
+rescue LoadError
+  warn "\n**** Install rcov (sudo gem install relevance-rcov) to get coverage stats ****\n"
+  task :default => :test
+end
+
+desc 'Generate the gemspec to serve this gem'
+task :gemspec do
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, 'w') {|f| f << spec.to_ruby }
+  puts "Created gemspec: #{file}"
+end

data/lib/rack/sprockets.rb

@@ -0,0 +1,51 @@
+require 'rack'
+require 'rack/sprockets/config'
+require 'rack/sprockets/options'
+require 'rack/sprockets/source'
+require 'rack/sprockets/base'
+require 'rack/sprockets/request'
+require 'rack/sprockets/response'
+
+# === Usage
+#
+# Create with default configs:
+#   require 'rack/sprockets'
+#   Rack::Sprockets.new(app, :compress => true)
+#
+# Within a rackup file (or with Rack::Builder):
+#   require 'rack/sprockets'
+#
+#   use Rack::Sprockets,
+#     :source   => 'app/scripts'
+#     :compress => true
+#
+#   run app
+
+module Rack::Sprockets
+  MIME_TYPE = "text/javascript"
+  @@config = Config.new
+  
+  class << self
+    
+    # Configuration accessors for Rack::Sprockets
+    # (see config.rb for details)
+    def configure
+      yield @@config if block_given?
+    end
+    def config
+      @@config
+    end
+    def config=(value)
+      @@config = value
+    end
+    
+  end
+
+  # Create a new Rack::Sprockets middleware component 
+  # => the +options+ Hash can be used to specify default option values
+  # => (see Rack::Sprockets::Options for possible key/values)
+  def self.new(app, options={}, &block)
+    Base.new(app, options, &block)
+  end
+  
+end

data/lib/rack/sprockets/base.rb

@@ -0,0 +1,67 @@
+require 'rack/sprockets/options'
+require 'rack/sprockets/request'
+require 'rack/sprockets/response'
+
+module Rack::Sprockets
+  class Base
+    include Rack::Sprockets::Options
+
+    def initialize(app, options={})
+      @app = app
+      initialize_options options
+      yield self if block_given?
+      validate_options
+    end
+
+    # The Rack call interface. The receiver acts as a prototype and runs
+    # each request in a clone object unless the +rack.run_once+ variable is
+    # set in the environment.
+    def call(env)
+      if env['rack.run_once']
+        call! env
+      else
+        clone.call! env
+      end
+    end
+
+    # The real Rack call interface.
+    # if Sprockets JS is being requested, this is an endpoint:
+    # => generate the compiled javascripts
+    # => respond appropriately
+    # Otherwise, call on up to the app as normal
+    def call!(env)
+      @default_options.each { |k,v| env[k] ||= v }
+      @env = env
+      
+      if (@request = Request.new(@env.dup.freeze)).for_sprockets?
+        Response.new(@env.dup.freeze, @request.source.to_js).to_rack
+      else
+        @app.call(env)
+      end
+    end
+    
+    private
+    
+    def validate_options
+      # ensure a root path is specified and does exists
+      unless options.has_key?(option_name(:root)) and !options(:root).nil?
+        raise(ArgumentError, "no :root option set")
+      end
+      unless File.exists?(options(:root))
+        raise(ArgumentError, "the :root path ('#{options(:root)}') does not exist") 
+      end
+
+      set :root, File.expand_path(options(:root))
+
+      # ensure a source path is specified and does exists
+      unless options.has_key?(option_name(:source)) and !options(:source).nil?
+        raise(ArgumentError, "no :source option set")
+      end
+      source_path = File.join(options(:root), options(:source))
+      unless File.exists?(source_path)
+        raise(ArgumentError, "the :source path ('#{source_path}') does not exist") 
+      end
+    end
+
+  end
+end

data/lib/rack/sprockets/config.rb

@@ -0,0 +1,40 @@
+module Rack::Sprockets
+  
+  # Handles configuration for Rack::Sprockets
+  # Available config settings:
+  # :cache
+  #   whether to cache the compilation output to
+  #   a corresponding static file. Also determines
+  #   what value config#combinations(:key) returns
+  # :compress
+  #   Whether or not to apply compression to the
+  #   concatenation output - uses YUI Compressor
+  #   if available or will remove extraneous
+  #   whitespace if not.
+  
+  class Config
+    
+    ATTRIBUTES = [:cache, :compress]
+    attr_accessor *ATTRIBUTES
+    
+    DEFAULTS = {
+      :cache    => false,
+      :compress => false
+    }
+
+    def initialize(settings={})
+      ATTRIBUTES.each do |a|
+        instance_variable_set("@#{a}", settings[a] || DEFAULTS[a])
+      end
+    end
+    
+    def cache?
+      !!@cache
+    end
+    
+    def compress?
+      !!@compress
+    end
+    
+  end
+end

data/lib/rack/sprockets/options.rb

@@ -0,0 +1,131 @@
+module Rack::Sprockets
+  module Options
+    
+    # Handles options for Rack::Sprockets
+    # Available options:
+    # => root
+    #    The app root.  The reference point for
+    #    the source and public options.  Maps to
+    #    the `:root` Sprockets option.
+    # => public
+    #    The path where static files are located.
+    #    Maps to the `:asset_root` Sprockets option.
+    # => source
+    #    The path where Sprockets source files are
+    #    located.  Notice this does not map to the
+    #    `:source_files` Sprockets option.  It is
+    #    assumed that any requested resource found
+    #    in `:source` be treated as a Sprockets
+    #    source file.
+    # => hosted_at
+    #    The public hosted HTTP path for static
+    #    javascripts files.
+    # => load_path
+    #    An ordered array of directory names to
+    #    search for dependencies in.  Maps to the
+    #    `:load_path` Sprockets option.
+    # => expand_paths
+    #    Whether or not to expand filenames according
+    #    to shell glob rules.  Maps to the
+    #    `:expand_paths` Sprockets option.
+    
+    RACK_ENV_NS = "rack-sprockets"
+    COLLECTION_OPTS = ["#{RACK_ENV_NS}.load_path"]
+    
+    module ClassMethods
+      
+      def defaults
+        {
+          option_name(:root)         => ".",
+          option_name(:public)       => 'public',
+          option_name(:source)       => 'app/javascripts',
+          option_name(:hosted_at)    => '/javascripts',
+          option_name(:load_path)    => [
+            "app/javascripts/",
+            "vendor/javascripts/"
+          ],
+          option_name(:expand_paths) => true
+        }
+      end
+
+      # Rack::Sprockets uses the Rack Environment to store option values. All options
+      # are stored in the Rack Environment as "<RACK_ENV_PREFIX>.<option>", where
+      # <option> is the option name.
+      def option_name(key)
+        case key
+        when Symbol ; "#{RACK_ENV_NS}.#{key}"
+        when String ; key
+        else raise ArgumentError
+        end
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+      # Rack::Sprockets uses the Rack Environment to store option values. All options
+      # are stored in the Rack Environment as "<RACK_ENV_PREFIX>.<option>", where
+      # <option> is the option name.
+      def option_name(key)
+        self.class.option_name(key)
+      end
+      
+      # The underlying options Hash. During initialization (or outside of a
+      # request), this is a default values Hash. During a request, this is the
+      # Rack environment Hash. The default values Hash is merged in underneath
+      # the Rack environment before each request is processed.
+      # => if a key is passed, the option value for the key is returned
+      def options(key=nil)
+        if key
+          (@env || @default_options)[option_name(key)]
+        else
+          @env || @default_options
+        end
+      end
+
+      # Set multiple options at once.
+      def options=(hash={})
+        hash.each { |key,value| write_option(key, value) }
+      end 
+
+      # Set an option. When +option+ is a Symbol, it is set in the Rack
+      # Environment as "rack-cache.option". When +option+ is a String, it
+      # exactly as specified. The +option+ argument may also be a Hash in
+      # which case each key/value pair is merged into the environment as if
+      # the #set method were called on each.
+      def set(option, value=nil)
+        if value.nil?
+          self.options = option.to_hash
+        else
+          write_option option, value
+        end
+      end
+
+      private
+
+      def initialize_options(options={})
+        @default_options = self.class.defaults
+        self.options = options
+      end
+
+      def read_option(key)
+        options[option_name(key)]
+      end
+
+      def write_option(key, value)
+        if COLLECTION_OPTS.include?(opt_name = option_name(key))
+          options[opt_name] = [*value]
+        else
+          options[opt_name] = value
+        end
+      end
+
+    end
+    
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+    
+  end
+end

data/lib/rack/sprockets/request.rb

@@ -0,0 +1,78 @@
+require 'rack/request'
+require 'rack/sprockets'
+require 'rack/sprockets/options'
+require 'rack/sprockets/source'
+
+module Rack::Sprockets
+
+  # Provides access to the HTTP request.
+  # Request objects respond to everything defined by Rack::Request
+  # as well as some additional convenience methods defined here
+
+  class Request < Rack::Request
+    include Rack::Sprockets::Options
+    
+    JS_PATH_FORMATS = ['.js']
+
+    # The HTTP request method. This is the standard implementation of this
+    # method but is respecified here due to libraries that attempt to modify
+    # the behavior to respect POST tunnel method specifiers. We always want
+    # the real request method.
+    def request_method
+      @env['REQUEST_METHOD']
+    end
+    
+    def path_info
+      @env['PATH_INFO']
+    end
+    
+    def http_accept
+      @env['HTTP_ACCEPT']
+    end
+    
+    def path_resource_name
+      File.basename(path_info, path_resource_format)
+    end
+    
+    def path_resource_format
+      File.extname(path_info)
+    end
+
+    # The Rack::Sprockets::Source that the request is for
+    def source
+      @source ||= begin
+        cache = if Rack::Sprockets.config.cache?
+          File.join(options(:root), options(:public), options(:hosted_at))
+        else
+          nil
+        end
+        source_opts = {
+          :folder    => File.join(options(:root), options(:source)),
+          :cache     => cache,
+          :compress  => Rack::Sprockets.config.compress,
+          :secretary => {
+            :root         => options(:root),
+            :load_path    => options(:load_path),
+            :expand_paths => options(:expand_paths)
+          }
+        }
+        Source.new(path_resource_name, source_opts)
+      end
+    end
+
+    def for_js?
+      (http_accept && http_accept.include?(Rack::Sprockets::MIME_TYPE)) ||
+      (media_type  && media_type.include?(Rack::Sprockets::MIME_TYPE )) ||
+      JS_PATH_FORMATS.include?(path_resource_format)
+    end
+
+    # Determine if the request is for an existing Sprockets source file
+    # This will be called on every request so speed is an issue
+    # => first check if the request is a GET on a js resource (fast)
+    # => then check for sprockets source files that match the request (slow)
+    def for_sprockets?
+      get? && for_js? && !source.files.empty?
+    end
+    
+  end
+end

data/lib/rack/sprockets/response.rb

@@ -0,0 +1,45 @@
+require 'rack/response'
+require 'rack/utils'
+
+module Rack::Sprockets
+
+  # Given some generated js, mimicks a Rack::Response
+  # => call to_rack to build standard rack response parameters
+  class Response
+    include Rack::Sprockets::Options
+    include Rack::Response::Helpers
+
+    # Rack response tuple accessors.
+    attr_accessor :status, :headers, :body
+    
+    class << self
+
+      # Calculate appropriate content_length
+      def content_length(body)
+        if body.respond_to?(:bytesize)
+          body.bytesize
+        else
+          body.size
+        end
+      end
+      
+    end
+
+    # Create a Response instance given the env
+    # and some generated js.
+    def initialize(env, js)
+      @env = env
+      @body = js
+      @status = 200 # OK
+      @headers = Rack::Utils::HeaderHash.new
+
+      headers["Content-Type"] = Rack::Sprockets::MIME_TYPE
+      headers["Content-Length"] = self.class.content_length(body).to_s
+    end
+    
+    def to_rack
+      [status, headers.to_hash, body]
+    end
+
+  end
+end

data/lib/rack/sprockets/source.rb

@@ -0,0 +1,118 @@
+require 'sprockets'
+
+begin
+  require "yui/compressor"
+rescue LoadError
+  # only error about missing yui compressor if
+  # :yui compression is requested
+end
+
+module Rack::Sprockets
+
+  class Source
+    
+    PREFERRED_EXTENSIONS = [:js]
+    SECRETARY_DEFAULTS = {
+      :expand_paths => true
+    }
+    YUI_OPTS = {
+      :munge => true
+    }
+    
+    attr_reader :js_name
+    
+    def initialize(js_name, options={})
+      @js_name  = js_name
+      @compress = options[:compress]
+      @cache    = options[:cache]
+
+      @folder   = get_required_path(options, :folder)
+      @secretary = SECRETARY_DEFAULTS.merge(options[:secretary] || {})
+    end
+    
+    def compress?
+      !!@compress
+    end
+    def cache?
+      !@cache.nil?
+    end
+    def cache
+      @cache
+    end
+    
+    def files
+      @files ||= js_sources
+    end    
+    
+    def secretary
+      @secretary_obj ||= Sprockets::Secretary.new(@secretary.merge({
+        :source_files => files
+      }))
+    end
+
+    def compiled
+      @compiled ||= begin
+        compiled_js = secretary.concatenation.to_s
+        
+        compiled_js = case @compress
+        when :whitespace
+          compiled_js.delete("\n")
+        when :yui
+          if defined?(YUI::JavaScriptCompressor)
+            YUI::JavaScriptCompressor.new(YUI_OPTS).compress(compiled_js)
+          else
+            raise LoadError, "YUI::JavaScriptCompressor is not available. Install it with: gem install yui-compressor"
+          end
+        else
+          compiled_js
+        end
+
+        if cache? && !File.exists?(cf = File.join(@cache, "#{@js_name}.js"))
+          FileUtils.mkdir_p(@cache)
+          File.open(cf, "w") do |file|
+            file.write(compiled_js)
+          end
+        end
+        
+        compiled_js
+      end
+    end
+    alias_method :to_js, :compiled
+    alias_method :js, :compiled
+    
+    protected
+    
+    # Source files matching the js name
+    def js_sources
+      @js_sources ||= preferred_sources([*@js_name])
+    end
+    
+    private
+    
+    # Given a list of file names, return a list of
+    # existing source files with the corresponding names
+    # honoring the preferred extension list
+    def preferred_sources(file_names)
+      file_names.collect do |name|
+        PREFERRED_EXTENSIONS.inject(nil) do |source_file, extension|
+          source_file || begin
+            path = File.join(@folder, "#{name}.#{extension}")
+            File.exists?(path) ? path : nil
+          end
+        end
+      end.compact
+    end
+    
+    def get_required_path(options, path_key)
+      unless options.has_key?(path_key)
+        raise(ArgumentError, "no :#{path_key} option specified")
+      end
+      unless File.exists?(options[path_key])
+        raise(ArgumentError, "the :#{path_key} ('#{options[path_key]}') does not exist") 
+      end
+      options[path_key]
+    end
+
+  end
+  
+end

data/lib/rack/sprockets/version.rb

@@ -0,0 +1,13 @@
+module RackSprockets
+  module Version
+    
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+    
+    def self.to_s # :nodoc:
+      [MAJOR, MINOR, TINY].join('.')
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification 
+name: rack-sprockets
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Kelly Redding
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-14 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.10.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: webrat
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.6.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.4"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sprockets
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
+description: 
+email: kelly@kelredd.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- lib/rack/sprockets/base.rb
+- lib/rack/sprockets/config.rb
+- lib/rack/sprockets/options.rb
+- lib/rack/sprockets/request.rb
+- lib/rack/sprockets/response.rb
+- lib/rack/sprockets/source.rb
+- lib/rack/sprockets/version.rb
+- lib/rack/sprockets.rb
+has_rdoc: true
+homepage: http://github.com/kelredd/rack-sprockets
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Sprockets javascript preprocessing for Rack apps.
+test_files: []
+