rake-pipeline 0.5.0 → 0.7.0

data/spec/file_wrapper_spec.rb

@@ -33,8 +33,25 @@ describe "Rake::Pipeline::FileWrapper" do
     file.should_not == other
   end
 
-  it "has a fullpath" do
-    file.fullpath.should == jquery
+  describe "#fullpath" do
+    it "returns the complete path to the file" do
+      file.fullpath.should == jquery
+    end
+
+    it "raises an error if its root is not a root path" do
+      file.root = 'root'
+      lambda { file.fullpath }.should raise_error
+    end
+
+    it "doesn't raise an error with a unix root path" do
+      file.root = '/root'
+      lambda { file.fullpath }.should_not raise_error
+    end
+
+    it "doesn't raise an error with a windows root path" do
+      file.root = 'c:\root'
+      lambda { file.fullpath }.should_not raise_error
+    end
   end
 
   it "it knows it doesn't exist when the file doesn't exist" do

data/spec/filter_spec.rb

@@ -1,4 +1,9 @@
 describe "Rake::Pipeline::Filter" do
+  after do
+    # Clean out all defined tasks after each test runs
+    Rake.application = Rake::Application.new
+  end
+
   def input_file(path, file_root=input_root)
     Rake::Pipeline::FileWrapper.new(file_root, path)
   end
@@ -11,7 +16,7 @@ describe "Rake::Pipeline::Filter" do
   let(:input_root)  { File.join(tmp, "app/assets") }
   let(:output_root) { File.join(tmp, "filter1/app/assets") }
   let(:input_files) do
-    %w(jquery.js jquery-ui.js sproutcore.js).map { |f| input_file(f) }
+    %w(jquery.js jquery-ui.js ember.js).map { |f| input_file(f) }
   end
 
   it "accepts a series of FileWrapper objects for the input" do
@@ -47,6 +52,13 @@ describe "Rake::Pipeline::Filter" do
     new_filter.output_name_generator.should == conversion
   end
 
+  it "knows about its containing pipeline" do
+    pipeline = Rake::Pipeline.new
+    filter = Rake::Pipeline::Filter.new
+    pipeline.add_filter(filter)
+    filter.pipeline.should == pipeline
+  end
+
   describe "using the output_name proc to converting the input names into a hash" do
     before do
       filter.output_root = output_root
@@ -64,6 +76,20 @@ describe "Rake::Pipeline::Filter" do
       filter.output_files.should == [output_file("application.js")]
     end
 
+    it "with more than one output per input" do
+      output_name_generator = proc { |input| [ input, "application.js" ] }
+      filter.output_name_generator = output_name_generator
+      outputs = filter.outputs
+
+      outputs = input_files.inject({}) do |hash, input|
+        hash.merge output_file(input.path) => [ input ]
+      end
+
+      filter.outputs.should == { output_file("application.js") => input_files }.merge(outputs)
+      filter.output_files.sort.should ==
+        ([ output_file("application.js") ] + input_files.map { |f| output_file(f.path) }).sort
+    end
+
     it "with a 1:1 output_name proc" do
       output_name_generator = proc { |input| input }
       filter.output_name_generator = output_name_generator
@@ -80,27 +106,28 @@ describe "Rake::Pipeline::Filter" do
       filter.output_name_generator = output_name_generator
       outputs = filter.outputs
 
-      outputs.keys.should == [output_file("jquery.js"), output_file("sproutcore.js")]
-      outputs.values.should == [[input_file("jquery.js"), input_file("jquery-ui.js")], [input_file("sproutcore.js")]]
+      outputs.keys.sort.should == [output_file("ember.js"), output_file("jquery.js")]
+      outputs.values.sort.should == [[input_file("ember.js")], [input_file("jquery.js"), input_file("jquery-ui.js")]]
 
-      filter.output_files.should == [output_file("jquery.js"), output_file("sproutcore.js")]
+      filter.output_files.should == [output_file("jquery.js"), output_file("ember.js")]
     end
   end
 
   describe "generates rake tasks" do
-    class TestFilter < Rake::Pipeline::Filter
-      attr_accessor :generate_output_block
+    let(:filter_class) {
+      Class.new(Rake::Pipeline::Filter) do
+        attr_accessor :generate_output_block
 
-      def generate_output(inputs, output)
-        generate_output_block.call(inputs, output)
+        def generate_output(inputs, output)
+          generate_output_block.call(inputs, output)
+        end
       end
-    end
-
-    let(:filter)      { TestFilter.new }
+    }
+    let(:filter)      { filter_class.new }
     let(:input_root)  { File.join(tmp, "app/assets") }
     let(:output_root) { File.join(tmp, "filter1/app/assets") }
     let(:input_files) do
-      %w(jquery.js jquery-ui.js sproutcore.js).map do |file|
+      %w(jquery.js jquery-ui.js ember.js).map do |file|
         input_file("javascripts/#{file}")
       end
     end
@@ -112,11 +139,11 @@ describe "Rake::Pipeline::Filter" do
     end
 
     def output_task(path, app=Rake.application)
-      app.define_task(Rake::FileTask, File.join(output_root, path))
+      app.define_task(Rake::Pipeline::DynamicFileTask, File.join(output_root, path))
     end
 
     def input_task(path)
-      Rake::FileTask.define_task(File.join(input_root, path))
+      Rake::Pipeline::DynamicFileTask.define_task(File.join(input_root, path))
     end
 
     it "does not generate Rake tasks onto Rake.application if an alternate application is supplied" do
@@ -148,13 +175,21 @@ describe "Rake::Pipeline::Filter" do
       filter.generate_rake_tasks
       tasks = filter.rake_tasks
       tasks.should == [output_task("javascripts/application.js")]
