benoit 0.1.0

data/vendor/rake-pipeline/spec/graph_spec.rb

@@ -0,0 +1,56 @@
+describe "Rake::Pipeline::Graph" do
+  Graph = Rake::Pipeline::Graph
+  Node  = Rake::Pipeline::Graph::Node
+
+  before do
+    @graph = Graph.new
+  end
+
+  it "has nodes" do
+    @graph.nodes.should == []
+  end
+
+  it "can add nodes" do
+    @graph.add("foo")
+    @graph["foo"].should == Node.new("foo")
+  end
+
+  it "can link nodes" do
+    @graph.add("foo")
+    @graph.add("bar")
+    @graph.nodes.should == [Node.new("foo"), Node.new("bar")]
+    @graph.link("foo", "bar")
+    @graph["foo"].children.map(&:name).should == ["bar"]
+    @graph["bar"].parents.map(&:name).should == ["foo"]
+  end
+
+  it "can unlink nodes" do
+    @graph.add("foo")
+    @graph.add("bar")
+    @graph.link("foo", "bar")
+    @graph.unlink("foo", "bar")
+    @graph["foo"].children.should == Set[]
+    @graph["bar"].parents.should == Set[]
+  end
+
+  it "can remove nodes" do
+    @graph.add("foo")
+    @graph.add("bar")
+    @graph.nodes.should == [Node.new("foo"), Node.new("bar")]
+    @graph.link("foo", "bar")
+    @graph.remove("foo")
+    @graph.nodes.should == [Node.new("bar")]
+    @graph["bar"].children.should == Set[]
+    @graph["bar"].parents.should == Set[]
+  end
+
+  it "can add metadata to nodes" do
+    @graph.add("foo", :meta => 1)
+    @graph.add("bar")
+    @graph["bar"].metadata[:meta] = 2
+
+    @graph["foo"].metadata.should == { :meta => 1 }
+    @graph["bar"].metadata.should == { :meta => 2 }
+  end
+end
+

data/vendor/rake-pipeline/spec/gsub_filter_spec.rb

@@ -0,0 +1,87 @@
+describe "GsubFilter" do
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+
+  let(:input_files) {
+    [
+      MemoryFileWrapper.new("/path/to/input", "ember.js", "UTF-8", [], "Ember.assert"),
+    ]
+  }
+
+  let(:rake_application) { Rake::Application.new }
+
+  it "generates output" do
+    filter = Rake::Pipeline::GsubFilter.new "Ember.assert", "foo"
+    filter.rake_application = rake_application
+
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+
+    filter.output_root = "/path/to/output"
+    filter.input_files = input_files
+
+    filter.output_files.should == [MemoryFileWrapper.new("/path/to/output", "ember.js", "UTF-8", [])]
+
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    file = MemoryFileWrapper.files["/path/to/output/ember.js"]
+    file.body.should == "foo"
+  end
+
+  it "accepts a block to use with gsub" do
+    filter = Rake::Pipeline::GsubFilter.new "Ember.assert" do 
+      "foo"
+    end
+
+    filter.rake_application = rake_application
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+
+    filter.output_root = "/path/to/output"
+    filter.input_files = input_files
+
+    filter.output_files.should == [MemoryFileWrapper.new("/path/to/output", "ember.js", "UTF-8", [])]
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    file = MemoryFileWrapper.files["/path/to/output/ember.js"]
+    file.body.should == "foo"
+  end
+
+  it "should be able to access global match variables" do
+    filter = Rake::Pipeline::GsubFilter.new /Ember\.(.+)/ do |match, word|
+      word.should == "assert"
+      "Ember.#{word}Strongly"
+    end
+
+    filter.rake_application = rake_application
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+
+    filter.output_root = "/path/to/output"
+    filter.input_files = input_files
+
+    filter.output_files.should == [MemoryFileWrapper.new("/path/to/output", "ember.js", "UTF-8", [])]
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    file = MemoryFileWrapper.files["/path/to/output/ember.js"]
+    file.body.should == "Ember.assertStrongly"
+  end
+
+  it "use the input name for output" do
+    filter = Rake::Pipeline::GsubFilter.new
+    filter.rake_application = rake_application
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.output_root = "/path/to/output"
+    filter.input_files = input_files
+    filter.output_files.should == [MemoryFileWrapper.new("/path/to/output", "ember.js", "UTF-8", [])]
+  end
+end

