sprockets-foo 0.0.1 → 0.0.2

data/Rakefile

@@ -12,6 +12,7 @@ begin
     gem.authors = ["Ben Curren"]
     gem.add_dependency "ejs-rcompiler", ">= 0.1.1"
     # gem.add_dependency "sprockets", ">= " # use when sprockets directive branch is merged
+    Dir.glob('ext/**/*.rb').each { |f| gem.files << f }
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/ext/sprockets_with_directives/lib/sprockets.rb

@@ -0,0 +1,46 @@
+$:.unshift File.dirname(__FILE__)
+
+require "yaml"
+require "fileutils"
+
+module Sprockets
+  class << self
+    def running_on_windows?
+      RUBY_PLATFORM =~ /(win|w)32$/
+    end
+  
+    def absolute?(location)
+      same_when_expanded?(location) || platform_absolute_path?(location)
+    end
+
+    protected
+      def same_when_expanded?(location)
+        location[0, 1] == File.expand_path(location)[0, 1]
+      end
+
+      def platform_absolute_path?(location)
+        false
+      end
+
+      if Sprockets.running_on_windows?
+        def platform_absolute_path?(location)
+          location[0, 1] == File::SEPARATOR && File.expand_path(location) =~ /[A-Za-z]:[\/\\]/
+        end
+      end
+  end
+end
+
+require "sprockets/concatenation"
+require "sprockets/directive"
+require "sprockets/directives"
+require "sprockets/directives/provide_directive"
+require "sprockets/directives/require_directive"
+require "sprockets/directives/relative_require_directive"
+require "sprockets/error"
+require "sprockets/environment"
+require "sprockets/pathname"
+require "sprockets/preprocessor"
+require "sprockets/source_file"
+require "sprockets/secretary"
+require "sprockets/version"
+

data/ext/sprockets_with_directives/lib/sprockets/concatenation.rb

@@ -0,0 +1,38 @@
+module Sprockets
+  class Concatenation
+    attr_reader :lines
+    
+    def initialize
+      @lines = []
+      @source_files_and_numbers = []
+      @source_file_mtimes = {}
+    end
+    
+    def record(source_file, line, number)
+      @lines << line
+      @source_files_and_numbers << [source_file, number]
+      record_mtime_for(source_file)
+      line
+    end
+    
+    def to_s
+      lines.join
+    end
+
+    def mtime
+      @source_file_mtimes.values.max
+    end
+    
+    def save_to(filename)
+      timestamp = mtime
+      File.open(filename, "w") { |file| file.write(to_s) }
+      File.utime(timestamp, timestamp, filename)
+      true
+    end
+
+    protected
+      def record_mtime_for(source_file)
+        @source_file_mtimes[source_file] ||= source_file.mtime
+      end
+  end
+end

data/ext/sprockets_with_directives/lib/sprockets/directive.rb

@@ -0,0 +1,56 @@
+module Sprockets
+  class Directive
+    attr_reader :source_file, :line, :number, :name, :argument
+
+    QUOTED_STRING = /(?:"([^"]+|\\"+)*")/
+    ANGLED_STRING = /(?:<([^>]+|\\>+)*>)/
+
+    class << self
+      def for(source_file, line, number)
+        if directive_klass = Directives.find(line)
+          directive_klass.new(source_file, line, number)
+        end
+      end
+
+      def parse(line)
+        if matches = full_pattern.match(line)
+          matches.captures
+        end
+      end
+      
+      protected
+        def full_pattern
+          @full_pattern ||= /\s*\/\/=\s+#{pattern}\s*$/
+        end
+        
+        def pattern
+          /^$/
+        end
+    end
+    
+    def initialize(source_file, line, number)
+      @source_file     = source_file
+      @line, @number   = line, number
+      @name, @argument = self.class.parse(line)
+    end
+    
+    protected
+      def environment
+        source_file.environment
+      end
+    
+      def parse_quoted_string(string)
+        QUOTED_STRING.match(string)[1].gsub(/\\"/, "\"")
+      end
+      
+      def parse_angled_string(string)
+        ANGLED_STRING.match(string)[1].gsub(/\\>/, "\>")
+      end
+      
+      def raise_load_error
+        raise LoadError, 
+          "can't find file for #{name} `#{require_location}' " +
+          "(line #{number} of #{source_file.pathname})"
+      end
+  end
+end

