sprockets 2.1.2 → 2.2.0

data/README.md

@@ -354,6 +354,14 @@ submit a pull request.
 
 ## Version History ##
 
+**2.2.0** (Unreleased)
+
+* Added `sprockets` command line utility.
+* Added rake/sprocketstask.
+* Added json manifest log of compiled assets.
+* Added `stub` directive that allows you to exclude files from the bundle.
+* Added per environment external encoding (Environment#default_external_encoding). Defaults to UTF-8. Fixes issues where LANG is not set correctly and Rubys default external is set to ASCII.
+
 **2.1.2** (November 20, 2011)
 
 * Disabled If-Modified-Since server checks. Fixes some browser caching issues when serving the asset body only. If-None-Match caching is sufficent.

data/bin/sprockets

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+require 'sprockets'
+require 'optparse'
+require 'shellwords'
+
+unless ARGV.delete("--noenv")
+  if File.exist?(path = "./.sprocketsrc")
+    rcflags = Shellwords.split(File.read(path))
+    ARGV.unshift(*rcflags)
+  end
+end
+
+filenames = []
+environment = Sprockets::Environment.new(Dir.pwd)
+manifest = nil
+
+(ENV['SPROCKETS_PATH'] || "").split(File::PATH_SEPARATOR).each do |path|
+  environment.append_path path
+end
+
+OptionParser.new do |opts|
+  opts.summary_width = 28
+  opts.banner = "Usage: sprockets [options] filename [filename ...]"
+
+  def opts.show_usage
+    puts self
+    exit 1
+  end
+
+  opts.on("-r", "--require LIBRARY", "Require the LIBRARY before doing anything") do |lib|
+    require lib
+  end
+
+  opts.on("-I DIRECTORY", "--include=DIRECTORY", "Adds the directory to the Sprockets load path") do |directory|
+    environment.append_path directory
+  end
+
+  opts.on("-o DIRECTORY", "--output=DIRECTORY", "Copy provided assets into DIRECTORY") do |directory|
+    manifest = Sprockets::Manifest.new(environment, directory)
+  end
+
+  opts.on("--noenv", "Disables .sprocketsrc file") do
+  end
+
+  opts.on_tail("-h", "--help", "Shows this help message") do
+    opts.show_usage
+  end
+
+  opts.on_tail("-v", "--version", "Shows version") do
+    puts Sprockets::VERSION
+    exit
+  end
+
+  opts.show_usage if ARGV.empty?
+
+  begin
+    opts.order(ARGV) do |filename|
+      filenames << File.expand_path(filename)
+    end
+  rescue OptionParser::ParseError => e
+    opts.warn e.message
+    opts.show_usage
+  end
+end
+
+if environment.paths.empty?
+  warn "No load paths given"
+  warn "Usage: sprockets -Ijavascripts/ filename"
+  exit 1
+end
+
+if manifest
+  manifest.compile(filenames)
+elsif filenames.length == 1
+  puts environment.find_asset(filenames.first).to_s
+else
+  warn "Only one file can be compiled to stdout at a time"
+  exit 1
+end

data/lib/rake/sprocketstask.rb

@@ -0,0 +1,140 @@
+require 'rake'
+require 'rake/tasklib'
+
+require 'sprockets'
+require 'logger'
+
+module Rake
+  # Simple Sprockets compilation Rake task macro.
+  #
+  #   Rake::SprocketsTask.new do |t|
+  #     t.environment = Sprockets::Environment.new
+  #     t.output      = "./public/assets"
+  #     t.assets      = %w( application.js application.css )
+  #   end
+  #
+  class SprocketsTask < Rake::TaskLib
+    # Name of the task. Defaults to "assets".
+    #
+    # The name will also be used to suffix the clean and clobber
+    # tasks, "clean_assets" and "clobber_assets".
+    attr_accessor :name
+
+    # `Environment` instance used for finding assets.
+    #
+    # You'll most likely want to reassign `environment` to your own.
+    #
+    #   Rake::SprocketsTask.new do |t|
+    #     t.environment = Foo::Assets
+    #   end
+    #
+    def environment
+      if !@environment.is_a?(Sprockets::Base) && @environment.respond_to?(:call)
+        @environment = @environment.call
+      else
+        @environment
+      end
+    end
+    attr_writer :environment
+
+    # Directory to write compiled assets too. As well as the manifest file.
+    #
+    #   t.output = "./public/assets"
+    #
+    attr_accessor :output
+
+    # Array of asset logical paths to compile.
+    #
+    #   t.assets = %w( application.js jquery.js application.css )
+    #
+    attr_accessor :assets
+
+    # Number of old assets to keep.
+    attr_accessor :keep
+
+    # Logger to use during rake tasks. Defaults to using stderr.
+    #
+    #   t.logger = Logger.new($stdout)
+    #
+    attr_accessor :logger
+
+    # Returns logger level Integer.
+    def log_level
+      @logger.level
+    end
+
+    # Set logger level with constant or symbol.
+    #
+    #   t.log_level = Logger::INFO
+    #   t.log_level = :debug
+    #
+    def log_level=(level)
+      if level.is_a?(Integer)
+        @logger.level = level
+      else
+        @logger.level = Logger.const_get(level.to_s.upcase)
+      end
+    end
+
+    def initialize(name = :assets)
+      @name         = name
+      @environment  = lambda { Sprockets::Environment.new(Dir.pwd) }
+      @logger       = Logger.new($stderr)
+      @logger.level = Logger::INFO
+      @keep         = 2
+
+      yield self if block_given?
+
+      define
+    end
+
+    # Define tasks
+    def define
+      desc name == :assets ? "Compile assets" : "Compile #{name} assets"
+      task name do
+        with_logger do
+          manifest.compile(assets)
+        end
+      end
+
+      desc name == :assets ? "Remove all assets" : "Remove all #{name} assets"
+      task "clobber_#{name}" do
+        with_logger do
+          manifest.clobber
+        end
+      end
+
+      task :clobber => ["clobber_#{name}"]
+
+      desc name == :assets ? "Clean old assets" : "Clean old #{name} assets"
+      task "clean_#{name}" do
+        with_logger do
+          manifest.clean(keep)
+        end
+      end
+
+      task :clean => ["clean_#{name}"]
+    end
+
+    private
+      # Returns cached indexed environment
+      def index
+        @index ||= environment.index
+      end
+
+      # Returns manifest for tasks
+      def manifest
+        @manifest ||= Sprockets::Manifest.new(index, output)
+      end
+
+      # Sub out environment logger with our rake task logger that
+      # writes to stderr.
+      def with_logger
+        old_logger = index.logger
+        index.logger = @logger
+        yield
+      ensure
+        index.logger = old_logger
+      end
+  end
+end

data/lib/sprockets.rb

@@ -6,6 +6,7 @@ module Sprockets
   autoload :Engines,                 "sprockets/engines"
   autoload :Environment,             "sprockets/environment"
   autoload :Index,                   "sprockets/index"
+  autoload :Manifest,                "sprockets/manifest"
 
   # Assets
   autoload :Asset,                   "sprockets/asset"

data/lib/sprockets/asset.rb

@@ -138,6 +138,8 @@ module Sprockets
       # Gzip contents if filename has '.gz'
       options[:compress] ||= File.extname(filename) == '.gz'
 
+      FileUtils.mkdir_p File.dirname(filename)
+
       File.open("#{filename}+", 'wb') do |f|
         if options[:compress]
           # Run contents through `Zlib`

data/lib/sprockets/base.rb

@@ -103,6 +103,12 @@ module Sprockets
       raise NotImplementedError
     end
 
+    if defined? Encoding.default_external
+      # Define `default_external_encoding` accessor on 1.9.
+      # Defaults to UTF-8.
+      attr_accessor :default_external_encoding
+    end
+
     # Works like `Dir.entries`.
     #
     # Subclasses may cache this method.
@@ -204,13 +210,15 @@ module Sprockets
       nil
     end
 
-    def each_logical_path
-      return to_enum(__method__) unless block_given?
+    def each_logical_path(*args)
+      return to_enum(__method__, *args) unless block_given?
+      filters = args.flatten
       files = {}
       each_file do |filename|
-        logical_path = attributes_for(filename).logical_path
-        yield logical_path unless files[logical_path]
-        files[logical_path] = true
+        if logical_path = logical_path_for_filename(filename, filters)
+          yield logical_path unless files[logical_path]
+          files[logical_path] = true
+        end
       end
       nil
     end
@@ -263,5 +271,37 @@ module Sprockets
       ensure
         Thread.current[:sprockets_circular_calls] = nil if reset
       end
+
+      def logical_path_for_filename(filename, filters)
+        logical_path = attributes_for(filename).logical_path.to_s
+
+        if matches_filter(filters, logical_path)
+          return logical_path
+        end
+
+        # If filename is an index file, retest with alias
+        if File.basename(logical_path)[/[^\.]+/, 0] == 'index'
+          path = logical_path.sub(/\/index\./, '.')
+          if matches_filter(filters, path)
+            return path
+          end
+        end
+
+        nil
+      end
+
+      def matches_filter(filters, filename)
+        return true if filters.empty?
+
+        filters.any? do |filter|
+          if filter.is_a?(Regexp)
+            filter.match(filename)
+          elsif filter.respond_to?(:call)
+            filter.call(filename)
+          else
+            File.fnmatch(filter.to_s, filename)
+          end
+        end
+      end
   end
 end

data/lib/sprockets/context.rb

@@ -11,7 +11,7 @@ module Sprockets
   # helpers by injecting them into `Environment#context_class`. Do not
   # mix them into `Context` directly.
   #
-  #     environment.instance_eval do
+  #     environment.context_class.class_eval do
   #       include MyHelper
   #       def asset_url; end
   #     end
@@ -22,7 +22,8 @@ module Sprockets
   # assets. See `DirectiveProcessor` for an example of this.
   class Context
     attr_reader :environment, :pathname
-    attr_reader :_required_paths, :_dependency_paths, :_dependency_assets
+    attr_reader :_required_paths, :_stubbed_assets
+    attr_reader :_dependency_paths, :_dependency_assets
     attr_writer :__LINE__
 
     def initialize(environment, logical_path, pathname)
@@ -32,6 +33,7 @@ module Sprockets
       @__LINE__     = nil
 
       @_required_paths    = []
+      @_stubbed_assets    = Set.new
       @_dependency_paths  = Set.new
       @_dependency_assets = Set.new([pathname.to_s])
     end
@@ -143,6 +145,14 @@ module Sprockets
       nil
     end
 
+    # `stub_asset` blacklists `path` from being included in the bundle.
+    # `path` must be an asset which may or may not already be included
+    # in the bundle.
+    def stub_asset(path)
+      @_stubbed_assets << resolve(path, :content_type => :self).to_s
+      nil
+    end
+
     # Tests if target path is able to be safely required into the
     # current concatenation.
     def asset_requirable?(path)
@@ -168,7 +178,13 @@ module Sprockets
       if options[:data]
         result = options[:data]
       else
-        result = Sprockets::Utils.read_unicode(pathname)
+        if environment.respond_to?(:default_external_encoding)
+          mime_type = environment.mime_types(pathname.extname)
+          encoding  = environment.encoding_for_mime_type(mime_type)
+          result    = Sprockets::Utils.read_unicode(pathname, encoding)
+        else
+          result = Sprockets::Utils.read_unicode(pathname)
+        end
       end
 
       processors.each do |processor|

data/lib/sprockets/directive_processor.rb

@@ -260,7 +260,7 @@ module Sprockets
           root = pathname.dirname.join(path).expand_path
 
           unless (stats = stat(root)) && stats.directory?
-            raise ArgumentError, "require_tree argument must be a directory"
+            raise ArgumentError, "require_directory argument must be a directory"
           end
 
           context.depend_on(root)
@@ -340,6 +340,18 @@ module Sprockets
         context.depend_on_asset(path)
       end
 
+      # Allows dependency to be excluded from the asset bundle.
+      #
+      # The `path` must be a valid asset and may or may not already
+      # be part of the bundle. Once stubbed, it is blacklisted and
+      # can't be brought back by any other `require`.
+      #
+      #     //= stub "jquery"
+      #
+      def process_stub_directive(path)
+        context.stub_asset(path)
+      end
+
       # Enable Sprockets 1.x compat mode.
       #
       # Makes it possible to use the same JavaScript source

data/lib/sprockets/environment.rb

@@ -23,6 +23,10 @@ module Sprockets
       self.logger = Logger.new($stderr)
       self.logger.level = Logger::FATAL
 
+      if respond_to?(:default_external_encoding)
+        self.default_external_encoding = Encoding::UTF_8
+      end
+
       # Create a safe `Context` subclass to mutate
       @context_class = Class.new(Context)
 

data/lib/sprockets/index.rb

@@ -14,6 +14,10 @@ module Sprockets
     def initialize(environment)
       @environment = environment
 
+      if environment.respond_to?(:default_external_encoding)
+        @default_external_encoding = environment.default_external_encoding
+      end
+
       # Copy environment attributes
       @logger            = environment.logger
       @context_class     = environment.context_class

data/lib/sprockets/manifest.rb

@@ -0,0 +1,203 @@
+require 'multi_json'
+require 'time'
+
+module Sprockets
+  # The Manifest logs the contents of assets compiled to a single
+  # directory. It records basic attributes about the asset for fast
+  # lookup without having to compile. A pointer from each logical path
+  # indicates with fingerprinted asset is the current one.
+  #
+  # The JSON is part of the public API and should be considered
+  # stable. This should make it easy to read from other programming
+  # languages and processes that don't have sprockets loaded. See
+  # `#assets` and `#files` for more infomation about the structure.
+  class Manifest
+    attr_reader :environment, :path, :dir
+
+    # Create new Manifest associated with an `environment`. `path` is
+    # a full path to the manifest json file. The file may or may not
+    # already exist. The dirname of the `path` will be used to write
+    # compiled assets to. Otherwise, if the path is a directory, the
+    # filename will default to "manifest.json" in that directory.
+    #
+    #   Manifest.new(environment, "./public/assets/manifest.json")
+    #
+    def initialize(environment, path)
+      @environment = environment
+
+      if File.extname(path) == ""
+        @dir  = File.expand_path(path)
+        @path = File.join(@dir, 'manifest.json')
+      else
+        @path = File.expand_path(path)
+        @dir  = File.dirname(path)
+      end
+
+      data = nil
+
+      begin
+        if File.exist?(@path)
+          data = MultiJson.decode(File.read(@path))
+        end
+      rescue MultiJson::DecodeError => e
+        logger.error "#{@path} is invalid: #{e.class} #{e.message}"
+      end
+
+      @data = data.is_a?(Hash) ? data : {}
+    end
+
+    # Returns internal assets mapping. Keys are logical paths which
+    # map to the latest fingerprinted filename.
+    #
+    #   Logical path (String): Fingerprint path (String)
+    #
+    #   { "application.js" => "application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js",
+    #     "jquery.js"      => "jquery-ae0908555a245f8266f77df5a8edca2e.js" }
+    #
+    def assets
+      @data['assets'] ||= {}
+    end
+
+    # Returns internal file directory listing. Keys are filenames
+    # which map to an attributes array.
+    #
+    #   Fingerprint path (String):
+    #     logical_path: Logical path (String)
+    #     mtime: ISO8601 mtime (String)
+    #     digest: Base64 hex digest (String)
+    #
+    #  { "application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js" =>
+    #      { 'logical_path' => "application.js",
+    #        'mtime' => "2011-12-13T21:47:08-06:00",
+    #        'digest' => "2e8e9a7c6b0aafa0c9bdeec90ea30213" } }
+    #
+    def files
+      @data['files'] ||= {}
+    end
+
+    # Compile and write asset to directory. The asset is written to a
+    # fingerprinted filename like
+    # `application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js`. An entry is
+    # also inserted into the manifest file.
+    #
+    #   compile("application.js")
+    #
+    def compile(*args)
+      paths = environment.each_logical_path(*args).to_a +
+        args.flatten.select { |fn| Pathname.new(fn).absolute? }
+
+      paths.each do |path|
+        if asset = find_asset(path)
+          files[asset.digest_path] = {
+            'logical_path' => asset.logical_path,
+            'mtime'        => asset.mtime.iso8601,
+            'digest'       => asset.digest
+          }
+          assets[asset.logical_path] = asset.digest_path
+
+          target = File.join(dir, asset.digest_path)
+
+          if File.exist?(target)
+            logger.debug "Skipping #{target}, already exists"
+          else
+            logger.info "Writing #{target}"
+            asset.write_to target
+          end
+
+          save
+          asset
+        end
+      end
+    end
+
+    # Removes file from directory and from manifest. `filename` must
+    # be the name with any directory path.
+    #
+    #   manifest.remove("application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js")
+    #
+    def remove(filename)
+      path = File.join(dir, filename)
+      logical_path = files[filename]['logical_path']
+
+      if assets[logical_path] == filename
+        assets.delete(logical_path)
+      end
+
+      files.delete(filename)
+      FileUtils.rm(path) if File.exist?(path)
+
+      save
+
+      logger.warn "Removed #{filename}"
+
+      nil
+    end
+
+    # Cleanup old assets in the compile directory. By default it will
+    # keep the latest version plus 2 backups.
+    def clean(keep = 2)
+      self.assets.keys.each do |logical_path|
+        # Get assets sorted by ctime, newest first
+        assets = backups_for(logical_path)
+
+        # Keep the last N backups
+        assets = assets[keep..-1] || []
+
+        # Remove old assets
+        assets.each { |path, _| remove(path) }
+      end
+    end
+
+    # Wipe directive
+    def clobber
+      FileUtils.rm_r(@dir) if File.exist?(@dir)
+      logger.warn "Removed #{@dir}"
+      nil
+    end
+
+    protected
+      # Finds all the backup assets for a logical path. The latest
+      # version is always excluded. The return array is sorted by the
+      # assets mtime in descending order (Newest to oldest).
+      def backups_for(logical_path)
+        files.select { |filename, attrs|
+          # Matching logical paths
+          attrs['logical_path'] == logical_path &&
+            # Excluding whatever asset is the current
+            assets[logical_path] != filename
+        }.sort_by { |filename, attrs|
+          # Sort by timestamp
+          Time.parse(attrs['mtime'])
+        }.reverse
+      end
+
+      # Basic wrapper around Environment#find_asset. Logs compile time.
+      def find_asset(logical_path)
+        asset = nil
+        ms = benchmark do
+          asset = environment.find_asset(logical_path)
+        end
+        logger.warn "Compiled #{logical_path}  (#{ms}ms)"
+        asset
+      end
+
+      # Persist manfiest back to FS
+      def save
+        FileUtils.mkdir_p dir
+        File.open(path, 'w') do |f|
+          f.write MultiJson.encode(@data)
+        end
+      end
+
+    private
+      def logger
+        environment.logger
+      end
+
+      def benchmark
+        start_time = Time.now.to_f
+        yield
+        ((Time.now.to_f - start_time) * 1000).to_i
+      end
+  end
+end

data/lib/sprockets/mime.rb

@@ -30,6 +30,16 @@ module Sprockets
       ext = Sprockets::Utils.normalize_extension(ext)
       @mime_types[ext] = mime_type
     end
+
+    if defined? Encoding
+      # Returns the correct encoding for a given mime type, while falling
+      # back on the default external encoding, if it exists.
+      def encoding_for_mime_type(type)
+        encoding = Encoding::BINARY if type =~ %r{^(image|audio|video)/}
+        encoding ||= default_external_encoding if respond_to?(:default_external_encoding)
+        encoding
+      end
+    end
   end
 
   # Extend Sprockets module to provide global registry

data/lib/sprockets/processed_asset.rb

@@ -94,27 +94,31 @@ module Sprockets
 
     private
       def build_required_assets(environment, context)
-        @required_assets = []
-        required_assets_cache = {}
+        @required_assets = resolve_dependencies(environment, context._required_paths + [pathname.to_s]) -
+          resolve_dependencies(environment, context._stubbed_assets.to_a)
+      end
+
+      def resolve_dependencies(environment, paths)
+        assets = []
+        cache  = {}
 
-        (context._required_paths + [pathname.to_s]).each do |path|
+        paths.each do |path|
           if path == self.pathname.to_s
-            unless required_assets_cache[self]
-              required_assets_cache[self] = true
-              @required_assets << self
+            unless cache[self]
+              cache[self] = true
+              assets << self
             end
           elsif asset = environment.find_asset(path, :bundle => false)
             asset.required_assets.each do |asset_dependency|
-              unless required_assets_cache[asset_dependency]
-                required_assets_cache[asset_dependency] = true
-                @required_assets << asset_dependency
+              unless cache[asset_dependency]
+                cache[asset_dependency] = true
+                assets << asset_dependency
               end
             end
           end
         end
 
-        required_assets_cache.clear
-        required_assets_cache = nil
+        assets
       end
 
       def build_dependency_paths(environment, context)

data/lib/sprockets/static_asset.rb

@@ -23,6 +23,8 @@ module Sprockets
       # Gzip contents if filename has '.gz'
       options[:compress] ||= File.extname(filename) == '.gz'
 
+      FileUtils.mkdir_p File.dirname(filename)
+
       if options[:compress]
         # Open file and run it through `Zlib`
         pathname.open('rb') do |rd|

data/lib/sprockets/utils.rb

@@ -8,19 +8,21 @@ module Sprockets
       # 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"
+      def self.read_unicode(pathname, external_encoding = Encoding.default_external)
+        pathname.open("r:#{external_encoding}") do |f|
+          f.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, "")
+            # 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
       end

