architecture-js 0.1.13 → 0.1.14

data/lib/sprockets/lib/sprockets/preprocessor.rb

@@ -0,0 +1,96 @@
+module Sprockets
+  class Preprocessor
+    attr_reader :environment, :concatenation, :source_files, :asset_paths
+    
+    def initialize(environment, options = {})
+      @environment = environment
+      @concatenation = Concatenation.new
+      @source_files = []
+      @asset_paths = []
+      @options = options
+    end
+    
+    def require(source_file)
+      return if source_files.include?(source_file)
+      source_files << source_file
+      source_file.interpolate_constants = interpolate_constants?
+      
+      source_file.each_source_line do |source_line|
+        if source_line.require?
+          require_from_source_line(source_line)
+        elsif source_line.provide?
+          provide_from_source_line(source_line)
+        else
+          record_source_line(source_line)
+        end
+      end
+    end
+    
+    def provide(asset_path)
+      return if !asset_path || asset_paths.include?(asset_path)
+      asset_paths << asset_path
+    end
+    
+    protected
+      attr_reader :options
+    
+      def require_from_source_line(source_line)
+        require pathname_from(source_line).source_file
+      end
+      
+      def provide_from_source_line(source_line)
+        provide asset_path_from(source_line)
+      end
+      
+      def record_source_line(source_line)
+        unless source_line.comment? && strip_comments?
+          concatenation.record(source_line)
+        end
+      end
+
+      def strip_comments?
+        options[:strip_comments] != false
+      end
+      
+      def interpolate_constants?
+        options[:interpolate_constants] != 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 asset_path_from(source_line)
+        source_line.source_file.find(source_line.provide, :directory)
+      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/lib/sprockets/secretary.rb

@@ -0,0 +1,110 @@
+module Sprockets
+  class Secretary
+    DEFAULT_OPTIONS = {
+      :root           => ".",
+      :load_path      => [],
+      :source_files   => [],
+      :expand_paths   => true,
+      :strip_comments => true,
+      :interpolate_constants => 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],
+        :interpolate_constants => @options[:interpolate_constants])
+      
+      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/lib/sprockets/lib/sprockets/source_file.rb

@@ -0,0 +1,56 @@
+module Sprockets
+  class SourceFile
+    attr_reader :environment, :pathname
+    attr_accessor :interpolate_constants
+
+    def initialize(environment, pathname)
+      @environment = environment
+      @pathname = pathname
+      @interpolate_constants = true
+    end
+
+    def source_lines
+      @lines ||= begin
+        lines = []
+
+        comments = []
+        File.open(pathname.absolute_location) do |file|
+          file.each do |line|
+            lines << line = SourceLine.new(self, line, file.lineno)
+
+            if line.begins_pdoc_comment? || comments.any?
+              comments << line
+            end
+
+            if line.ends_multiline_comment?
+              if line.ends_pdoc_comment?
+                comments.each { |l| l.comment! }
+              end
+              comments.clear
+            end
+          end
+        end
+
+        lines
+      end
+    end
+
+    def each_source_line(&block)
+      source_lines.each(&block)
+    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
+  end
+end

data/lib/sprockets/lib/sprockets/source_line.rb