data/vendor/rake-pipeline/spec/manifest_entry_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Rake::Pipeline::ManifestEntry do
+  let(:hash) do
+    {
+      "deps" => {
+        "file.h" => 100,
+        "other.h" => 100
+      },
+      "mtime" => 200
+    }
+  end
+
+  subject {
+    Rake::Pipeline::ManifestEntry.from_hash(hash)
+  }
+
+  describe "#from_hash" do
+    it "creates a new ManifestEntry from a hash" do
+      subject.should be_kind_of described_class
+    end
+
+    it "should leave mtimes have integers" do
+      subject.mtime.should == 200
+    end
+
+    it "parses each time from the deps value into a Time" do
+      subject.deps.each do |file, mtime|
+        mtime.should == 100
+      end
+    end
+  end
+
+  describe "#as_json" do
+    it "returns a hash representation of the entry for converting to json" do
+      subject.as_json.should == {
+        :deps => {
+          "file.h" => 100,
+          "other.h" => 100
+        },
+        :mtime => 200
+      }
+    end
+  end
+end
+

data/vendor/rake-pipeline/spec/manifest_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Rake::Pipeline::Manifest do
+  before do
+    # ensure all our date/time conversions happen in UTC.
+    ENV['TZ'] = 'UTC'
+  end
+
+  let(:manifest_file) { "#{tmp}/manifest.json" }
+
+  let(:json) { <<-JSON }
+{
+  "file.h": {
+    "deps": {
+      "other.h": "2000-01-01 00:00:00 +0000"
+    },
+    "mtime":"2000-01-01 00:00:00 +0000"
+  }
+}
+  JSON
+
+  let(:entries_hash) do
+    {
+      "file.h" => Rake::Pipeline::ManifestEntry.from_hash({
+        "deps" => {
+          "other.h" => "2000-01-01 00:00:00 +0000"
+        },
+        "mtime" => "2000-01-01 00:00:00 +0000"
+      })
+    }
+  end
+
+  subject do
+    Rake::Pipeline::Manifest.new(manifest_file)
+  end
+
+  describe "#write_manifest" do
+    before do
+      subject.entries = entries_hash
+      rm_rf manifest_file
+    end
+
+    it "writes a manifest json file to disk" do
+      subject.write_manifest
+
+      File.exist?(manifest_file).should be_true
+      JSON.parse(File.read(manifest_file)).should == JSON.parse(json)
+    end
+
+    it "writes nothing if it's empty" do
+      subject.entries = {}
+      subject.write_manifest
+      File.exist?(manifest_file).should be_false
+    end
+  end
+
+  describe "#read_manifest" do
+    before do
+      File.open(manifest_file, 'w') { |f| f.puts json }
+    end
+
+    it "reads a manifest json file from disk" do
+      subject.read_manifest
+      subject.entries.should == entries_hash
+    end
+  end
+end

data/vendor/rake-pipeline/spec/matcher_spec.rb