data/ext/sprockets_with_directives/lib/sprockets/directives.rb

@@ -0,0 +1,15 @@
+module Sprockets
+  module Directives
+    def self.find(line)
+      directives.find do |directive_klass|
+        directive_klass.parse(line)
+      end
+    end
+
+    def self.directives
+      constants.grep(/Directive$/).map do |directive_name|
+        const_get(directive_name)
+      end
+    end
+  end
+end

data/ext/sprockets_with_directives/lib/sprockets/directives/provide_directive.rb

@@ -0,0 +1,25 @@
+module Sprockets
+  module Directives
+    class ProvideDirective < Directive
+      def self.pattern
+        /(provide)\s+(#{QUOTED_STRING})/
+      end
+      
+      def evaluate_in(preprocessor)
+        if asset_path
+          preprocessor.provide(asset_path)
+        else
+          raise_load_error
+        end
+      end
+
+      def asset_path
+        source_file.find(provide_location, :directory)
+      end
+      
+      def provide_location
+        parse_quoted_string(argument)
+      end
+    end
+  end
+end

data/ext/sprockets_with_directives/lib/sprockets/directives/relative_require_directive.rb

@@ -0,0 +1,18 @@
+module Sprockets
+  module Directives
+    class RelativeRequireDirective < RequireDirective
+      def self.pattern
+        /(require)\s+(#{QUOTED_STRING})/
+      end
+      
+      def require_location
+        parse_quoted_string(argument)
+      end
+
+      protected
+        def location_finder
+          source_file
+        end
+    end
+  end
+end

data/ext/sprockets_with_directives/lib/sprockets/directives/require_directive.rb

@@ -0,0 +1,34 @@
+module Sprockets
+  module Directives
+    class RequireDirective < Directive
+      def self.pattern
+        /(require)\s+(#{ANGLED_STRING})/
+      end
+      
+      def evaluate_in(preprocessor)
+        if source_file_path
+          preprocessor.require(source_file_path.source_file)
+        else
+          raise_load_error
+        end
+      end
+      
+      def source_file_path
+        @source_file_path ||= location_finder.find(normalize(require_location))
+      end
+      
+      def require_location
+        parse_angled_string(argument)
+      end
+
+      protected
+        def location_finder
+          environment
+        end
+        
+        def normalize(location)
+          File.join(File.dirname(location), File.basename(location, ".js") + ".js")
+        end
+    end
+  end
+end

data/ext/sprockets_with_directives/lib/sprockets/environment.rb

@@ -0,0 +1,52 @@
+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)
+      if Sprockets.absolute?(location) && File.exists?(location)
+        pathname_from(location)
+      else
+        find_all(location).first
+      end
+    end
+    
+    def constants(reload = false)
+      @constants = nil if reload
+      @constants ||= find_all("constants.yml").inject({}) do |constants, pathname|
+        contents = YAML.load(pathname.contents) rescue nil
+        contents = {} unless contents.is_a?(Hash)
+        constants.merge(contents)
+      end
+    end
+    
+    protected
+      def absolute_location_from(location)
+        location = location.to_s
+        location = File.join(root.absolute_location, location) unless Sprockets.absolute?(location)
+        File.expand_path(location)
+      end
+      
+      def find_all(location)
+        load_path.map { |pathname| pathname.find(location) }.compact
+      end
+  end
+end

data/ext/sprockets_with_directives/lib/sprockets/error.rb

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

data/ext/sprockets_with_directives/lib/sprockets/pathname.rb

@@ -0,0 +1,37 @@
+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, kind = :file)
+      location = File.join(absolute_location, location)
+      File.send("#{kind}?", 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 contents
+      IO.read(absolute_location)
+    end
+    
+    def ==(pathname)
+      environment == pathname.environment &&
+        absolute_location == pathname.absolute_location
+    end
+    
+    def to_s
+      absolute_location
+    end
+  end
+end

data/ext/sprockets_with_directives/lib/sprockets/preprocessor.rb

@@ -0,0 +1,138 @@
+module Sprockets
+  class Preprocessor
+    attr_reader :environment, :concatenation, :source_files, :pdoc_lines, :asset_paths
+    
+    def initialize(environment, options = {})
+      @environment   = environment
+      @concatenation = Concatenation.new
+      @source_files  = []
+      @comment_lines = []
+      @pdoc_lines    = []
+      @asset_paths   = []
+      @options       = options
+    end
+    
+    def require(source_file)
+      return if source_files.include?(source_file)
+      source_files << source_file
+      
+      source_file.each_line do |line, number|
+        process(source_file, line, number)
+      end
+    end
+    
+    def provide(asset_path)
+      return if !asset_path || asset_paths.include?(asset_path)
+      asset_paths << asset_path
+    end
+    
+    protected
+      attr_reader :options, :comment_lines
+
+      def process(source_file, line, number)
+        if inside_multi_line_comment?
+          comment_lines.push([source_file, line, number])
+
+          if line_closes_multi_line_pdoc_comment?(line)
+            record_comment_lines_as(:pdoc)
+          elsif line_closes_multi_line_comment?(line)
+            record_comment_lines_as(:source)
+          end
+
+        elsif line_opens_multi_line_pdoc_comment?(line)
+          comment_lines.push([source_file, line, number])
+
+        elsif line_is_single_line_comment?(line)
+          if directive = Directive.for(source_file, line, number)
+            directive.evaluate_in(self)
+          else
+            record_single_comment_line(source_file, line, number)
+          end
+
+        else
+          record_source_line(source_file, line, number)
+        end
+        
+      rescue UndefinedConstantError => constant
+        raise UndefinedConstantError, 
+          "couldn't find constant `#{constant}' in line #{number} of #{source_file.pathname}"
+      end
+
+    private
+      def record_source_line(source_file, line, number)
+        concatenation.record(source_file, format(line), number)
+      end
+      
+      def record_pdoc_line(source_file, line, number)
+        pdoc_lines.push([source_file, line, number])
+        record_source_line(source_file, line, number) unless stripping_comments?
+      end
+
+      def record_single_comment_line(source_file, line, number)
+        record_source_line(source_file, line, number) unless stripping_comments?
+      end
+
+      def record_comment_lines_as(kind)
+        comment_lines.each do |comment_line|
+          send(:"record_#{kind}_line", *comment_line)
+        end
+        comment_lines.clear
+      end
+      
+      def format(line)
+        result = line.chomp
+        interpolate_constants!(result, environment.constants)
+        strip_trailing_whitespace!(result)
+        result << $/
+      end
+      
+      def interpolate_constants!(result, constants)
+        result.gsub!(/<%=(.*?)%>/) do
+          constant = $1.strip
+          if value = constants[constant]
+            value
+          else
+            raise UndefinedConstantError, constant
+          end
+        end
+      end
+      
+      def strip_trailing_whitespace!(result)
+        result.gsub!(/\s+$/, "")
+      end
+
+      def inside_multi_line_comment?
+        comment_lines.any?
+      end
+      
+      def line_opens_multi_line_pdoc_comment?(line)
+        if rest = line[/^\s*\/\*\*(.*)/, 1]
+          !line_closes_multi_line_comment?(rest)
+        end
+      end
+      
+      def line_closes_multi_line_pdoc_comment?(line)
+        line =~ /\*\*\/\s*$/
+      end
+      
+      def line_opens_multi_line_comment?(line)
+        if rest = line[/^\s*\/\*(.*)/, 1]
+          !line_closes_multi_line_comment?(rest)
+        end
+      end
+      
+      def line_closes_multi_line_comment?(line)
+        if rest = line[/\*\/(.*)/, 1]
+          !line_opens_multi_line_comment?(rest)
+        end
+      end
+      
+      def line_is_single_line_comment?(line)
+        line =~ /^\s*\/\//
+      end
+      
+      def stripping_comments?
+       options[:strip_comments] != false
+      end
+  end
+end

data/ext/sprockets_with_directives/lib/sprockets/secretary.rb

@@ -0,0 +1,107 @@
+module Sprockets
+  class Secretary
+    DEFAULT_OPTIONS = {
+      :root           => ".",
+      :load_path      => [],
+      :source_files   => [],
+      :expand_paths   => true,
+      :strip_comments => true
+    }
+
+    attr_reader :environment, :preprocessor
+    
+    def initialize(options = {})
+      reset!(options)
+    end
+
+    def reset!(options = @options)
+      @options = DEFAULT_OPTIONS.merge(options)
+      @environment  = Sprockets::Environment.new(@options[:root])
+      @preprocessor = Sprockets::Preprocessor.new(@environment, :strip_comments => @options[:strip_comments])
+
+      add_load_locations(@options[:load_path])
+      add_source_files(@options[:source_files])
+    end
+
+    def add_load_location(load_location, options = {})
+      add_load_locations([load_location], options)
+    end
+
+    def add_load_locations(load_locations, options = {})
+      expand_paths(load_locations, options).each do |load_location|
+        environment.register_load_location(load_location)
+      end
+    end
+    
+    def add_source_file(source_file, options = {})
+      add_source_files([source_file], options)
+    end
+    
+    def add_source_files(source_files, options = {})
+      expand_paths(source_files, options).each do |source_file|
+        if pathname = environment.find(source_file)
+          preprocessor.require(pathname.source_file)
+        else
+          raise Sprockets::LoadError, "no such file `#{source_file}'"
+        end
+      end
+    end
+    
+    def concatenation
+      preprocessor.concatenation
+    end
+    
+    def install_assets
+      if @options[:asset_root]
+        preprocessor.asset_paths.each do |asset_path|
+          copy_assets_from(asset_path.absolute_location)
+        end
+      end
+    end
+    
+    def source_last_modified
+      preprocessor.source_files.map { |s| s.mtime }.max
+    end
+    
+    protected
+      def expand_paths(paths, options = {})
+        if options.has_key?(:expand_paths) ? options[:expand_paths] : @options[:expand_paths]
+          paths.map { |path| Dir[from_root(path)].sort }.flatten.compact
+        else
+          paths.map { |path| from_root(path) }
+        end
+      end
+      
+      def from_root(path)
+        if Sprockets.absolute?(path)
+          path
+        else
+          File.join(@options[:root], path)
+        end
+      end
+      
+      def copy_assets_from(asset_path)
+        relative_file_paths_beneath(asset_path).each do |filename|
+          source, destination = File.join(asset_path, filename), File.join(asset_root, File.dirname(filename))
+          if !File.directory?(source)
+            FileUtils.mkdir_p(destination)
+            FileUtils.cp(source, destination)
+          end
+        end
+      end
+      
+      def relative_file_paths_beneath(path)
+        Dir[File.join(path, "**", "*")].map do |filename|
+          File.join(*path_pieces(filename)[path_pieces(path).length..-1])
+        end
+      end
+      
+      def asset_root
+        from_root(@options[:asset_root])
+      end
+      
+      def path_pieces(path)
+        path.split(File::SEPARATOR)
+      end
+  end
+end

data/ext/sprockets_with_directives/lib/sprockets/source_file.rb

@@ -0,0 +1,32 @@
+module Sprockets
+  class SourceFile
+    attr_reader :environment, :pathname
+
+    def initialize(environment, pathname)
+      @environment = environment
+      @pathname = pathname
+    end
+
+    def find(location, kind = :file)
+      pathname.parent_pathname.find(location, kind)
+    end
+    
+    def ==(source_file)
+      pathname == source_file.pathname
+    end
+    
+    def mtime
+      File.mtime(pathname.absolute_location)
+    rescue Errno::ENOENT
+      Time.now
+    end
+    
+    def each_line
+      File.open(pathname.absolute_location) do |file|
+        file.each_line do |line|
+          yield line, file.lineno
+        end
+      end
+    end
+  end
+end

data/ext/sprockets_with_directives/lib/sprockets/version.rb

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

data/ext/sprockets_with_directives/test/test_concatenation.rb

@@ -0,0 +1,28 @@
+require "test_helper"
+
+class ConcatenationTest < Test::Unit::TestCase
+  def setup
+    @concatenation = Sprockets::Concatenation.new
+    @environment = environment_for_fixtures
+  end
+  
+  def test_record
+    assert_equal [], @concatenation.lines
+    assert_equal "hello\n", @concatenation.record(source_file, "hello\n", 1).to_s
+    assert_equal "world\n", @concatenation.record(source_file, "world\n", 2).to_s
+    assert_equal ["hello\n", "world\n"], @concatenation.lines
+  end
+  
+  def test_to_s
+    @concatenation.record(source_file, "hello\n", 1)
+    @concatenation.record(source_file, "world\n", 2)
+    assert_equal "hello\nworld\n", @concatenation.to_s
+  end
+  
+  def test_save_to
+    filename = File.join(FIXTURES_PATH, "output.js")
+    @concatenation.save_to(filename)
+    assert_equal @concatenation.to_s, IO.read(filename)
+    File.unlink(filename)
+  end
+end

data/ext/sprockets_with_directives/test/test_environment.rb

@@ -0,0 +1,64 @@
+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
+  
+  def test_constants_should_return_a_hash_of_all_constants_defined_in_the_load_path
+    constants = environment_for_fixtures.constants
+    assert_kind_of Hash, constants
+    assert_equal %w(HELLO ONE TWO VERSION), constants.keys.sort
+  end
+  
+  protected
+    def assert_load_path_equals(load_path_absolute_locations, environment)
+      assert load_path_absolute_locations.zip(environment.load_path).map { |location, pathname| File.expand_path(location) == pathname.absolute_location }.all?
+    end
+end

data/ext/sprockets_with_directives/test/test_helper.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__), *%w".. lib sprockets")
+require "test/unit"
+require "fileutils"
+require "tmpdir"
+
+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 File.expand_path(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 = "dummy", environment = @environment)
+      Sprockets::SourceFile.new(environment, pathname(location, environment))
+    end
+
+    def with_temporary_directory
+      path = File.join(Dir.tmpdir, [caller[0][/`(.*)'/, 1], Time.now.to_f].join("_"))
+      begin
+        FileUtils.mkdir(path)
+        yield path
+      ensure
+        FileUtils.rm_rf(path)
+      end
+    end
+end

data/ext/sprockets_with_directives/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/ext/sprockets_with_directives/test/test_preprocessor.rb

@@ -0,0 +1,107 @@
+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_concatenation_does_not_contain_line "// This is a double-slash comment that should not appear in the resulting output file."
+    assert_concatenation_contains_line "/* This is a slash-star comment that should not 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_concatenation_contains_line "// This is a double-slash comment that should appear in the resulting output file."
+    assert_concatenation_contains_line "/* This is a slash-star comment that should appear in the resulting output file. */"
+
+    assert_concatenation_contains_line "/* This is multiline slash-star comment"
+    assert_concatenation_contains_line "*  that should appear in the resulting"
+    assert_concatenation_contains_line "*  output file */"
+
+    assert_concatenation_contains_line "This is not a PDoc comment that should appear in the resulting output file."
+  end
+
+  def test_multiline_comments_should_be_removed_by_default
+    require_file_for_this_test
+    assert_concatenation_does_not_contain_line "/**"
+    assert_concatenation_does_not_contain_line " *  This is a PDoc comment"
+    assert_concatenation_does_not_contain_line " *  that should appear in the resulting output file."
+    assert_concatenation_does_not_contain_line "**/"
+  end
+
+  def test_requiring_a_single_file_should_replace_the_require_comment_with_the_file_contents
+    require_file_for_this_test
+    assert_concatenation_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_concatenation_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 concatenation
+      preprocessor.concatenation
+    end
+    
+    def output_text
+      preprocessor.concatenation.to_s
+    end
+    
+    def source_lines_matching(line)
+      concatenation.lines.select { |l| l.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_concatenation_does_not_contain_line(line)
+      assert source_lines_matching(line).empty?, "Expected #{line.inspect} not to exist"
+    end
+    
+    def assert_concatenation_contains_line(line)
+      assert source_lines_matching(line).any?, "Expected #{line.inspect} to exist"
+    end
+    
+    def assert_concatenation_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/ext/sprockets_with_directives/test/test_secretary.rb

@@ -0,0 +1,89 @@
+require "test_helper"
+
+class SecretaryTest < Test::Unit::TestCase
+  def test_load_locations_are_not_expanded_when_expand_paths_is_false
+    secretary = Sprockets::Secretary.new(:root => FIXTURES_PATH)
+    secretary.add_load_location("src/**/", :expand_paths => false)
+    
+    assert_equal [File.join(FIXTURES_PATH, "src/**"), FIXTURES_PATH], 
+                 secretary.environment.load_path.map { |pathname| pathname.absolute_location }
+  end
+  
+  def test_load_locations_are_expanded_when_expand_paths_is_true
+    secretary = Sprockets::Secretary.new(:root => FIXTURES_PATH)
+    secretary.add_load_location("src/**/", :expand_paths => true)
+    
+    assert_equal [File.join(FIXTURES_PATH, "src", "foo"), File.join(FIXTURES_PATH, "src"), FIXTURES_PATH],
+                 secretary.environment.load_path.map { |pathname| pathname.absolute_location }
+  end
+  
+  def test_source_files_are_not_expanded_when_expand_paths_is_false
+    secretary = Sprockets::Secretary.new(:root => FIXTURES_PATH)
+    assert_raises(Sprockets::LoadError) do
+      secretary.add_source_file("src/f*.js", :expand_paths => false)
+    end
+  end
+  
+  def test_source_files_are_expanded_when_expand_paths_is_true
+    secretary = Sprockets::Secretary.new(:root => FIXTURES_PATH)
+    secretary.add_source_file("src/f*.js", :expand_paths => true)
+    
+    assert_equal [File.join(FIXTURES_PATH, "src", "foo.js")],
+                 secretary.preprocessor.source_files.map { |source_file| source_file.pathname.absolute_location }
+  end
+  
+  def test_install_assets_into_empty_directory
+    with_temporary_directory do |temp|
+      secretary = Sprockets::Secretary.new(:root => FIXTURES_PATH, :asset_root => temp)
+      secretary.add_source_file("src/script_with_assets.js")
+
+      assert_equal [], Dir[File.join(temp, "**", "*")]
+      secretary.install_assets
+      assert_equal paths_relative_to(temp, 
+        "images", "images/script_with_assets", "images/script_with_assets/one.png", 
+        "images/script_with_assets/two.png", "stylesheets", "stylesheets/script_with_assets.css"),
+        Dir[File.join(temp, "**", "*")].sort
+    end
+  end
+  
+  def test_install_assets_into_nonexistent_directory
+    with_temporary_directory do |temp|
+      temp = File.join(temp, "assets")
+      secretary = Sprockets::Secretary.new(:root => FIXTURES_PATH, :asset_root => temp)
+      secretary.add_source_file("src/script_with_assets.js")
+
+      assert_equal [], Dir[File.join(temp, "**", "*")]
+      secretary.install_assets
+      assert_equal paths_relative_to(temp, 
+        "images", "images/script_with_assets", "images/script_with_assets/one.png", 
+        "images/script_with_assets/two.png", "stylesheets", "stylesheets/script_with_assets.css"),
+        Dir[File.join(temp, "**", "*")].sort
+    end
+  end
+  
+  def test_install_assets_into_subdirectories_that_already_exist
+    with_temporary_directory do |temp|
+      secretary = Sprockets::Secretary.new(:root => FIXTURES_PATH, :asset_root => temp)
+      secretary.add_source_file("src/script_with_assets.js")
+
+      FileUtils.mkdir_p(File.join(temp, "images", "script_with_assets"))
+      assert_equal paths_relative_to(temp, "images", "images/script_with_assets"), Dir[File.join(temp, "**", "*")]
+      secretary.install_assets
+      assert_equal paths_relative_to(temp, 
+        "images", "images/script_with_assets", "images/script_with_assets/one.png", 
+        "images/script_with_assets/two.png", "stylesheets", "stylesheets/script_with_assets.css"),
+        Dir[File.join(temp, "**", "*")].sort
+    end
+  end
+  
+  def test_secretary_passes_strip_comments_option_through_to_preprocessor
+    secretary = Sprockets::Secretary.new(:root => FIXTURES_PATH, :strip_comments => false)
+    secretary.add_source_file("src/script_with_comments.js")
+    assert_equal content_of_fixture("src/script_with_comments.js"), secretary.concatenation.to_s
+  end
+  
+  protected
+    def paths_relative_to(root, *paths)
+      paths.map { |path| File.join(root, path) }
+    end
+end

data/ext/sprockets_with_directives/test/test_source_file.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+class SourceFileTest < Test::Unit::TestCase
+  def setup
+    @environment = environment_for_fixtures
+  end
+  
+  def test_each_line
+    source_file_lines = []
+    source_file("src/foo/bar.js").each_line {|line, number| source_file_lines << line }
+    assert_equal content_of_fixture("src/foo/bar.js"), source_file_lines.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
+  
+  def test_mtime_should_return_now_if_file_does_not_exist
+    assert source_file("src/foo/nonexistent.js").mtime.instance_of?(Time)
+  end
+end

data/ext/sprockets_with_directives/test/test_source_line.rb

@@ -0,0 +1,89 @@
+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_begins_a_multiline_comment
+    assert source_line(" /*").begins_multiline_comment?
+    assert source_line(" /**").begins_multiline_comment?
+  end
+
+  def test_line_that_begins_a_pdoc_comment
+    assert !source_line(" /*").begins_pdoc_comment?
+    assert source_line(" /**").begins_pdoc_comment?
+  end
+
+  def test_line_that_ends_a_multiline_comment
+    assert source_line(" */").ends_multiline_comment?
+    assert source_line(" **/").ends_multiline_comment?
+  end
+
+  def test_line_that_ends_a_pdoc_comment
+    assert !source_line(" */").ends_pdoc_comment?
+    assert source_line(" **/").ends_pdoc_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_line_that_contains_a_provide_comment_should_be_a_provide
+    assert source_line("//= provide \"../assets\"").provide?
+    assert !source_line("//= provide").provide?
+    assert !source_line("//= provide <../assets>").provide?
+  end
+  
+  def test_provide_should_be_extracted_from_provide_lines
+    assert_nil source_line("//= provide").provide
+    assert_equal "../assets", source_line("//= provide \"../assets\"").provide
+  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 #{File.expand_path("/a/b/c.js")}", source_line("hello", source_file, 25).inspect
+  end
+  
+  def test_interpolation_of_constants
+    assert_equal %(var VERSION = "1.0";\n), source_line('var VERSION = "<%= VERSION %>";').to_s("VERSION" => "1.0")
+  end
+  
+  def test_interpolation_of_missing_constant_raises_undefined_constant_error
+    assert_raises(Sprockets::UndefinedConstantError) do
+      source_line('<%= NONEXISTENT %>').to_s("VERSION" => "1.0")
+    end
+  end
+  
+  def test_to_s_should_strip_trailing_whitespace_before_adding_line_ending
+    assert_equal "hello();\n", source_line("hello();     \t  \r\n").to_s({})
+  end
+end

data/sprockets-foo.gemspec

@@ -0,0 +1,84 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sprockets-foo}
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ben Curren"]
+  s.date = %q{2010-09-27}
+  s.description = %q{Enhancements for sprockets including templating support with ejs.}
+  s.email = %q{ben@outright.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     ".gitmodules",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "ext/sprockets_with_directives/lib/sprockets.rb",
+     "ext/sprockets_with_directives/lib/sprockets/concatenation.rb",
+     "ext/sprockets_with_directives/lib/sprockets/directive.rb",
+     "ext/sprockets_with_directives/lib/sprockets/directives.rb",
+     "ext/sprockets_with_directives/lib/sprockets/directives/provide_directive.rb",
+     "ext/sprockets_with_directives/lib/sprockets/directives/relative_require_directive.rb",
+     "ext/sprockets_with_directives/lib/sprockets/directives/require_directive.rb",
+     "ext/sprockets_with_directives/lib/sprockets/environment.rb",
+     "ext/sprockets_with_directives/lib/sprockets/error.rb",
+     "ext/sprockets_with_directives/lib/sprockets/pathname.rb",
+     "ext/sprockets_with_directives/lib/sprockets/preprocessor.rb",
+     "ext/sprockets_with_directives/lib/sprockets/secretary.rb",
+     "ext/sprockets_with_directives/lib/sprockets/source_file.rb",
+     "ext/sprockets_with_directives/lib/sprockets/version.rb",
+     "ext/sprockets_with_directives/test/test_concatenation.rb",
+     "ext/sprockets_with_directives/test/test_environment.rb",
+     "ext/sprockets_with_directives/test/test_helper.rb",
+     "ext/sprockets_with_directives/test/test_pathname.rb",
+     "ext/sprockets_with_directives/test/test_preprocessor.rb",
+     "ext/sprockets_with_directives/test/test_secretary.rb",
+     "ext/sprockets_with_directives/test/test_source_file.rb",
+     "ext/sprockets_with_directives/test/test_source_line.rb",
+     "lib/sprockets-foo.rb",
+     "lib/sprockets/directives/template_directive.rb",
+     "sprockets-foo.gemspec",
+     "test/fixtures/requiring_a_template_should_compile_then_require.js",
+     "test/fixtures/requiring_a_template_with_namespace_should_compile_then_require.js",
+     "test/fixtures/src/MyTemplate.ejs",
+     "test/fixtures/src/MyTemplate.js",
+     "test/fixtures/src/or/ui/MyNamespacedTemplate.ejs",
+     "test/fixtures/src/or/ui/MyNamespacedTemplate.js",
+     "test/test_helper.rb",
+     "test/test_template_directive.rb"
+  ]
+  s.homepage = %q{http://github.com/bcurren/sprockets-foo}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Enhancements for sprockets including templating support with ejs.}
+  s.test_files = [
+    "test/test_helper.rb",
+     "test/test_template_directive.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<ejs-rcompiler>, [">= 0.1.1"])
+    else
+      s.add_dependency(%q<ejs-rcompiler>, [">= 0.1.1"])
+    end
+  else
+    s.add_dependency(%q<ejs-rcompiler>, [">= 0.1.1"])
+  end
+end
+

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Ben Curren
@@ -48,8 +48,31 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- ext/sprockets_with_directives/lib/sprockets.rb
+- ext/sprockets_with_directives/lib/sprockets/concatenation.rb
+- ext/sprockets_with_directives/lib/sprockets/directive.rb
+- ext/sprockets_with_directives/lib/sprockets/directives.rb
+- ext/sprockets_with_directives/lib/sprockets/directives/provide_directive.rb
+- ext/sprockets_with_directives/lib/sprockets/directives/relative_require_directive.rb
+- ext/sprockets_with_directives/lib/sprockets/directives/require_directive.rb
+- ext/sprockets_with_directives/lib/sprockets/environment.rb
+- ext/sprockets_with_directives/lib/sprockets/error.rb
+- ext/sprockets_with_directives/lib/sprockets/pathname.rb
+- ext/sprockets_with_directives/lib/sprockets/preprocessor.rb
+- ext/sprockets_with_directives/lib/sprockets/secretary.rb
+- ext/sprockets_with_directives/lib/sprockets/source_file.rb
+- ext/sprockets_with_directives/lib/sprockets/version.rb
+- ext/sprockets_with_directives/test/test_concatenation.rb
+- ext/sprockets_with_directives/test/test_environment.rb
+- ext/sprockets_with_directives/test/test_helper.rb
+- ext/sprockets_with_directives/test/test_pathname.rb
+- ext/sprockets_with_directives/test/test_preprocessor.rb
+- ext/sprockets_with_directives/test/test_secretary.rb
+- ext/sprockets_with_directives/test/test_source_file.rb
+- ext/sprockets_with_directives/test/test_source_line.rb
 - lib/sprockets-foo.rb
 - lib/sprockets/directives/template_directive.rb
+- sprockets-foo.gemspec
 - test/fixtures/requiring_a_template_should_compile_then_require.js
 - test/fixtures/requiring_a_template_with_namespace_should_compile_then_require.js
 - test/fixtures/src/MyTemplate.ejs
@@ -57,7 +80,7 @@ files:
 - test/fixtures/src/or/ui/MyNamespacedTemplate.ejs
 - test/fixtures/src/or/ui/MyNamespacedTemplate.js
 - test/test_helper.rb
-- test/test_preprocessor.rb
+- test/test_template_directive.rb
 has_rdoc: true
 homepage: http://github.com/bcurren/sprockets-foo
 licenses: []
@@ -90,4 +113,4 @@ specification_version: 3
 summary: Enhancements for sprockets including templating support with ejs.
 test_files: 
 - test/test_helper.rb
-- test/test_preprocessor.rb
+- test/test_template_directive.rb