sstephenson-sprockets 0.1.1

data/Rakefile

@@ -0,0 +1,16 @@
+require "rubygems"
+require "rake/testtask"
+require "rake/gempackagetask"
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/test_*.rb"]
+  t.verbose = true
+end
+
+Rake::GemPackageTask.new(eval(IO.read(File.join(File.dirname(__FILE__), "sprockets.gemspec")))) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end

data/bin/sprocketize

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), *%w".. lib sprockets")
+require "optparse"
+
+load_path = (ENV["SPROCKETS_PATH"] || "").split(":")
+filenames = []
+
+OptionParser.new do |opts|
+  opts.summary_width = 28
+  opts.banner = "Usage: sprocketize [options] filename [filename ...]"
+  
+  def opts.show_usage
+    puts self
+    exit
+  end
+  
+  opts.on("-C DIRECTORY", "--directory=DIRECTORY", "Change to DIRECTORY before doing anything") do |directory|
+    Dir.chdir(directory)
+  end
+  
+  opts.on("-I DIRECTORY", "--include-dir=DIRECTORY", "Adds the directory to the Sprockets load path") do |directory|
+    load_path << directory
+  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::STRING
+    exit
+  end
+  
+  opts.show_usage if ARGV.empty?
+  
+  begin
+    opts.order(ARGV) do |filename|
+      filenames << filename
+    end
+  rescue OptionParser::ParseError => e
+    opts.warn e.message
+    opts.show_usage
+  end
+end
+
+environment  = Sprockets::Environment.new(".", load_path)
+preprocessor = Sprockets::Preprocessor.new(environment)
+
+filenames.each do |filename|
+  if pathname = environment.find(filename)
+    preprocessor.require(pathname.source_file)
+  else
+    raise Sprockets::LoadError, "no such file `#{filename}'"
+  end
+end
+
+print preprocessor.output_file

data/lib/sprockets/environment.rb

