benoit 0.1.0

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

@@ -0,0 +1,42 @@
+describe "OrderingConcatFilter" do
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+
+  let(:input_files) {
+    [
+      MemoryFileWrapper.new("/path/to/input", "first.txt", "UTF-8", [], "FIRST"),
+      MemoryFileWrapper.new("/path/to/input", "second.txt", "UTF-8", [], "SECOND"),
+      MemoryFileWrapper.new("/path/to/input", "last.txt", "UTF-8", [], "LAST")
+    ]
+  }
+
+  let(:output_files) {
+    [
+      MemoryFileWrapper.new("/path/to/output", "all.txt", "BINARY", [], "FIRSTSECONDLAST")
+    ]
+  }
+
+  let(:output_file) {
+    MemoryFileWrapper.files["/path/to/output/all.txt"]
+  }
+
+  def make_filter(ordering)
+    filter = Rake::Pipeline::OrderingConcatFilter.new(ordering, "all.txt")
+    filter.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.input_files = input_files
+    filter.output_root = "/path/to/output"
+    filter.rake_application = Rake::Application.new
+    filter.generate_rake_tasks.each(&:invoke)
+    filter
+  end
+
+  it "generates output" do
+    filter = make_filter(["first.txt", "second.txt"])
+
+    filter.output_files.should == output_files
+    output_file.body.should == "FIRSTSECONDLAST"
+    output_file.encoding.should == "BINARY"
+  end
+end

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