data/lib/sprockets/version.rb

@@ -1,3 +1,3 @@
 module Sprockets
-  VERSION = "2.1.2"
+  VERSION = "2.2.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sprockets
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 7
   prerelease: 
   segments: 
   - 2
-  - 1
   - 2
-  version: 2.1.2
+  - 0
+  version: 2.2.0
 platform: ruby
 authors: 
 - Sam Stephenson
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-20 00:00:00 -06:00
+date: 2012-01-10 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -35,7 +35,7 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rack
+  name: multi_json
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
@@ -50,9 +50,24 @@ dependencies:
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: tilt
+  name: rack
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: tilt
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -71,11 +86,11 @@ dependencies:
         - 0
         version: 1.3.0
   type: :runtime
-  version_requirements: *id003
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: coffee-script
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -86,11 +101,27 @@ dependencies:
         - 0
         version: "2.0"
   type: :development
-  version_requirements: *id004
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: coffee-script-source
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 1
+        - 2
+        - 0
+        version: 1.2.0
+  type: :development
+  version_requirements: *id006
 - !ruby/object:Gem::Dependency 
   name: eco
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -101,11 +132,11 @@ dependencies:
         - 0
         version: "1.0"
   type: :development
-  version_requirements: *id005
+  version_requirements: *id007
 - !ruby/object:Gem::Dependency 
   name: ejs
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -116,11 +147,11 @@ dependencies:
         - 0
         version: "1.0"
   type: :development
