rake-pipeline 0.5.0 → 0.7.0

data/spec/project_spec.rb

@@ -0,0 +1,293 @@
+describe "Rake::Pipeline::Project" do
+  include Rake::Pipeline::SpecHelpers::InputHelpers
+
+  ASSETFILE_SOURCE = <<-HERE.gsub(/^ {4}/, '')
+    require "#{tmp}/../support/spec_helpers/filters"
+    tmpdir "tmp"
+    output "public"
+
+    input "app/assets" do
+      match "*.js" do
+        concat "javascripts/application.js"
+        filter Rake::Pipeline::SpecHelpers::Filters::StripAssertsFilter
+      end
+    end
+  HERE
+
+  MODIFIED_ASSETFILE_SOURCE = <<-HERE.gsub(/^ {4}/, '')
+    require "#{tmp}/../support/spec_helpers/filters"
+    tmpdir "tmp"
+    output "public"
+
+    input "app/assets" do
+      match "*.js" do
+        concat "javascripts/app.js"
+        filter Rake::Pipeline::SpecHelpers::Filters::StripAssertsFilter
+      end
+    end
+  HERE
+
+  BAD_ASSETFILE_SOURCE = <<-HERE.gsub(/^ {4}/, '')
+    require "#{tmp}/../support/spec_helpers/filters"
+    tmpdir "tmp"
+    output "public"
+
+    input "app/assets" do
+      method_not_in_dsl_on_line_6
+    end
+  HERE
+
+  let(:assetfile_path) { File.join(tmp, "Assetfile") }
+
+  def assetfile_digest
+    (Digest::SHA1.new << File.read(assetfile_path)).to_s
+  end
+
+  let(:unmatched_file) { input_file("junk.txt") }
+
+  let(:input_files) do
+    [input_file("jquery.js"), input_file("ember.js"), unmatched_file]
+  end
+
+  let(:output_files) do
+    [output_file("javascripts/application.js")]
+  end
+
+  let(:old_tmpdir) do
+    File.join(tmp, "tmp", "rake-pipeline-ad7a83894789")
+  end
+
+  let(:digested_tmpdir) do
+    File.join(tmp, "tmp", "rake-pipeline-#{assetfile_digest}")
+  end
+
+  attr_reader :project
+
+  before do
+    File.open(assetfile_path, 'w') { |file| file.write(ASSETFILE_SOURCE) }
+    create_files(input_files)
+    @project = Rake::Pipeline::Project.new(assetfile_path)
+    mkdir_p(old_tmpdir)
+  end
+
+  it "has an assetfile_path" do
+    project.assetfile_path.should == assetfile_path
+  end
+
+  it "has an assetfile_digest" do
+    project.assetfile_digest.should == assetfile_digest
+  end
+
+  it "has a pipeline" do
+    project.should have(1).pipelines
+  end
+
+  describe "constructor" do
+    it "creates pipelines from an Assetfile given an Assetfile path" do
+      project = Rake::Pipeline::Project.new(assetfile_path)
+      project.maps.should == {}
+      pipeline = project.pipelines.last
+      pipeline.inputs.should == { "app/assets" => "**/*" }
+      pipeline.output_root.should == File.join(tmp, "public")
+    end
+
+    it "wraps an existing pipeline" do
+      pipeline = Rake::Pipeline::Project.class_eval("build do\n#{File.read(assetfile_path)}\nend", assetfile_path, 1)
+      project = Rake::Pipeline::Project.new(pipeline)
+      project.pipelines.last.should == pipeline
+    end
+  end
+
+  describe "#invoke" do
+    it "creates output files" do
+      output_files.each { |file| file.should_not exist }
+      project.invoke
+      output_files.each { |file| file.should exist }
+    end
+
+    it "writes temp files to a subdirectory of the tmp dir named after the assetfile digest" do
+      project.invoke
+      File.exist?(digested_tmpdir).should be_true
+    end
+  end
+
+  describe "invalid Assetfile" do
+    before do
+      File.open(assetfile_path, 'w') { |file| file.write(BAD_ASSETFILE_SOURCE) }
+    end
+
+    it "should raise error with assetfile path on correct line number" do
+      lambda {
+        Rake::Pipeline::Project.new(assetfile_path)
+      }.should raise_error {|error| error.backtrace[0].should match(/Assetfile:6/) }
+    end
+  end
+
+  describe "#invoke_clean" do
+    context "if the Assetfile contents have changed" do
+      def modify_assetfile
+        File.open(assetfile_path, 'w') do |file|
+          file.write(MODIFIED_ASSETFILE_SOURCE)
+        end
+      end
+
+      it "rebuilds its pipeline" do
+        project.invoke_clean
+        original_pipeline = project.pipelines.last
+        original_assetfile_digest = assetfile_digest
+
+        modify_assetfile
+        project.invoke_clean
+        assetfile_digest.should_not == original_assetfile_digest
+        project.pipelines.last.should_not == original_pipeline
+      end
+    end
+  end
+
+  describe "#cleanup_tmpdir" do
+    it "cleans old rake-pipeline-* dirs out of the pipeline's tmp dir" do
+      File.exist?(old_tmpdir).should be_true
+      project.cleanup_tmpdir
+      File.exist?(old_tmpdir).should be_false
+    end
+
+    it "leaves the current assetfile-digest tmp dir alone" do
+      project.invoke
+      File.exist?(digested_tmpdir).should be_true
+      project.cleanup_tmpdir
+      File.exist?(digested_tmpdir).should be_true
+    end
+  end
+
+  describe "#clean" do
+    def rakep_tmpdirs
+      Dir["#{tmp}/tmp/rake-pipeline-*"]
+    end
+
+    it "cleans all rake-pipeline-* dirs out of the pipeline's tmp dir" do
+      project.invoke
+      rakep_tmpdirs.should_not be_empty
+      project.clean
+      rakep_tmpdirs.should be_empty
+    end
+
+    it "removes the pipeline's output files" do
+      project.invoke
+      output_files.each { |f| f.should exist }
+      project.clean
+      output_files.each { |f| f.should_not exist }
+    end
+
+    it "leaves the pipeline's unmatched input files alone" do
+      project.invoke
+      project.clean
+      unmatched_file.should exist
+    end
+  end
+
+  describe ".add_to_digest" do
+    after do
+      Rake::Pipeline::Project.digest_additions = []
+    end
+
+    it "appends a string to the generated tmp dir name" do
+      Rake::Pipeline::Project.add_to_digest("octopus")
+
+      File.basename(project.digested_tmpdir).should ==
+        "rake-pipeline-#{assetfile_digest}-octopus"
+    end
+
+    it "can be called multiple times" do
+      Rake::Pipeline::Project.add_to_digest("a")
+      Rake::Pipeline::Project.add_to_digest("b")
+
+      File.basename(project.digested_tmpdir).should ==
+        "rake-pipeline-#{assetfile_digest}-a-b"
+    end
+  end
+
+  describe "#build_pipeline" do
+    let(:inputs) { {"foo" => "**/*"} }
+
+    it "returns a pipeline" do
+      pipeline = project.build_pipeline(inputs) {}
+      pipeline.should be_kind_of(Rake::Pipeline)
+    end
+
+    it "adds the pipeline to the list of pipelines" do
+      pipeline = project.build_pipeline(inputs) {}
+      project.pipelines.last.should == pipeline
+    end
+
+    it "configures the pipeline with the pipeline DSL" do
+      pipeline = project.build_pipeline(inputs) do
+        output "bar"
+      end
+
+      pipeline.output_root.should == File.expand_path("bar")
+    end
+
+    it "sets the pipeline's tmpdir to a digest tmpdir" do
+      pipeline = project.build_pipeline(inputs) {}
+      pipeline.tmpdir.should == project.digested_tmpdir
+    end
+
+    it "sets the pipeline's output_root to the default_output_root" do
+      pipeline = project.build_pipeline(inputs) {}
+      pipeline.output_root.should == project.default_output_root
+    end
+
+    it "sets the pipeline's project to itself" do
+      pipeline = project.build_pipeline(inputs) {}
+      pipeline.project.should == project
+    end
+
+    it "creates a pipeline with a given set of inputs" do
+      pipeline = project.build_pipeline(inputs) {}
+      pipeline.inputs.should == inputs
+    end
+
+    it "can be called with a single path input" do
+      pipeline = project.build_pipeline("/path") {}
+      pipeline.inputs.should == {"/path" => "**/*"}
+    end
+
+    it "can be called with a path and a glob" do
+      pipeline = project.build_pipeline("/path", "*.js") {}
+      pipeline.inputs.should == {"/path" => "*.js"}
+    end
+
+    it "can be called with an array of paths" do
+      pipeline = project.build_pipeline(["path1", "path2"]) {}
+      pipeline.inputs.should have_key("path1")
+      pipeline.inputs.should have_key("path2")
+    end
+
+    it "can be called with a hash of path => glob pairs" do
+      pipeline = project.build_pipeline({"/path" => "*.css"}) {}
+      pipeline.inputs.should == {"/path" => "*.css"}
+    end
+  end
+
+  describe "#obsolete_tmpdirs" do
+    it "includes tmp directories that don't match the current digest" do
+      project.obsolete_tmpdirs.should include(old_tmpdir)
+    end
+  end
+
+  describe "#files_to_clean" do
+    it "includes a project's output files" do
+      output_files.each do |file|
+        project.files_to_clean.should include(file.fullpath)
+      end
+    end
+
+    it "includes a project's temporary directory" do
+      project.files_to_clean.should include(digested_tmpdir)
+    end
+
+    it "includes any old digest tmp dirs" do
+      project.files_to_clean.should include(old_tmpdir)
+    end
+  end
+end