@@ -0,0 +1,85 @@
+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 comment!
+      @comment = line
+    end
+
+    def begins_multiline_comment?
+      line =~ /^\s*\/\*(.*)/
+    end
+
+    def begins_pdoc_comment?
+      line =~ /^\s*\/\*\*(.*)/
+    end
+
+    def ends_multiline_comment?
+      line =~ /^(.*)\*\/\s*/
+    end
+
+    def ends_pdoc_comment?
+      line =~ /^(.*)\*\*\/\s*/
+    end
+
+    def require
+      @require ||= (comment || "")[/^=\s+require\s+(\"(.*?)\"|<(.*?)>)\s*$/, 1]
+    end
+    
+    def require?
+      !!require
+    end
+    
+    def provide
+      @provide ||= (comment || "")[/^=\s+provide\s+\"(.*?)\"\s*$/, 1]
+    end
+    
+    def provide?
+      !!provide
+    end
+    
+    def inspect
+      "line #@number of #{@source_file.pathname}"
+    end
+    
+    def to_s(constants = source_file.environment.constants)
+      result = line.chomp
+      interpolate_constants!(result, constants) if interpolate_constants?
+      strip_trailing_whitespace!(result)
+      result + $/
+    end
+    
+    protected
+      def interpolate_constants?
+        source_file.interpolate_constants != false
+      end
+      def interpolate_constants!(result, constants)
+        result.gsub!(/<%=(.*?)%>/) do
+          constant = $1.strip
+          if value = constants[constant]
+            value
+          else
+            raise UndefinedConstantError, "couldn't find constant `#{constant}' in #{inspect}"
+          end
+        end
+      end
+      
+      def strip_trailing_whitespace!(result)
+        result.gsub!(/\s+$/, "")
+      end
+  end
+end

data/lib/sprockets/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/lib/sprockets/lib/sprockets.rb

@@ -0,0 +1,42 @@
+$:.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/version"
+require "sprockets/error"
+require "sprockets/environment"
+require "sprockets/pathname"
+require "sprockets/source_line"
+require "sprockets/source_file"
+require "sprockets/concatenation"
+require "sprockets/preprocessor"
+require "sprockets/secretary"
+

data/lib/sprockets/test/fixtures/assets/images/script_with_assets/one.png

@@ -0,0 +1 @@
+one

data/lib/sprockets/test/fixtures/assets/images/script_with_assets/two.png

@@ -0,0 +1 @@
+two

data/lib/sprockets/test/fixtures/assets/stylesheets/script_with_assets.css

@@ -0,0 +1 @@
+/* nothing */

data/lib/sprockets/test/fixtures/constants.yml

@@ -0,0 +1 @@
+VERSION: 1.0

data/lib/sprockets/test/fixtures/double_slash_comments_that_are_not_requires_should_be_ignored_when_strip_comments_is_false.js

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

data/lib/sprockets/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 not appear in the resulting output file. */

data/lib/sprockets/test/fixtures/multiline_comments_should_be_removed_by_default.js

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

data/lib/sprockets/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/lib/sprockets/test/fixtures/requiring_a_file_that_does_not_exist_should_raise_an_error.js

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

data/lib/sprockets/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/lib/sprockets/test/fixtures/requiring_the_current_file_should_do_nothing.js

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

data/lib/sprockets/test/fixtures/src/constants.yml

@@ -0,0 +1,3 @@
+ONE: one
+TWO: two
+HELLO: Hello world!

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

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

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

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

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

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

data/lib/sprockets/test/fixtures/src/script_with_assets.js

@@ -0,0 +1,3 @@
+//= provide "../assets"
+
+var ScriptWithAssets = { };

data/lib/sprockets/test/fixtures/src/script_with_comments.js

@@ -0,0 +1,13 @@
+/*
+ * Comment that should remain
+ */
+
+/**
+ * PDoc comment that should be stripped
+ **/
+
+(function(){})();
+
+// This should be stripped, too
+
+with({}){}; // but not this

data/lib/sprockets/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.source_lines
+    assert_equal "hello\n", @concatenation.record(source_line("hello\n")).to_s
+    assert_equal "world\n", @concatenation.record(source_line("world\n")).to_s
+    assert_equal ["hello\n", "world\n"], @concatenation.source_lines.map { |source_line| source_line.to_s }
+  end
+  
+  def test_to_s
+    @concatenation.record(source_line("hello\n"))
+    @concatenation.record(source_line("world\n"))
+    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/lib/sprockets/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/lib/sprockets/test/test_helper.rb

@@ -0,0 +1,55 @@
+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, 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 || source_file("dummy"), line, line_number)
+    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/lib/sprockets/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