@@ -0,0 +1,232 @@
+describe "Rake::Pipeline" do
+  ConcatFilter ||= Rake::Pipeline::SpecHelpers::Filters::ConcatFilter
+  StripAssertsFilter ||= Rake::Pipeline::SpecHelpers::Filters::StripAssertsFilter
+
+  let(:project) { Rake::Pipeline::Project.new }
+  let(:pipeline) { Rake::Pipeline.new :project => project }
+
+  it "accepts a input root" do
+    pipeline.add_input "app/assets"
+    pipeline.inputs["app/assets"].should == '**/*'
+  end
+
+  it "raises an exception on #relative_input_files if input_files are not provided" do
+    lambda { pipeline.input_files }.should raise_error(Rake::Pipeline::Error)
+  end
+
+  it "accepts a temporary directory" do
+    pipeline.tmpdir = "tmp"
+    pipeline.tmpdir.should == File.expand_path("tmp")
+  end
+
+  it "accepts an output directory" do
+    pipeline.output_root = "public"
+    pipeline.output_root.should == File.expand_path("public")
+  end
+
+  it "accepts a rake application" do
+    app = Rake::Application.new
+    pipeline.rake_application = app
+    pipeline.rake_application.should == app
+  end
+
+  it "defaults the rake application to Rake.application" do
+    pipeline.rake_application.should == Rake.application
+  end
+
+  describe ".build" do
+    it "evaluates a block against a new Pipeline" do
+      pipeline = Rake::Pipeline.build do
+        output "octopus"
+      end
+      pipeline.should be_kind_of(Rake::Pipeline)
+      pipeline.output_root.should == File.expand_path("octopus")
+    end
+  end
+
+  describe "#build" do
+    it "evaluates a block against an existing Pipeline" do
+      pipeline = Rake::Pipeline.new
+      pipeline.output_root = "octopus"
+
+      pipeline.build do
+        output "squid"
+      end
+      pipeline.output_root.should == File.expand_path("squid")
+    end
+  end
+
+  describe "the constructor" do
+    it "accepts an :inputs option" do
+      pipeline = Rake::Pipeline.new(:inputs => {"app/assets" => "**/*"})
+      pipeline.inputs.should == {"app/assets" => "**/*"}
+    end
+
+    it "accepts a :tmpdir option" do
+      pipeline = Rake::Pipeline.new(:tmpdir => "tmp")
+      pipeline.tmpdir.should == "tmp"
+    end
+
+    it "accepts an :output_root option" do
+      pipeline = Rake::Pipeline.new(:output_root => "public")
+      pipeline.output_root.should == File.expand_path("public")
+    end
+
+    it "accepts a :rake_application option" do
+      app = Rake::Application.new
+      pipeline = Rake::Pipeline.new(:rake_application => app)
+      pipeline.rake_application.should == app
+    end
+  end
+
+  describe "adding filters" do
+    let(:filter) { ConcatFilter.new }
+
+    it "can have filters added to it" do
+      pipeline.add_filter filter
+    end
+
+    it "sets an added filter's rake_application" do
+      app = Rake::Application.new
+      pipeline.rake_application = app
+      pipeline.add_filter filter
+      filter.rake_application.should == app
+    end
+
+    it "sets an added filter's pipeline" do
+      pipeline.add_filter filter
+      filter.pipeline.should == pipeline
+    end
+  end
+
+  describe "#copy" do
+    it "should copy state" do
+      copy = pipeline.copy
+      copy.inputs.should == pipeline.inputs
+      copy.tmpdir.should == pipeline.tmpdir
+      copy.rake_application.should == pipeline.rake_application
+      copy.project.should == pipeline.project
+    end
+  end
+
+  shared_examples_for "when working with input" do
+    include Rake::Pipeline::SpecHelpers::InputHelpers
+
+    let(:files) do
+      %w(javascripts/jquery.js javascripts/sproutcore.js).map do |filename|
+        input_file(filename)
+      end
+    end
+
+    def setup_roots
+      pipeline.add_input "app/assets"
+    end
+
+    before do
+      Rake.application = Rake::Application.new
+      create_files(files)
+      setup_roots
+      setup_input(pipeline)
+      pipeline.output_root = "public"
+    end
+
+    it "accepts a list of relative input files" do
+      pipeline.input_files.should == files
+    end
+
+    it "configures the filters with outputs and inputs with #rake_tasks" do
+      concat = ConcatFilter.new
+      concat.output_name_generator = proc { |input| "javascripts/application.js" }
+
+      strip_asserts = StripAssertsFilter.new
+      strip_asserts.output_name_generator = proc { |input| input }
+
+      pipeline.add_filters concat, strip_asserts
+      pipeline.setup
+
+      concat.input_files.should == pipeline.input_files
+      strip_asserts.input_files.each { |file| file.root.should == concat.output_root }
+
+      strip_asserts.input_files.should == [input_file("javascripts/application.js", concat.output_root)]
+      strip_asserts.output_root.should == File.expand_path(pipeline.output_root)
+    end
+
+    describe "generating rake tasks" do
+      tasks = nil
+
+      before do
+        concat = ConcatFilter.new
+        concat.output_name_generator = proc { |input| "javascripts/application.js" }
+        pipeline.add_filter concat
+      end
+
+      it "generates rake tasks in Rake.application" do
+        pipeline.setup
+        tasks = pipeline.rake_tasks
+
+        tasks.size.should == 1
+        task = tasks[0]
+        task.name.should == File.join(pipeline.output_root, "javascripts/application.js")
+
+        deps = task.prerequisites
+        deps.size.should == 2
+
+        root = File.expand_path(pipeline.inputs.keys.first)
+
+        deps[0].should == File.join(root, "javascripts/jquery.js")
+        deps[1].should == File.join(root, "javascripts/sproutcore.js")
+
+        Rake.application.tasks.size.should == 3
+      end
+
+      it "generates rake tasks is an alternate Rake::Application" do
+        app = Rake::Application.new
+        pipeline.rake_application = app
+        pipeline.setup
+        tasks = pipeline.rake_tasks
+
+        Rake.application.tasks.size.should == 0
+      end
+    end
+  end
+
+  describe "when using multiple input roots" do
+    it_behaves_like "when working with input"
+
+    def setup_roots
+      pipeline.add_input File.join(tmp, 'tmp1', "app/assets"), '**/*.js'
+      pipeline.add_input File.join(tmp, 'tmp2', "app/assets"), '**/*.css'
+    end
+
+    def setup_input(pipeline)
+    end
+
+    let(:files) do
+      f = []
+
+      %w(javascripts/jquery.js javascripts/sproutcore.js).map do |filename|
+        f << input_file(filename, File.join(tmp, 'tmp1', "app/assets"))
+      end
+
+      %w(stylesheets/jquery.css stylesheets/sproutcore.css).map do |filename|
+        f << input_file(filename, File.join(tmp, 'tmp2', "app/assets"))
+      end
+
+      f
+    end
+  end
+
+  describe "using an array for input files" do
+    it_behaves_like "when working with input"
+
+    def setup_input(pipeline)
+      Dir.chdir("app/assets") do
+        files = Dir["javascripts/**/*.js"].sort
+        wrappers = files.map do |file|
+          Rake::Pipeline::FileWrapper.new(File.join(tmp, "app/assets"), file)
+        end
+        pipeline.input_files = wrappers
+      end
+    end
+  end
+end

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

@@ -0,0 +1,295 @@
+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
+    def modify_assetfile
+      File.open(assetfile_path, 'w') do |file|
+        file.write(MODIFIED_ASSETFILE_SOURCE)
+      end
+    end
+
+    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
+
+    it "updates the manifest" do
+      project.last_manifest.should_receive(:read_manifest)
+      project.manifest.should_receive(:write_manifest)
+      project.invoke
+    end
+
+    it "rebuilds its pipeline when the Assetfile changes" do
+      project.invoke
+      original_pipeline = project.pipelines.last
+      original_assetfile_digest = assetfile_digest
+
+      modify_assetfile
+      project.invoke
+      assetfile_digest.should_not == original_assetfile_digest
+      project.pipelines.last.should_not == original_pipeline
+    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 "#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