data/spec/rake_acceptance_spec.rb

@@ -1,6 +1,6 @@
 require "rake-pipeline/filters"
 
-describe "A realistic pipeline" do
+describe "A realistic project" do
 
 INPUTS = {
 
@@ -26,10 +26,14 @@ HERE
 }
 HERE
 
-"app/index.html" => <<-HERE
+"app/index.html" => <<-HERE,
 <html></html>
 HERE
 
+"app/junk.txt" => <<-HERE
+junk
+HERE
+
 }
 
 EXPECTED_JS_OUTPUT = <<-HERE
@@ -52,15 +56,6 @@ EXPECTED_HTML_OUTPUT = <<-HERE
 <html></html>
 HERE
 
-  before do
-    Rake.application = Rake::Application.new
-
-    INPUTS.each do |name, string|
-      mkdir_p File.dirname(File.join(tmp, name))
-      File.open(File.join(tmp, name), "w") { |file| file.write(string) }
-    end
-  end
-
   def input_wrapper(path)
     Rake::Pipeline::FileWrapper.new(tmp, path)
   end
@@ -78,65 +73,112 @@ HERE
   concat_filter = Rake::Pipeline::ConcatFilter
   strip_asserts_filter = Rake::Pipeline::SpecHelpers::Filters::StripAssertsFilter
 