-      tasks[0].prerequisites.should == input_files.map { |i| i.fullpath }
 
       tasks.each(&:invoke)
 
       filter_runs.should == 1
     end
 
+    it "with an output_name proc that takes two arguments" do
+      filter.output_name_generator = proc { |path, input|
+        input.path.upcase
+      }
+
+      filter.outputs.keys.map(&:path).should include('JAVASCRIPTS/JQUERY.JS')
+      filter.output_files.map(&:path).should include('JAVASCRIPTS/JQUERY.JS')
+    end
+
     it "with a 1:1 output_name proc" do
       filter_runs = 0
 
@@ -187,9 +222,9 @@ describe "Rake::Pipeline::Filter" do
         if output.path == "javascripts/jquery.js"
           inputs.should == [input_file("javascripts/jquery.js"), input_file("javascripts/jquery-ui.js")]
           output.should == output_file("javascripts/jquery.js")
-        elsif output.path == "javascripts/sproutcore.js"
-          inputs.should == [input_file("javascripts/sproutcore.js")]
-          output.should == output_file("javascripts/sproutcore.js")
+        elsif output.path == "javascripts/ember.js"
+          inputs.should == [input_file("javascripts/ember.js")]
+          output.should == output_file("javascripts/ember.js")
         else
           flunk
         end
@@ -199,18 +234,81 @@ describe "Rake::Pipeline::Filter" do
 
       filter.generate_rake_tasks
       tasks = filter.rake_tasks
-      tasks.sort.should == [output_task("javascripts/jquery.js"), output_task("javascripts/sproutcore.js")].sort
+      tasks.sort.should == [output_task("javascripts/jquery.js"), output_task("javascripts/ember.js")].sort
 
       tasks.sort[0].prerequisites.should == [
-        File.join(input_root, "javascripts/jquery.js"),
-        File.join(input_root, "javascripts/jquery-ui.js")
+        File.join(input_root, "javascripts/ember.js"),
       ]
 
-      tasks.sort[1].prerequisites.should == [File.join(input_root, "javascripts/sproutcore.js")]
+      tasks.sort[1].prerequisites.should == [
+        File.join(input_root, "javascripts/jquery.js"),
+        File.join(input_root, "javascripts/jquery-ui.js"),
+      ]
 
       tasks.each(&:invoke)
 
       filter_runs.should == 2
     end
   end
+
+  describe "a filter with additional_dependencies" do
+    let(:include_filter) {
+      Class.new(Rake::Pipeline::ConcatFilter) do
+        def additional_dependencies(input)
+          includes(input)
+        end
+
+        def includes(input)
+          input.read.scan(/^#include \"(.*)\"$/).map(&:first).map do |inc|
+            File.join(input.root, inc)
+          end
+        end
+
+        def generate_output(inputs, output)
+          out = ""
+          inputs.each do |input|
+            includes(input).each { |inc| out += File.read(inc) }
+            out += input.read
+            output.write out
+          end
+        end
+      end
+    }
+
+    def write_input_file(filename, contents='', root=input_root)
+      mkdir_p root
+      File.open(File.join(root, filename), 'w') { |f| f.puts contents }
+      input_file(filename)
+    end
+
+    def invoke_filter(filter)
+      mkdir_p output_root
+      filter.output_root = output_root
+      filter.input_files = input_files
+      tasks = filter.generate_rake_tasks
+      tasks.each(&:invoke)
+      tasks
+    end
+
+    let!(:main)        { write_input_file('main', '#include "header"') }
+    let!(:header)      { write_input_file('header', 'header') }
+    let!(:main_output) { output_file('main') }
+    let(:input_files)  { [main] }
+    let(:filter)       { include_filter.new }
+
+    it "creates its output files" do
+      invoke_filter(filter)
+      main_output.exists?.should be_true
+      main_output.read.should == %[header\n#include "header"\n]
+    end
+
+    it "rebuilds the main file when a dynamic dependency changes" do
+      invoke_filter(filter)
+      File.open(header.fullpath, 'w') { |f| f.puts 'PEANUTS' }
+      filter.rake_tasks.each { |t| t.recursively_reenable(Rake.application) }
+      invoke_filter(filter)
+      main_output.read.should == %[PEANUTS\n#include "header"\n]
+    end
+  end
 end
+

data/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/spec/manifest_entry_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Rake::Pipeline::ManifestEntry do
+  before do
+    # ensure all our date/time conversions happen in UTC.
+    ENV['TZ'] = 'UTC'
+  end
+
+  let(:hash) do
+    {
+      "deps" => {
+        "file.h" => "2001-01-01 00:00:00 +0000",
+        "other.h" => "2001-01-01 00:00:00 +0000"
+      },
+      "mtime" => "2000-01-01 00:00:00 +0000"
+    }
+  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 "parses mtime value into a Time" do
+      subject.mtime.should == Time.utc(2000)
+    end
+
+    it "parses each time from the deps value into a Time" do
+      subject.deps.each do |file, mtime|
+        mtime.should == Time.utc(2001)
+      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" => Time.utc(2001),
+          "other.h" => Time.utc(2001),
+        },
+        :mtime => Time.utc(2000)
+      }
+    end
+  end
+end
+

data/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/spec/matcher_spec.rb

@@ -25,6 +25,12 @@ describe "a matcher" do
     @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"
@@ -61,19 +67,22 @@ describe "a matcher" do
 
   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("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("javascripts/backbone.js"),
+      file_wrapper("something/javascripts/backbone.js")
     ]
   end
 
@@ -102,4 +111,28 @@ describe "a matcher" do
       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