@@ -0,0 +1,35 @@
+module Sprockets
+  class Environment
+    attr_reader :root, :load_path
+    
+    def initialize(root, load_path = [])
+      @load_path = [@root = Pathname.new(self, root)]
+
+      load_path.reverse_each do |location|
+        register_load_location(location)
+      end
+    end
+    
+    def pathname_from(location)
+      Pathname.new(self, absolute_location_from(location))
+    end
+
+    def register_load_location(location)
+      pathname = pathname_from(location)
+      load_path.delete(pathname)
+      load_path.unshift(pathname)
+      location
+    end
+    
+    def find(location)
+      load_path.map { |pathname| pathname.find(location) }.compact.first
+    end
+    
+    protected
+      def absolute_location_from(location)
+        location = location.to_s
+        location = File.join(root.absolute_location, location) unless location[/^\//]
+        File.expand_path(location)
+      end
+  end
+end

data/lib/sprockets/error.rb

@@ -0,0 +1,4 @@
+module Sprockets
+  class Error < ::StandardError; end
+  class LoadError < Error;       end
+end

data/lib/sprockets/output_file.rb

@@ -0,0 +1,20 @@
+module Sprockets
+  class OutputFile
+    attr_reader :source_lines
+    
+    def initialize
+      @source_lines = []
+    end
+    
+    def record(source_line)
+      @source_lines << source_line
+      source_line
+    end
+    
+    def to_s
+      @source_lines.map do |source_line|
+        source_line.line
+      end.join
+    end
+  end
+end

data/lib/sprockets/pathname.rb

@@ -0,0 +1,33 @@
+module Sprockets
+  class Pathname
+    attr_reader :environment, :absolute_location
+    
+    def initialize(environment, absolute_location)
+      @environment = environment
+      @absolute_location = File.expand_path(absolute_location)
+    end
+
+    # Returns a Pathname for the location relative to this pathname's absolute location.
+    def find(location)
+      location = File.join(absolute_location, location)
+      File.file?(location) ? Pathname.new(environment, location) : nil
+    end
+
+    def parent_pathname
+      Pathname.new(environment, File.dirname(absolute_location))
+    end
+
+    def source_file
+      SourceFile.new(environment, self)
+    end
+    
+    def ==(pathname)
+      environment == pathname.environment &&
+        absolute_location == pathname.absolute_location
+    end
+    
+    def to_s
+      absolute_location
+    end
+  end
+end

data/lib/sprockets/preprocessor.rb

@@ -0,0 +1,75 @@
+module Sprockets
+  class Preprocessor
+    attr_reader :environment, :output_file, :source_files
+    
+    def initialize(environment, options = {})
+      @environment = environment
+      @output_file = OutputFile.new
+      @source_files = []
+      @options = options
+    end
+    
+    def require(source_file)
+      return if source_files.include?(source_file)
+      source_files << source_file
+      
+      source_file.each_source_line do |source_line|
+        if source_line.require?
+          require_from_source_line(source_line)
+        else
+          record_source_line(source_line)
+        end
+      end
+    end
+    
+    protected
+      attr_reader :options
+    
+      def require_from_source_line(source_line)
+        require pathname_from(source_line).source_file
+      end
+      
+      def record_source_line(source_line)
+        unless source_line.comment? && strip_comments?
+          output_file.record(source_line)
+        end
+      end
+      
+      def strip_comments?
+        options[:strip_comments] != false
+      end
+      
+      def pathname_from(source_line)
+        pathname = send(pathname_finder_from(source_line), source_line)
+        raise_load_error_for(source_line) unless pathname
+        pathname
+      end
+
+      def pathname_for_require_from(source_line)
+        environment.find(location_from(source_line))
+      end
+      
+      def pathname_for_relative_require_from(source_line)
+        source_line.source_file.find(location_from(source_line))
+      end
+
+      def pathname_finder_from(source_line)
+        "pathname_for_#{kind_of_require_from(source_line)}_from"
+      end
+
+      def kind_of_require_from(source_line)
+        source_line.require[/^(.)/, 1] == '"' ? :relative_require : :require
+      end
+
+      def location_from(source_line)
+        location = source_line.require[/^.(.*).$/, 1]
+        File.join(File.dirname(location), File.basename(location, ".js") + ".js")
+      end
+      
+      def raise_load_error_for(source_line)
+        kind = kind_of_require_from(source_line).to_s.tr("_", " ")
+        file = File.split(location_from(source_line)).last
+        raise LoadError, "can't find file for #{kind} `#{file}' (#{source_line.inspect})"
+      end
+  end
+end

data/lib/sprockets/source_file.rb

@@ -0,0 +1,26 @@
+module Sprockets
+  class SourceFile
+    attr_reader :environment, :pathname
+
+    def initialize(environment, pathname)
+      @environment = environment
+      @pathname = pathname
+    end
+    
+    def each_source_line
+      File.open(pathname.absolute_location) do |file|
+        file.each do |line|
+          yield SourceLine.new(self, line, file.lineno)
+        end
+      end
+    end
+    
+    def find(location)
+      pathname.parent_pathname.find(location)
+    end
+    
+    def ==(source_file)
+      pathname == source_file.pathname
+    end
+  end
+end

data/lib/sprockets/source_line.rb

@@ -0,0 +1,31 @@
+module Sprockets
+  class SourceLine
+    attr_reader :source_file, :line, :number
+
+    def initialize(source_file, line, number)
+      @source_file = source_file
+      @line = line
+      @number = number
+    end
+    
+    def comment
+      @comment ||= line[/^\s*\/\/(.*)/, 1]
+    end
+
+    def comment?
+      !!comment
+    end
+
+    def require
+      @require ||= (comment || "")[/^=\s+require\s+(\"(.*?)\"|<(.*?)>)\s*$/, 1]
+    end
+    
+    def require?
+      !!require
+    end
+    
+    def inspect
+      "line #@number of #{@source_file.pathname}"
+    end
+  end
+end

data/lib/sprockets/version.rb

@@ -0,0 +1,9 @@
+module Sprockets
+  module Version
+    MAJOR  = 0
+    MINOR  = 1
+    TINY   = 1
+
+    STRING = [MAJOR, MINOR, TINY].join(".")
+  end
+end

data/lib/sprockets.rb

@@ -0,0 +1,10 @@
+$:.unshift File.dirname(__FILE__)
+
+require "sprockets/version"
+require "sprockets/error"
+require "sprockets/environment"
+require "sprockets/pathname"
+require "sprockets/source_line"
+require "sprockets/source_file"
+require "sprockets/output_file"
+require "sprockets/preprocessor"

data/test/fixtures/double_slash_comments_that_are_not_requires_should_be_ignored_when_strip_comments_is_false.js

@@ -0,0 +1 @@
+// This is a double-slash comment that should appear in the resulting output file.

data/test/fixtures/double_slash_comments_that_are_not_requires_should_be_removed_by_default.js

@@ -0,0 +1,2 @@
+// This is a double-slash comment that should not appear in the resulting output file.
+/* This is a slash-star comment that should appear in the resulting output file. */

data/test/fixtures/requiring_a_file_after_it_has_already_been_required_should_do_nothing.js

@@ -0,0 +1,5 @@
+var before_first_require;
+//= require <foo>
+var after_first_require_and_before_second_require;
+//= require <foo>
+var after_second_require;

data/test/fixtures/requiring_a_file_that_does_not_exist_should_raise_an_error.js

@@ -0,0 +1 @@
+//= require <nonexistent>

data/test/fixtures/requiring_a_single_file_should_replace_the_require_comment_with_the_file_contents.js

@@ -0,0 +1,3 @@
+var before_require;
+//= require <foo>
+var after_require;

data/test/fixtures/requiring_the_current_file_should_do_nothing.js

@@ -0,0 +1 @@
+//= require "requiring_the_current_file_should_do_nothing"

data/test/fixtures/src/foo/bar.js

@@ -0,0 +1,4 @@
+//= require "bar"
+var FooBar = { };
+
+/* Hello! */

data/test/fixtures/src/foo/foo.js

@@ -0,0 +1 @@
+var FooFoo = { };

data/test/fixtures/src/foo.js

@@ -0,0 +1 @@
+var Foo = { };

data/test/test_environment.rb

@@ -0,0 +1,58 @@
+require "test_helper"
+
+class EnvironmentTest < Test::Unit::TestCase
+  def test_load_path_locations_become_pathnames_for_absolute_locations_from_the_root
+    environment = Sprockets::Environment.new("/root", ["/a", "b"])
+    assert_load_path_equals ["/a", "/root/b", "/root"], environment
+  end
+  
+  def test_pathname_from_for_location_with_leading_slash_should_return_a_pathname_with_the_location_unchanged
+    environment = Sprockets::Environment.new("/root")
+    assert_absolute_location "/a", environment.pathname_from("/a")
+  end
+  
+  def test_pathname_from_for_relative_location_should_return_a_pathname_for_the_expanded_absolute_location_from_root
+    environment = Sprockets::Environment.new("/root")
+    assert_absolute_location "/root/a", environment.pathname_from("a")
+    assert_absolute_location "/root/a", environment.pathname_from("./a")
+    assert_absolute_location "/a", environment.pathname_from("../a")
+  end
+  
+  def test_register_load_location_should_unshift_the_location_onto_the_load_path
+    environment = Sprockets::Environment.new("/root")
+    environment.register_load_location("a")
+    assert_load_path_equals ["/root/a", "/root"], environment
+    environment.register_load_location("b")
+    assert_load_path_equals ["/root/b", "/root/a", "/root"], environment
+  end
+  
+  def test_register_load_location_should_remove_already_existing_locations_before_unshifting
+    environment = Sprockets::Environment.new("/root")
+    environment.register_load_location("a")
+    environment.register_load_location("b")
+    assert_load_path_equals ["/root/b", "/root/a", "/root"], environment
+    environment.register_load_location("a")
+    assert_load_path_equals ["/root/a", "/root/b", "/root"], environment
+  end
+  
+  def test_find_should_return_the_first_matching_pathname_in_the_load_path
+    environment = environment_for_fixtures
+    first_pathname = environment.find("foo.js")
+    assert_absolute_location_ends_with "src/foo.js", first_pathname
+    
+    environment.register_load_location(File.join(FIXTURES_PATH, "src", "foo"))
+    second_pathname = environment.find("foo.js")
+    assert_not_equal first_pathname, second_pathname
+    assert_absolute_location_ends_with "foo/foo.js", second_pathname
+  end
+  
+  def test_find_should_return_nil_when_no_matching_source_file_is_found
+    environment = environment_for_fixtures
+    assert_nil environment.find("nonexistent.js")
+  end
+  
+  protected
+    def assert_load_path_equals(load_path_absolute_locations, environment)
+      assert load_path_absolute_locations.zip(environment.load_path).map { |location, pathname| location == pathname.absolute_location }.all?
+    end
+end

data/test/test_helper.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), *%w".. lib sprockets")
+require "test/unit"
+
+class Test::Unit::TestCase
+  FIXTURES_PATH = File.expand_path(File.join(File.dirname(__FILE__), "fixtures")) unless defined?(FIXTURES_PATH)
+  
+  protected
+    def location_for_fixture(fixture)
+      File.join(FIXTURES_PATH, fixture)
+    end
+    
+    def content_of_fixture(fixture)
+      IO.read(location_for_fixture(fixture))
+    end
+  
+    def environment_for_fixtures
+      Sprockets::Environment.new(FIXTURES_PATH, source_directories_in_fixtures_path)
+    end
+  
+    def source_directories_in_fixtures_path
+      Dir[File.join(FIXTURES_PATH, "**", "src")]
+    end
+
+    def assert_absolute_location(location, pathname)
+      assert_equal location, pathname.absolute_location
+    end
+    
+    def assert_absolute_location_ends_with(location_ending, pathname)
+      assert pathname.absolute_location[/#{Regexp.escape(location_ending)}$/]
+    end
+
+    def pathname(location, environment = @environment)
+      Sprockets::Pathname.new(environment, File.join(FIXTURES_PATH, location))
+    end
+    
+    def source_file(location, environment = @environment)
+      Sprockets::SourceFile.new(environment, pathname(location, environment))
+    end
+
+    def source_line(line, source_file = nil, line_number = 1)
+      Sprockets::SourceLine.new(source_file, line, line_number)
+    end
+end

data/test/test_output_file.rb

@@ -0,0 +1,20 @@
+require "test_helper"
+
+class OutputFileTest < Test::Unit::TestCase
+  def setup
+    @output_file = Sprockets::OutputFile.new
+  end
+  
+  def test_record
+    assert_equal [], @output_file.source_lines
+    assert_equal "hello\n", @output_file.record("hello\n")
+    assert_equal "world\n", @output_file.record("world\n")
+    assert_equal ["hello\n", "world\n"], @output_file.source_lines
+  end
+  
+  def test_to_s
+    @output_file.record(source_line("hello\n"))
+    @output_file.record(source_line("world\n"))
+    assert_equal "hello\nworld\n", @output_file.to_s
+  end
+end

data/test/test_pathname.rb

@@ -0,0 +1,43 @@
+require "test_helper"
+
+class PathnameTest < Test::Unit::TestCase
+  def setup
+    @environment = environment_for_fixtures
+  end
+  
+  def test_absolute_location_is_automatically_expanded
+    expanded_location = File.expand_path(File.join(FIXTURES_PATH, "foo"))
+    assert_absolute_location expanded_location, pathname("foo")
+    assert_absolute_location expanded_location, pathname("./foo")
+    assert_absolute_location expanded_location, pathname("./foo/../foo")
+  end
+  
+  def test_find_should_return_a_pathname_for_the_location_relative_to_the_absolute_location_of_the_pathname
+    assert_absolute_location_ends_with "src/foo/bar.js", pathname("src/foo").find("bar.js")
+  end
+  
+  def test_find_should_return_nil_when_the_location_relative_to_the_absolute_location_of_the_pathname_is_not_a_file_or_does_not_exist
+    assert_nil pathname("src/foo").find("nonexistent.js")
+  end
+  
+  def test_parent_pathname_should_return_a_pathname_for_the_parent_directory
+    assert_absolute_location_ends_with "src", pathname("src/foo").parent_pathname
+    assert_absolute_location_ends_with "foo", pathname("src/foo/foo.js").parent_pathname
+  end
+  
+  def test_source_file_should_return_a_source_file_for_the_pathname
+    source_file = pathname("src/foo.js").source_file
+    assert_kind_of Sprockets::SourceFile, source_file
+    assert_equal pathname("src/foo.js"), source_file.pathname
+  end
+
+  def test_equality_of_pathnames
+    assert_equal pathname("src/foo.js"), pathname("src/foo.js")
+    assert_equal pathname("src/foo.js"), pathname("src/foo/../foo.js")
+    assert_not_equal pathname("src/foo.js"), pathname("src/foo/foo.js")
+  end
+  
+  def test_to_s_should_return_absolute_location
+    assert_equal pathname("src/foo.js").to_s, pathname("src/foo.js").absolute_location
+  end
+end

data/test/test_preprocessor.rb

@@ -0,0 +1,92 @@
+require "test_helper"
+
+class PreprocessorTest < Test::Unit::TestCase
+  def setup
+    @environment  = environment_for_fixtures
+    @preprocessor = Sprockets::Preprocessor.new(@environment)
+  end
+
+  def test_double_slash_comments_that_are_not_requires_should_be_removed_by_default
+    require_file_for_this_test
+    assert_output_file_does_not_contain_line "// This is a double-slash comment that should not appear in the resulting output file."
+    assert_output_file_contains_line "/* This is a slash-star comment that should appear in the resulting output file. */"
+  end
+
+  def test_double_slash_comments_that_are_not_requires_should_be_ignored_when_strip_comments_is_false
+    @preprocessor = Sprockets::Preprocessor.new(@environment, :strip_comments => false)
+    require_file_for_this_test
+    assert_output_file_contains_line "// This is a double-slash comment that should appear in the resulting output file."
+  end
+  
+  def test_requiring_a_single_file_should_replace_the_require_comment_with_the_file_contents
+    require_file_for_this_test
+    assert_output_file_contains <<-LINES
+      var before_require;
+      var Foo = { };
+      var after_require;
+    LINES
+  end
+  
+  def test_requiring_a_file_that_does_not_exist_should_raise_an_error
+    assert_raises(Sprockets::LoadError) do
+      require_file_for_this_test
+    end
+  end
+  
+  def test_requiring_the_current_file_should_do_nothing
+    require_file_for_this_test
+    assert_equal "", output_text
+  end
+  
+  def test_requiring_a_file_after_it_has_already_been_required_should_do_nothing
+    require_file_for_this_test
+    assert_output_file_contains <<-LINES
+      var before_first_require;
+      var Foo = { };
+      var after_first_require_and_before_second_require;
+      var after_second_require;
+    LINES
+  end
+  
+  protected
+    attr_reader :environment, :preprocessor
+    
+    def output_file
+      preprocessor.output_file
+    end
+    
+    def output_text
+      preprocessor.output_file.to_s
+    end
+    
+    def source_lines_matching(line)
+      output_file.source_lines.select { |source_line| source_line.line.strip == line }
+    end
+    
+    def require_file(location)
+      preprocessor.require(environment.find(location).source_file)
+    end
+    
+    def require_file_for_this_test
+      require_file(file_for_this_test)
+    end
+    
+    def file_for_this_test
+      caller.map { |c| c[/`(.*?)'$/, 1] }.grep(/^test_/).first[5..-1] + ".js"
+    end
+    
+    def assert_output_file_does_not_contain_line(line)
+      assert source_lines_matching(line).empty?
+    end
+    
+    def assert_output_file_contains_line(line)
+      assert source_lines_matching(line).any?
+    end
+    
+    def assert_output_file_contains(indented_text)
+      lines = indented_text.split($/)
+      initial_indent  = lines.first[/^\s*/].length
+      unindented_text = lines.map { |line| line[initial_indent..-1] }.join($/)
+      assert output_text[unindented_text]
+    end
+end

data/test/test_source_file.rb

@@ -0,0 +1,29 @@
+require "test_helper"
+require "enumerator"
+
+class SourceFileTest < Test::Unit::TestCase
+  def setup
+    @environment = environment_for_fixtures
+  end
+  
+  def test_each_source_line
+    source_file_lines = Enumerable::Enumerator.new(source_file("src/foo/bar.js"), :each_source_line).to_a
+    assert_equal content_of_fixture("src/foo/bar.js"), source_file_lines.map { |line| line.line }.join
+    assert_equal 4, source_file_lines.length
+  end
+  
+  def test_find_should_return_pathname_for_file_relative_to_the_current_pathname
+    assert_absolute_location_ends_with "test/fixtures/src/foo/bar.js", source_file("src/foo/foo.js").find("bar.js")
+  end
+  
+  def test_find_should_return_nil_for_nonexistent_file
+    assert_nil source_file("src/foo/foo.js").find("nonexistent.js")
+  end
+  
+  def test_equality_of_source_files
+    assert_equal source_file("src/foo/foo.js"), source_file("src/foo/foo.js")
+    assert_equal source_file("src/foo/foo.js"), source_file("src/foo/../foo/foo.js")
+    assert_not_equal source_file("src/foo/foo.js"), source_file("src/foo.js")
+    assert_not_equal source_file("src/foo/foo.js"), source_file("src/foo/bar.js")
+  end
+end

data/test/test_source_line.rb

@@ -0,0 +1,44 @@
+require "test_helper"
+
+class SourceLineTest < Test::Unit::TestCase
+  def test_line_that_begins_with_double_slash_should_be_a_comment
+    assert source_line("//").comment?
+    assert source_line("//test").comment?
+    assert source_line("//= require").comment?
+    assert source_line("//= require <foo>").comment?
+    assert source_line(" //").comment?
+    assert source_line("\t//").comment?
+  end
+  
+  def test_line_that_contains_but_does_not_begin_with_double_slash_should_not_be_a_comment
+    assert !source_line("f //").comment?
+    assert !source_line("f //= require <foo>").comment?
+  end
+
+  def test_comment_should_be_extracted_from_comment_lines
+    assert_equal "test", source_line("//test").comment
+    assert_equal " test", source_line("// test").comment
+    assert_equal nil, source_line("f //test").comment
+  end
+  
+  def test_line_that_contains_require_comment_should_be_a_require
+    assert source_line("//= require <foo>").require?
+    assert !source_line("//= require<foo>").require?
+    assert source_line("//= require \"foo\"").require?
+    assert !source_line("//= require <foo> f").require?
+  end
+  
+  def test_require_should_be_extracted_from_require_lines
+    assert_nil source_line("//= require").require
+    assert_equal "<foo>", source_line("//= require <foo>").require
+    assert_equal "<foo>", source_line("//= require   <foo> ").require
+    assert_equal "\"foo\"", source_line("//= require \"foo\"").require
+  end
+
+  def test_inspect_should_include_source_file_location_and_line_number
+    environment = environment_for_fixtures
+    pathname    = Sprockets::Pathname.new(environment, "/a/b/c.js")
+    source_file = Sprockets::SourceFile.new(environment, pathname)
+    assert_equal "line 25 of /a/b/c.js", source_line("hello", source_file, 25).inspect
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: sstephenson-sprockets
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Sam Stephenson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-01 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Sprockets is a Ruby library that preprocesses and concatenates JavaScript source files.
+email: sstephenson@gmail.com
+executables: 
+- sprocketize
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- bin/sprocketize
+- lib/sprockets.rb
+- lib/sprockets
+- lib/sprockets/preprocessor.rb
+- lib/sprockets/source_file.rb
+- lib/sprockets/error.rb
+- lib/sprockets/output_file.rb
+- lib/sprockets/environment.rb
+- lib/sprockets/version.rb
+- lib/sprockets/source_line.rb
+- lib/sprockets/pathname.rb
+- test/test_preprocessor.rb
+- test/test_source_line.rb
+- test/test_source_file.rb
+- test/test_output_file.rb
+- test/fixtures
+- test/fixtures/src
+- test/fixtures/src/foo
+- test/fixtures/src/foo/bar.js
+- test/fixtures/src/foo/foo.js
+- test/fixtures/src/foo.js
+- test/fixtures/requiring_a_single_file_should_replace_the_require_comment_with_the_file_contents.js
+- test/fixtures/double_slash_comments_that_are_not_requires_should_be_removed_by_default.js
+- test/fixtures/requiring_a_file_that_does_not_exist_should_raise_an_error.js
+- test/fixtures/requiring_a_file_after_it_has_already_been_required_should_do_nothing.js
+- test/fixtures/double_slash_comments_that_are_not_requires_should_be_ignored_when_strip_comments_is_false.js
+- test/fixtures/requiring_the_current_file_should_do_nothing.js
+- test/test_pathname.rb
+- test/test_helper.rb
+- test/test_environment.rb
+has_rdoc: false
+homepage: http://github.com/sstephenson/sprockets
+post_install_message: 
+rdoc_options: []
+
+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.0.1
+signing_key: 
+specification_version: 2
+summary: JavaScript dependency management and concatenation
+test_files: 
+- test/test_preprocessor.rb
+- test/test_source_line.rb
+- test/test_source_file.rb
+- test/test_output_file.rb
+- test/test_pathname.rb
+- test/test_helper.rb
+- test/test_environment.rb