-  it "can successfully apply filters" do
-    concat = concat_filter.new
-    concat.input_files = INPUTS.keys.select { |key| key =~ /javascript/ }.map { |file| input_wrapper(file) }
-    concat.output_root = File.join(tmp, "temporary", "concat_filter")
-    concat.output_name_generator = proc { |input| "javascripts/application.js" }
+  def copy_files
+    INPUTS.each do |name, string|
+      mkdir_p File.dirname(File.join(tmp, name))
+      File.open(File.join(tmp, name), "w") { |file| file.write(string) }
+    end
+  end
 
-    strip_asserts = strip_asserts_filter.new
-    strip_asserts.input_files = concat.output_files
-    strip_asserts.output_root = File.join(tmp, "public")
-    strip_asserts.output_name_generator = proc { |input| input }
+  before do
+    Rake.application = Rake::Application.new
+    copy_files
+  end
 
-    concat.generate_rake_tasks
-    Rake::Task.define_task(:default => strip_asserts.generate_rake_tasks)
-    Rake.application[:default].invoke
+  describe "a pipeline" do
+    it "can successfully apply filters" do
+      concat = concat_filter.new
+      concat.input_files = INPUTS.keys.select { |key| key =~ /javascript/ }.map { |file| input_wrapper(file) }
+      concat.output_root = File.join(tmp, "temporary", "concat_filter")
+      concat.output_name_generator = proc { |input| "javascripts/application.js" }
 