@@ -0,0 +1,141 @@
+describe "a matcher" do
+  sep = File::SEPARATOR
+
+  let(:project) { Rake::Pipeline::Project.new }
+
+  before do
+    @matcher = Rake::Pipeline::Matcher.new :project => project
+
+    @files = %w(jquery.js sproutcore.js sproutcore.css).map do |file|
+      file_wrapper(file)
+    end
+
+    @matcher.input_files = @files
+  end
+
+  def file_wrapper(file, options={})
+    root = options[:root] || tmp
+    encoding = options[:encoding] || "UTF-8"
+    Rake::Pipeline::FileWrapper.new(root, file, encoding)
+  end
+
+  it "accepts input files" do
+    @matcher.input_files.should == @files
+  end
+
+  it "can access its glob" do
+    @matcher.glob = "*.js"
+    @matcher.glob.should == "*.js"
+  end
+
+  it "knows about its containing pipeline" do
+    pipeline = Rake::Pipeline.new
+    pipeline.add_filter @matcher
+    @matcher.pipeline.should == pipeline
+  end
+
+  it "only processes files matching the matcher" do
+    @matcher.glob = "*.js"
+    @matcher.output_root = "tmp1"
+
+    concat = Rake::Pipeline::ConcatFilter.new
+    concat.output_name_generator = proc { |input| "app.js" }
+    @matcher.add_filter concat
+
+    @matcher.setup
+
+    concat.input_files.should == [
+      file_wrapper("jquery.js", :encoding => "BINARY"),
+      file_wrapper("sproutcore.js", :encoding => "BINARY")
+    ]
+
+    @matcher.output_files.should == [
+      file_wrapper("app.js", :root => File.join(tmp, "tmp1")),
+      file_wrapper("sproutcore.css")
+    ]
+  end
+
+  def should_match_glob(glob, files)
+    @matcher.glob = glob
+    @matcher.output_root = "tmp1"
+
+    concat = Rake::Pipeline::ConcatFilter.new
+    concat.output_name_generator = proc { |input| input }
+    @matcher.add_filter concat
+
+    @matcher.setup
+
+    @matcher.output_files.should == files
+  end
+
+  it "understands */* style globs" do
+    @matcher.input_files << file_wrapper("javascripts/backbone.js")
+    @matcher.input_files << file_wrapper("something/javascripts/backbone.js")
+
+    should_match_glob "*/*.js", [
+      file_wrapper("javascripts/backbone.js", :encoding => "BINARY", :root => File.join(tmp, "tmp1")),
+      file_wrapper("jquery.js"),
+      file_wrapper("sproutcore.js"),
+      file_wrapper("sproutcore.css"),
+      file_wrapper("something/javascripts/backbone.js")
+    ]
+
+    should_match_glob "proutcore*.js", [
+      file_wrapper("jquery.js"),
+      file_wrapper("sproutcore.js"),
+      file_wrapper("sproutcore.css"),
+      file_wrapper("javascripts/backbone.js"),
+      file_wrapper("something/javascripts/backbone.js")
+    ]
+  end
+
+  it "understands **/* style globs" do
+    @matcher.input_files << file_wrapper("javascripts/backbone.js")
+
+    output_root = File.join(tmp, "tmp1")
+
+    should_match_glob "**/*.js", [
+      file_wrapper("jquery.js", :encoding => "BINARY", :root => output_root),
+      file_wrapper("sproutcore.js", :encoding => "BINARY", :root => output_root),
+      file_wrapper("javascripts/backbone.js", :encoding => "BINARY", :root => output_root),
+      file_wrapper("sproutcore.css")
+    ]
+  end
+
+  it "understands {foo,bar}/* style globs" do
+    @matcher.input_files << file_wrapper("javascripts/backbone.js")
+
+    output_root = File.join(tmp, "tmp1")
+
+    should_match_glob "{jquery,sproutcore}.js", [
+      file_wrapper("jquery.js", :encoding => "BINARY", :root => output_root),
+      file_wrapper("sproutcore.js", :encoding => "BINARY", :root => output_root),
+      file_wrapper("sproutcore.css"),
+      file_wrapper("javascripts/backbone.js")
+    ]
+  end
+
+  it "accepts Regexp as glob" do
+    regexp = /application\.erb/
+    @matcher.glob = regexp
+
+    @matcher.glob.should == regexp
+  end
+
+  it "underestands regexp globs" do
+    regexp = /^*(?<!\.coffee)\.js$/i
+
+    @matcher.input_files << file_wrapper("application.coffee.js")
+    @matcher.input_files << file_wrapper("application.engine.js")
+
+    output_root = File.join(tmp, "tmp1")
+
+    should_match_glob regexp, [
+      file_wrapper("jquery.js", :encoding => "BINARY", :root => output_root),
+      file_wrapper("sproutcore.js", :encoding => "BINARY", :root => output_root),
+      file_wrapper("application.engine.js", :encoding => "BINARY", :root => output_root),
+      file_wrapper("sproutcore.css"),
+      file_wrapper("application.coffee.js")
+    ]
+  end
+end

data/vendor/rake-pipeline/spec/middleware_spec.rb

