rake-pipeline 0.5.0

data/spec/encoding_spec.rb

@@ -0,0 +1,106 @@
+# encoding: UTF-8
+
+if "".respond_to?(:encode)
+  class String
+    def strip_heredoc
+      indent = scan(/^[ \t]*(?=\S)/).min
+      indent = indent ? indent.size : 0
+      gsub(/^[ \t]{#{indent}}/, '')
+    end
+  end
+
+  inputs = {
+    "app/javascripts/jquery.js" => <<-HERE.strip_heredoc,
+      var jQuery = { japanese: "こんにちは" };
+    HERE
+
+    "app/javascripts/sproutcore.js" => <<-HERE.strip_heredoc,
+      var SC = {};
+      assert(SC);
+      SC.hi = function() { console.log("こんにちは"); };
+    HERE
+  }
+
+  expected_output = <<-HERE.strip_heredoc
+    var jQuery = { japanese: "こんにちは" };
+    var SC = {};
+
+    SC.hi = function() { console.log("こんにちは"); };
+  HERE
+
+  describe "the pipeline's encoding handling" do
+    Filters = Rake::Pipeline::SpecHelpers::Filters
+
+    let(:inputs) { inputs }
+
+    def output_should_exist(expected, encoding="UTF-8")
+      output = File.join(tmp, "public/javascripts/application.js")
+
+      File.exists?(output).should be_true
+      output = File.read(output, :encoding => encoding)
+      output.should == expected
+      output.should be_valid_encoding
+    end
+
+    def create_files
+      inputs.each do |name, contents|
+        filename = File.join(tmp, name)
+        mkdir_p File.dirname(filename)
+
+        File.open(filename, "w:#{encoding}") do |file|
+          file.write contents.encode(encoding)
+        end
+      end
+    end
+
+    before do
+      create_files
+
+      @pipeline = Rake::Pipeline.build do
+        tmpdir "temporary"
+        input tmp, "app/javascripts/*.js"
+        filter Filters::ConcatFilter, "javascripts/application.js"
+        filter Filters::StripAssertsFilter
+        output "public"
+      end
+    end
+
+    describe "when the input is UTF-8" do
+      let(:encoding) { "UTF-8" }
+
+      it "creates the correct file" do
+        @pipeline.invoke
+        output_should_exist(expected_output)
+      end
+    end
+
+    describe "when the input is not UTF-8" do
+      let(:encoding) { "EUC-JP" }
+
+      it "raises an exception" do
+        lambda { @pipeline.invoke }.should raise_error(Rake::Pipeline::EncodingError, /not valid UTF-8/)
+      end
+    end
+
+    describe "when dealing with only BINARY-type filters" do
+      let(:encoding) { "EUC-JP" }
+
+      it "does not raise an exception" do
+        pipeline = Rake::Pipeline.build do
+          tmpdir "temporary"
+          input tmp, "app/javascripts/*.js"
+          filter Filters::ConcatFilter, "javascripts/application.js"
+          output "public"
+        end
+
+        pipeline.invoke
+
+        expected = inputs.map do |filename, contents|
+          contents.encode("EUC-JP")
+        end.join
+
+        output_should_exist(expected.force_encoding("BINARY"), "BINARY")
+      end
+    end
+  end
+end

data/spec/file_wrapper_spec.rb

@@ -0,0 +1,105 @@
+describe "Rake::Pipeline::FileWrapper" do
+  let(:file)   { Rake::Pipeline::FileWrapper.new }
+  let(:root)   { File.expand_path("app/assets") }
+  let(:jquery) { File.join(root, "javascripts/jquery.js") }
+
+  before do
+    file.root = root
+    file.path = "javascripts/jquery.js"
+  end
+
+  it "is equal to another FileWrapper if the root and path are the same" do
+    other = Rake::Pipeline::FileWrapper.new
+    other.root = root
+    other.path = "javascripts/jquery.js"
+
+    file.should == other
+    file.hash.should == other.hash
+  end
+
+  it "is not equal to another FileWrapper if the root is the same but the path is different" do
+    other = Rake::Pipeline::FileWrapper.new
+    other.root = root
+    other.path = "javascripts/jquery2.js"
+
+    file.should_not == other
+  end
+
+  it "is not equal to another FileWrapper if the root is different but the path is the same" do
+    other = Rake::Pipeline::FileWrapper.new
+    other.root = "/"
+    other.path = "javascripts/jquery.js"
+
+    file.should_not == other
+  end
+
+  it "has a fullpath" do
+    file.fullpath.should == jquery
+  end
+
+  it "it knows it doesn't exist when the file doesn't exist" do
+    file.exists?.should == false
+  end
+
+  it "knows it exists when the file exists" do
+    touch_p jquery
+    file.exists?.should == true
+  end
+
+  it "raises an exception if trying to #read a file that doesn't exist" do
+    lambda { file.read }.should raise_error(Errno::ENOENT)
+  end
+
+  it "returns the file's body when invoking #read on a file that does exist" do
+    touch_p jquery
+    body = "This. Is. jQuery!"
+    File.open(jquery, "w") { |file| file.write body }
+
+    file.read.should == body
+  end
+
+  it "creates a file with #create" do
+    new_file = file.create
+    new_file.should be_kind_of File
+
+    File.exists?(jquery).should == true
+
+    new_file.close
+  end
+
+  it "complains if trying to close an unopened file" do
+    lambda { file.close }.should raise_error(IOError)
+  end
+
+  it "closes a file created using #create with #close" do
+    new_file = file.create
+    new_file.closed?.should == false
+
+    file.close
+    new_file.closed?.should == true
+
+    lambda { file.close }.should raise_error(IOError)
+  end
+
+  it "complains if trying to write to a file that was not created" do
+    lambda { file.write "This. Is. jQuery" }.should raise_error(Rake::Pipeline::UnopenedFile)
+  end
+
+  it "supports a block form of create that closes the file at the end" do
+    file.create do |f|
+      f.write "HI"
+    end
+
+    File.exists?(jquery).should == true
+    File.read(jquery).should == "HI"
+    file.closed?.should == true
+  end
+
+  it "writes to the file system if the file was created" do
+    new_file = file.create
+    file.write "This. Is. jQuery"
+    new_file.close
+
+    file.read.should == "This. Is. jQuery"
+  end
+end

data/spec/filter_spec.rb

@@ -0,0 +1,216 @@
+describe "Rake::Pipeline::Filter" do
+  def input_file(path, file_root=input_root)
+    Rake::Pipeline::FileWrapper.new(file_root, path)
+  end
+
+  def output_file(path, file_root=output_root)
+    Rake::Pipeline::FileWrapper.new(file_root, path)
+  end
+
+  let(:filter)      { Rake::Pipeline::Filter.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 { |f| input_file(f) }
+  end
+
+  it "accepts a series of FileWrapper objects for the input" do
+    filter.input_files = input_files
+    filter.input_files.should == input_files
+  end
+
+  it "accepts a root directory for the outputs" do
+    path = File.expand_path(tmp, "filter1/app/assets")
+    filter.output_root = path
+    filter.output_root.should == path
+  end
+
+  it "accepts a Rake::Application to install tasks into" do
+    app = Rake::Application.new
+    filter.rake_application = app
+    filter.rake_application.should == app
+  end
+
+  it "makes Rake.application the default rake_application" do
+    filter.rake_application.should == Rake.application
+  end
+
+  it "accepts a proc to convert the input name into an output name" do
+    conversion = proc { |input| input }
+    filter.output_name_generator = conversion
+    filter.output_name_generator.should == conversion
+  end
+
+  it "accepts a block constructor argument to convert the input name into an output name" do
+    conversion = proc { |input| "application.js" }
+    new_filter = Rake::Pipeline::Filter.new(&conversion)
+    new_filter.output_name_generator.should == conversion
+  end
+
+  describe "using the output_name proc to converting the input names into a hash" do
+    before do
+      filter.output_root = output_root
+      filter.input_files = input_files
+    end
+
+    it "with a simple output_name proc that outputs to a single file" do
+      output_name_generator = proc { |input| "application.js" }
+      filter.output_name_generator = output_name_generator
+
+      filter.outputs.should == {
+        output_file("application.js") => input_files
+      }
+
+      filter.output_files.should == [output_file("application.js")]
+    end
+
+    it "with a 1:1 output_name proc" do
+      output_name_generator = proc { |input| input }
+      filter.output_name_generator = output_name_generator
+      outputs = filter.outputs
+
+      outputs.keys.sort.should == input_files.map { |f| output_file(f.path) }.sort
+      outputs.values.flatten.sort.should == input_files.sort
+
+      filter.output_files.should == input_files.map { |file| output_file(file.path) }
+    end
+
+    it "with a more complicated proc" do
+      output_name_generator = proc { |input| input.split(/[-.]/, 2).first + ".js" }
+      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")]]
+
+      filter.output_files.should == [output_file("jquery.js"), output_file("sproutcore.js")]
+    end
+  end
+
+  describe "generates rake tasks" do
+    class TestFilter < Rake::Pipeline::Filter
+      attr_accessor :generate_output_block
+
+      def generate_output(inputs, output)
+        generate_output_block.call(inputs, output)
+      end
+    end
+
+    let(:filter)      { TestFilter.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|
+        input_file("javascripts/#{file}")
+      end
+    end
+
+    before do
+      Rake.application = Rake::Application.new
+      filter.output_root = output_root
+      filter.input_files = input_files
+    end
+
+    def output_task(path, app=Rake.application)
+      app.define_task(Rake::FileTask, File.join(output_root, path))
+    end
+
+    def input_task(path)
+      Rake::FileTask.define_task(File.join(input_root, path))
+    end
+
+    it "does not generate Rake tasks onto Rake.application if an alternate application is supplied" do
+      app = Rake::Application.new
+      filter.rake_application = app
+      filter.output_name_generator = proc { |input| input }
+      filter.generate_rake_tasks
+      tasks = filter.rake_tasks
+
+      input_files.each do |file|
+        task = output_task(file.path, app)
+        tasks.include?(task).should == true
+        Rake.application.tasks.include?(task).should == false
+        app.tasks.include?(task).should == true
+      end
+    end
+
+    it "with a simple output_name proc that outputs to a single file" do
+      filter_runs = 0
+
+      filter.output_name_generator = proc { |input| "javascripts/application.js" }
+      filter.generate_output_block = proc do |inputs, output|
+        inputs.should == input_files
+        output.should == output_file("javascripts/application.js")
+
+        filter_runs += 1
+      end
+
+      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 a 1:1 output_name proc" do
+      filter_runs = 0
+
+      filter.output_name_generator = proc { |input| input }
+      filter.generate_output_block = proc do |inputs, output|
+        inputs.should == [input_file(output.path)]
+
+        filter_runs += 1
+      end
+
+      filter.generate_rake_tasks
+      tasks = filter.rake_tasks
+      tasks.sort.should == input_files.map { |file| output_task(file.path) }.sort
+      tasks.each do |task|
+        name = task.name.sub(/^#{Regexp.escape(output_root)}/, '')
+        prereq = File.join(input_root, name)
+        task.prerequisites.should == [prereq]
+      end
+
+      tasks.each(&:invoke)
+
+      filter_runs.should == 3
+    end
+
+    it "with a more complicated proc" do
+      filter_runs = 0
+
+      filter.output_name_generator = proc { |input| input.match(%r{javascripts/[^-.]*})[0] + ".js" }
+      filter.generate_output_block = proc do |inputs, output|
+        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")
+        else
+          flunk
+        end
+
+        filter_runs += 1
+      end
+
+      filter.generate_rake_tasks
+      tasks = filter.rake_tasks
+      tasks.sort.should == [output_task("javascripts/jquery.js"), output_task("javascripts/sproutcore.js")].sort
+
+      tasks.sort[0].prerequisites.should == [
+        File.join(input_root, "javascripts/jquery.js"),
+        File.join(input_root, "javascripts/jquery-ui.js")
+      ]
+
+      tasks.sort[1].prerequisites.should == [File.join(input_root, "javascripts/sproutcore.js")]
+
+      tasks.each(&:invoke)
+
+      filter_runs.should == 2
+    end
+  end
+end

data/spec/matcher_spec.rb

@@ -0,0 +1,105 @@
+describe "a matcher" do
+  sep = File::SEPARATOR
+
+  before do
+    @matcher = Rake::Pipeline::Matcher.new
+    @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 "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")
+
+    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")
+    ]
+
+    should_match_glob "proutcore*.js", [
+      file_wrapper("jquery.js"),
+      file_wrapper("sproutcore.js"),
+      file_wrapper("sproutcore.css"),
+      file_wrapper("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
+end