-    output_should_exist
-  end
+      strip_asserts = strip_asserts_filter.new
+      strip_asserts.input_files = concat.output_files
+      strip_asserts.output_root = File.join(tmp, "public")
+      strip_asserts.output_name_generator = proc { |input| input }
 
-  it "can be configured using the pipeline" do
-    pipeline = Rake::Pipeline.new
-    pipeline.input_root = File.expand_path(tmp)
-    pipeline.output_root = File.expand_path("public")
-    pipeline.input_glob = "app/javascripts/*.js"
-    pipeline.tmpdir = "temporary"
+      concat.generate_rake_tasks
+      Rake::Task.define_task(:default => strip_asserts.generate_rake_tasks)
+      Rake.application[:default].invoke
 
-    concat = concat_filter.new
-    concat.output_name_generator = proc { |input| "javascripts/application.js" }
+      output_should_exist
+    end
 
-    strip_asserts = strip_asserts_filter.new
-    strip_asserts.output_name_generator = proc { |input| input }
+    it "supports filters with multiple outputs per input" do
+      concat = concat_filter.new
+      concat.input_files = INPUTS.keys.select { |key| key =~ /javascript/ }.map { |file| input_wrapper(file) }
+      concat.output_root = File.join(tmp, "temporary", "concat_filter")
+      concat.output_name_generator = proc { |input| [ "javascripts/application.js", input.sub(/^app\//, '') ] }
 
-    pipeline.add_filters(concat, strip_asserts)
-    pipeline.invoke
+      strip_asserts = strip_asserts_filter.new
+      strip_asserts.input_files = concat.output_files
+      strip_asserts.output_root = File.join(tmp, "public")
+      strip_asserts.output_name_generator = proc { |input| input }
 
-    output_should_exist
+      concat.generate_rake_tasks
+      Rake::Task.define_task(:default => strip_asserts.generate_rake_tasks)
+      Rake.application[:default].invoke
+
+      output_should_exist
+
+      expected_files = {
+        "javascripts/jquery.js" => "var jQuery = {};\n",
+        "javascripts/sproutcore.js" => "var SC = {};\n\nSC.hi = function() { console.log(\"hi\"); };\n"
+      }
+
+      expected_files.each do |file, expected|
+        output_file = File.join(tmp, "public", file)
+        output = nil
+
+        lambda { output = File.read(output_file) }.should_not raise_error
+        output.should == expected
+      end
+    end
+
+    it "can be configured using the pipeline" do
+      pipeline = Rake::Pipeline.new
+      pipeline.add_input tmp, 'app/javascripts/*.js'
+      pipeline.output_root = File.expand_path("public")
+      pipeline.tmpdir = "temporary"
+
+      concat = concat_filter.new
+      concat.output_name_generator = proc { |input| "javascripts/application.js" }
+
+      strip_asserts = strip_asserts_filter.new
+      strip_asserts.output_name_generator = proc { |input| input }
+
+      pipeline.add_filters(concat, strip_asserts)
+      pipeline.invoke
+
+      output_should_exist
+    end
   end
 
   describe "using the pipeline DSL" do
-
-    attr_reader :pipeline
+    attr_reader :project
 
     shared_examples_for "the pipeline DSL" do
       it "can be configured using the pipeline DSL" do
-        pipeline.invoke
+        project.invoke
         output_should_exist
       end
 
       it "can be configured using the pipeline DSL with an alternate Rake application" do
-        pipeline.rake_application = Rake::Application.new
-        pipeline.invoke
+        project.pipelines.first.rake_application = Rake::Application.new
+        project.invoke
         output_should_exist
       end
 
       it "can be invoked repeatedly to reflected updated changes" do
-        pipeline.invoke
+        project.invoke
         age_existing_files
 
-        File.open(File.join(tmp, "app/javascripts/jquery.js"), "w") do |file|
-          file.write "var jQuery = {};\njQuery.trim = function() {};\n"
+        if respond_to?(:update_jquery)
+          update_jquery
+        else
+          File.open(File.join(tmp, "app/javascripts/jquery.js"), "w") do |file|
+            file.write "var jQuery = {};\njQuery.trim = function() {};\n"
+          end
         end
 
         expected = <<-HERE.gsub(/^ {10}/, '')
@@ -147,20 +189,24 @@ HERE
           SC.hi = function() { console.log("hi"); };
         HERE
 
-        pipeline.invoke
+        project.invoke
 
         output_should_exist(expected)
       end
 
       it "can be restarted to reflect new files" do
-        pipeline.invoke
+        project.invoke
         age_existing_files
 
-        File.open(File.join(tmp, "app/javascripts/history.js"), "w") do |file|
-          file.write "var History = {};\n"
+        if respond_to?(:update_history)
+          update_history
+        else
+          File.open(File.join(tmp, "app/javascripts/history.js"), "w") do |file|
+            file.write "var History = {};\n"
+          end
         end
 
-        pipeline.invoke_clean
+        project.invoke_clean
 
         expected = <<-HERE.gsub(/^ {10}/, '')
           var History = {};
@@ -174,36 +220,98 @@ HERE
       end
     end
 
-    describe "the raw pipeline DSL" do
+    describe "the raw pipeline DSL (with block strip_asserts_filter)" do
       it_behaves_like "the pipeline DSL"
 
       before do
-        @pipeline = Rake::Pipeline.build do
+        @project = Rake::Pipeline::Project.build do
           tmpdir "temporary"
-          input tmp, "app/javascripts/*.js"
-          filter(concat_filter) { "javascripts/application.js" }
-          filter(strip_asserts_filter) { |input| input }
           output "public"
+
+          input tmp, "app/javascripts/*.js" do
+            concat "javascripts/application.js"
+            filter(strip_asserts_filter) { |input| input }
+          end
         end
       end
     end
 
-    describe "the raw pipeline DSL" do
+    describe "the raw pipeline DSL (with before_filter)" do
       it_behaves_like "the pipeline DSL"
 
       before do
-        @pipeline = Rake::Pipeline.build do
+        @project = Rake::Pipeline::Project.build do
           tmpdir "temporary"
-          input tmp, "app/javascripts/*.js"
-          filter concat_filter, "javascripts/application.js"
-          filter strip_asserts_filter
           output "public"
+
+          before_filter Rake::Pipeline::ConcatFilter, "javascripts/application.js"
+
+          input tmp, "app/javascripts/*.js" do
+            filter strip_asserts_filter
+          end
+        end
+      end
+    end
+
+    describe "the raw pipeline DSL (with simple strip_asserts_filter)" do
+      it_behaves_like "the pipeline DSL"
+
+      before do
+        @project = Rake::Pipeline::Project.build do
+          tmpdir "temporary"
+          output "public"
+
+          input tmp, "app/javascripts/*.js" do
+            concat "javascripts/application.js"
+            filter strip_asserts_filter
+          end
         end
       end
     end
 
     describe "using the matcher spec" do
+      def output_should_exist(expected=EXPECTED_JS_OUTPUT)
+        super
+
+        css = File.join(tmp, "public/stylesheets/application.css")
+
+        File.exists?(css).should be_true
+        File.read(css).should == EXPECTED_CSS_OUTPUT
+
+        html = File.join(tmp, "public/index.html")
+        File.exists?(html).should be_true
+        File.read(html).should == EXPECTED_HTML_OUTPUT
+
+        junk = File.join(tmp, "public/junk.txt")
+        File.exists?(junk).should be_false
+      end
+
+      it_behaves_like "the pipeline DSL"
+
+      before do
+        @project = Rake::Pipeline::Project.build do
+          tmpdir "temporary"
+          output "public"
+
+          input File.join(tmp, "app") do
+            match "**/*.js" do
+              filter strip_asserts_filter
+              concat "javascripts/application.js"
+            end
+
+            match "**/*.css" do
+              concat "stylesheets/application.css"
+            end
+
+            match "**/*.html" do
+              concat
+            end
+          end
+        end
+      end
+    end
 
+    describe "using multiple pipelines (with after_filters)" do
       def output_should_exist(expected=EXPECTED_JS_OUTPUT)
         super
 
@@ -215,23 +323,155 @@ HERE
         html = File.join(tmp, "public/index.html")
         File.exists?(html).should be_true
         File.read(html).should == EXPECTED_HTML_OUTPUT
+
+        junk = File.join(tmp, "public/junk.txt")
+        File.exists?(junk).should be_false
       end
 
       it_behaves_like "the pipeline DSL"
 
       before do
-        @pipeline = Rake::Pipeline.build do
+        @project = Rake::Pipeline::Project.build do
           tmpdir "temporary"
-          input File.join(tmp, "app"), "**/*.{js,css,html}"
           output "public"
 
-          match "**/*.js" do
+          app_dir = File.join(tmp, "app")
+
+          after_filter Rake::Pipeline::ConcatFilter do |input|
+            ext = File.extname(input)
+
+            case ext
+            when ".js"
+              "javascripts/application.js"
+            when ".css"
+              "stylesheets/application.css"
+            when ".html"
+              input
+            end
+          end
+
+          input app_dir, "**/*.js" do
             filter strip_asserts_filter
-            filter concat_filter, "javascripts/application.js"
           end
 
-          match "**/*.css" do
-            filter concat_filter, "stylesheets/application.css"
+          input app_dir, "**/*.css"
+
+          input app_dir, "**/*.html"
+        end
+      end
+    end
+
+    describe "using multiple pipelines" do
+      def output_should_exist(expected=EXPECTED_JS_OUTPUT)
+        super
+
+        css = File.join(tmp, "public/stylesheets/application.css")
+
+        File.exists?(css).should be_true
+        File.read(css).should == EXPECTED_CSS_OUTPUT
+
+        html = File.join(tmp, "public/index.html")
+        File.exists?(html).should be_true
+        File.read(html).should == EXPECTED_HTML_OUTPUT
+
+        junk = File.join(tmp, "public/junk.txt")
+        File.exists?(junk).should be_false
+      end
+
+      it_behaves_like "the pipeline DSL"
+
+      before do
+        @project = Rake::Pipeline::Project.build do
+          tmpdir "temporary"
+          output "public"
+
+          app_dir = File.join(tmp, "app")
+
+          input app_dir, "**/*.js" do
+            filter strip_asserts_filter
+            concat "javascripts/application.js"
+          end
+
+          input app_dir, "**/*.css" do
+            concat "stylesheets/application.css"
+          end
+
+          input app_dir, "**/*.html" do
+            concat
+          end
+        end
+      end
+    end
+
+    describe "using the matcher spec (with multiple inputs to a single pipeline)" do
+      it_behaves_like "the pipeline DSL"
+
+      def tmp1
+        File.join(tmp, 'tmp1')
+      end
+
+      def tmp2
+        File.join(tmp, 'tmp2')
+      end
+
+      def update_jquery
+        File.open(File.join(tmp1, "app/javascripts/jquery.js"), "w") do |file|
+          file.write "var jQuery = {};\njQuery.trim = function() {};\n"
+        end
+      end
+
+      def update_history
+        File.open(File.join(tmp1, "app/javascripts/history.js"), "w") do |file|
+          file.write "var History = {};\n"
+        end
+      end
+
+      def copy_files
+        INPUTS.each do |name, string|
+          file = name =~ /\.js$/ ? File.join(tmp1, name) : File.join(tmp2, name)
+
+          mkdir_p File.dirname(file)
+          File.open(file, "w") { |f| f.write(string) }
+        end
+      end
+
+      def output_should_exist(expected=EXPECTED_JS_OUTPUT)
+        super
+
+        css = File.join(tmp, "public/stylesheets/application.css")
+
+        File.exists?(css).should be_true
+        File.read(css).should == EXPECTED_CSS_OUTPUT
+
+        html = File.join(tmp, "public/index.html")
+        File.exists?(html).should be_true
+        File.read(html).should == EXPECTED_HTML_OUTPUT
+
+        junk = File.join(tmp, "public/junk.txt")
+        File.exists?(junk).should be_false
+      end
+
+      before do
+        tmp1 = self.tmp1
+        tmp2 = self.tmp2
+
+        @project = Rake::Pipeline::Project.build do
+          tmpdir "temporary"
+          output "public"
+
+          inputs [File.join(tmp1, "app"), File.join(tmp2, "app")] do
+            match "**/*.js" do
+              filter strip_asserts_filter
+              concat "javascripts/application.js"
+            end
+
+            match "**/*.css" do
+              concat "stylesheets/application.css"
+            end
+
+            match "**/*.html" do
+              concat
+            end
           end
         end
       end