-  version_requirements: *id006
+  version_requirements: *id008
 - !ruby/object:Gem::Dependency 
   name: execjs
   prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -131,11 +162,11 @@ dependencies:
         - 0
         version: "1.0"
   type: :development
-  version_requirements: *id007
+  version_requirements: *id009
 - !ruby/object:Gem::Dependency 
   name: json
   prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
+  requirement: &id010 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -145,11 +176,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id008
+  version_requirements: *id010
 - !ruby/object:Gem::Dependency 
   name: rack-test
   prerelease: false
-  requirement: &id009 !ruby/object:Gem::Requirement 
+  requirement: &id011 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -159,11 +190,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id009
+  version_requirements: *id011
 - !ruby/object:Gem::Dependency 
   name: rake
   prerelease: false
-  requirement: &id010 !ruby/object:Gem::Requirement 
+  requirement: &id012 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -173,13 +204,13 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id010
+  version_requirements: *id012
 description: Sprockets is a Rack-based asset packaging system that concatenates and serves JavaScript, CoffeeScript, CSS, LESS, Sass, and SCSS.
 email: 
 - sstephenson@gmail.com
 - josh@joshpeek.com
-executables: []
-
+executables: 
+- sprockets
 extensions: []
 
 extra_rdoc_files: []
@@ -187,6 +218,7 @@ extra_rdoc_files: []
 files: 
 - README.md
 - LICENSE
+- lib/rake/sprocketstask.rb
 - lib/sprockets/asset.rb
 - lib/sprockets/asset_attributes.rb
 - lib/sprockets/base.rb
@@ -203,6 +235,7 @@ files:
 - lib/sprockets/errors.rb
 - lib/sprockets/index.rb
 - lib/sprockets/jst_processor.rb
+- lib/sprockets/manifest.rb
 - lib/sprockets/mime.rb
 - lib/sprockets/processed_asset.rb
 - lib/sprockets/processing.rb
@@ -214,6 +247,7 @@ files:
 - lib/sprockets/utils.rb
 - lib/sprockets/version.rb
 - lib/sprockets.rb
+- bin/sprockets
 has_rdoc: true
 homepage: http://getsprockets.org/
 licenses: []