@@ -0,0 +1,199 @@
+require "rake-pipeline/middleware"
+require "rake-pipeline/filters"
+require "rack/test"
+
+describe "Rake::Pipeline Middleware" do
+  include Rack::Test::Methods
+
+  inputs = {
+    "app/javascripts/jquery.js" => "var jQuery = {};\n",
+
+    "app/javascripts/sproutcore.js" => <<-HERE.gsub(/^ {6}/, ''),
+      var SC = {};
+      assert(SC);
+      SC.hi = function() { console.log("hi"); };
+    HERE
+
+    "app/index.html" => "<html>HI</html>",
+      "app/javascripts/index.html" => "<html>JAVASCRIPT</html>",
+      "app/empty_dir" => nil
+  }
+
+  expected_output = <<-HERE.gsub(/^ {4}/, '')
+    var jQuery = {};
+    var SC = {};
+
+    SC.hi = function() { console.log("hi"); };
+  HERE
+
+  assetfile_source = <<-HERE.gsub(/^ {4}/, '')
+    require "#{tmp}/../support/spec_helpers/filters"
+    output "public"
+
+    map "/dynamic-request.js" do
+      [200, { "Content-Type" => "text/plain" }, ["I am dynamic!"]]
+    end
+
+    input "#{tmp}", "app/**/*" do
+      match "*.js" do
+        concat "javascripts/application.js"
+        filter(Rake::Pipeline::SpecHelpers::Filters::StripAssertsFilter) { |input| input }
+      end
+
+      # copy the rest
+      concat { |input| input.sub(%r|^app/|, '') }
+    end
+  HERE
+
+  modified_assetfile_source = <<-HERE.gsub(/^ {4}/, '')
+    require "#{tmp}/../support/spec_helpers/filters"
+    output "public"
+
+    input "#{tmp}", "app/**/*" do
+      match "*.js" do
+        concat { "javascripts/app.js" }
+        filter(Rake::Pipeline::SpecHelpers::Filters::StripAssertsFilter) { |input| input }
+      end
+
+      # copy the rest
+      concat { |input| input.sub(%r|^app/|, '') }
+    end
+  HERE
+
+  app = middleware = nil
+
+  let(:app) { middleware }
+
+  before do
+    assetfile_path = File.join(tmp, "Assetfile")
+    File.open(assetfile_path, "w") { |file| file.write(assetfile_source) }
+
+    project = Rake::Pipeline::Project.new assetfile_path
+
+    app = lambda { |env| [404, {}, ['not found']] }
+    middleware = Rake::Pipeline::Middleware.new(app, project)
+  end
+
+  describe "dynamic requests" do
+    it "returns the value from the given block for paths that have been mapped" do
+      get "/dynamic-request.js"
+
+      last_response.should be_ok
+      last_response.headers["Content-Type"].should == "text/plain"
+      last_response.body.should == "I am dynamic!"
+    end
+  end
+
+  describe "static requests" do
+    before do
+      inputs.each do |name, string|
+        path = File.join(tmp, name)
+        if string
+          mkdir_p File.dirname(path)
+          File.open(path, "w") { |file| file.write(string) }
+        else
+          mkdir_p path
+        end
+      end
+
+      get "/javascripts/application.js"
+    end
+
+    it "returns files relative to the output directory" do
+      last_response.should be_ok
+
+      last_response.body.should == expected_output
+      last_response.headers["Content-Type"].should == "application/javascript"
+    end
+
+    it "updates the output when files change" do
+      age_existing_files
+
+      File.open(File.join(tmp, "app/javascripts/jquery.js"), "w") do |file|
+        file.write "var jQuery = {};\njQuery.trim = function() {};\n"
+      end
+
+      expected = <<-HERE.gsub(/^ {6}/, '')
+      var jQuery = {};
+      jQuery.trim = function() {};
+      var SC = {};
+
+      SC.hi = function() { console.log("hi"); };
+      HERE
+
+      get "/javascripts/application.js"
+
+      last_response.body.should == expected
+      last_response.headers["Content-Type"].should == "application/javascript"
+    end
+
+    it "updates the output when new files are added" do
+      age_existing_files
+
+      File.open(File.join(tmp, "app/javascripts/history.js"), "w") do |file|
+        file.write "var History = {};\n"
+      end
+
+      expected = <<-HERE.gsub(/^ {6}/, '')
+      var History = {};
+      var jQuery = {};
+      var SC = {};
+
+      SC.hi = function() { console.log("hi"); };
+      HERE
+
+      get "/javascripts/application.js"
+
+      last_response.body.should == expected
+      last_response.headers["Content-Type"].should == "application/javascript"
+    end
+
+    it "returns index.html for directories" do
+      get "/"
+
+      last_response.body.should == "<html>HI</html>"
+      last_response.headers["Content-Type"].should == "text/html"
+
+      get "/javascripts"
+
+      last_response.body.should == "<html>JAVASCRIPT</html>"
+      last_response.headers["Content-Type"].should == "text/html"
+    end
+
+    it "ignores directories without index.html" do
+      get "/empty_dir"
+
+      last_response.body.should == "not found"
+      last_response.status.should == 404
+    end
+
+    it "falls back to the app" do
+      get "/zomg.notfound"
+
+      last_response.body.should == "not found"
+      last_response.status.should == 404
+    end
+
+    it "recreates the pipeline when the Assetfile changes" do
+      get "/javascripts/app.js"
+      last_response.body.should == "not found"
+      last_response.status.should == 404
+
+      File.open(File.join(tmp, "Assetfile"), "w") do |file|
+        file.write(modified_assetfile_source)
+      end
+
+      expected = <<-HERE.gsub(/^ {6}/, '')
+      var jQuery = {};
+      var SC = {};
+
+      SC.hi = function() { console.log("hi"); };
+      HERE
+
+      get "/javascripts/app.js"
+
+      last_response.body.should == expected
+      last_response.headers["Content-Type"].should == "application/javascript"
+    end
+  end
+end