benoit 0.1.0

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

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe Rake::Pipeline::DynamicFileTask do
+  let(:invoked_tasks) { [] }
+
+  def define_task(deps, klass=Rake::Pipeline::DynamicFileTask, &task_proc)
+    task_proc ||= proc do |task|
+      touch(task.name)
+      invoked_tasks << task
+    end
+
+    task = klass.define_task(deps, &task_proc)
+
+    if klass == Rake::Pipeline::DynamicFileTask 
+      task.manifest = Rake::Pipeline::Manifest.new
+    end
+
+    task
+  end
+
+  let(:task) { define_task('output') }
+
+  after do
+    # Clean out all defined tasks after each test runs
+    Rake.application = Rake::Application.new
+  end
+
+  describe "#dynamic" do
+    it "saves a block that can be called later with #invoke_dynamic_block" do
+      block = proc {}
+      task.dynamic(&block)
+      block.should_receive(:call).with(task)
+      task.invoke_dynamic_block
+    end
+
+    it "returns the task" do
+      (task.dynamic {}).should eq(task)
+    end
+  end
+
+  describe "#invoke" do
+    let(:static) { define_task('static', Rake::FileTask) }
+    let!(:dynamic) { define_task('dynamic', Rake::FileTask) }
+    let!(:dynamic_task) { define_task('output' => static).dynamic { ['dynamic'] } }
+
+    it "invokes the task's static and dynamic prerequisites" do
+      dynamic_task.invoke
+      invoked_tasks.should include(static)
+      invoked_tasks.should include(dynamic)
+    end
+
+    it "adds dynamic dependencies to its manifest entry" do
+      dynamic_task.invoke
+      dynamic_task.manifest_entry.deps.should == {
+        'dynamic' => File.mtime('dynamic').to_i
+      }
+    end
+
+    it "adds the current task's mtime to its manifest entry" do
+      dynamic_task.invoke
+      dynamic_task.manifest_entry.mtime.should == File.mtime('output').to_i
+    end
+
+    it "raises an error when there is no manifest" do
+      dynamic_task.manifest = nil
+      lambda { 
+        dynamic_task.invoke
+      }.should raise_error(Rake::Pipeline::DynamicFileTask::ManifestRequired)
+    end
+  end
+
+  describe "#needed?" do
+    it "is true if the task has manifest entry" do
+      task.manifest_entry.should be_nil
+      task.should be_needed
+    end
+  end
+
+  describe "#dynamic_prerequisites" do
+    def make_file(name, mtime=nil)
+      touch(name)
+      if mtime
+        File.utime(mtime, mtime, name)
+      end
+    end
+
+    it "returns an empty array if the task has no dynamic block" do
+      task.dynamic_prerequisites.should == []
+    end
+
+    it "returns the result of invoking the dynamic block" do
+      task.dynamic { %w[blinky] }
+      task.dynamic_prerequisites.should == %w[blinky]
+    end
+
+    it "filters the task itself from the list" do
+      task.dynamic { %w[output blinky] }
+      task.dynamic_prerequisites.should == %w[blinky]
+    end
+
+    it "loads dependency information from the manifest first" do
+      time = Time.utc(2000)
+      %w[blinky output].each { |f| make_file f, time }
+
+      manifest_entry = Rake::Pipeline::ManifestEntry.from_hash({
+        "deps" => {
+          "blinky" => time.to_i
+        },
+        "mtime" => time.to_i
+      })
+
+      task.dynamic { %w[] }
+      task.stub(:last_manifest_entry) { manifest_entry }
+      task.should_not_receive(:invoke_dynamic_block)
+      task.dynamic_prerequisites.should == %w[blinky]
+    end
+  end
+
+end

data/vendor/rake-pipeline/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(:project) { Rake::Pipeline::Project.new }
+
+    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 :project => project do
+        output "public"
+        input "#{tmp}/app/javascripts/", "*.js"
+        concat "javascripts/application.js"
+        filter Filters::StripAssertsFilter
+      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 :project => project do
+          output "public"
+          input "#{tmp}/app/javascripts/", "*.js"
+          concat "javascripts/application.js"
+        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/vendor/rake-pipeline/spec/file_wrapper_spec.rb

@@ -0,0 +1,132 @@
+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
+
+  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
+
+  describe "#in_directory?" do
+    it "is when the full path starts with the directory" do
+      file.should be_in_directory(file.root)
+    end
+
+    it "is not when full path does not start with the directory" do
+      file.should_not be_in_directory("/foo/bar/baz")
+    end
+  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/vendor/rake-pipeline/spec/filter_spec.rb

@@ -0,0 +1,367 @@
+describe "Rake::Pipeline::Filter" do
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+
+  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
+
+  def output_file(path, file_root=output_root)
+    Rake::Pipeline::FileWrapper.new(file_root, path)
+  end
+
+  let(:project) { Rake::Pipeline::Project.new }
+  let(:pipeline) { project.build_pipeline "app" }
+
+  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 ember.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
+
+  it "knows about its containing pipeline" do
+    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
+      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 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
+      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.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("ember.js")]
+    end
+
+    describe "tracking original inputs" do
+
+      before do
+        output_name_generator = proc { |input| "application.js" }
+        filter.output_name_generator = output_name_generator
+        pipeline.add_filter(filter)
+      end
+
+      let(:original_inputs) {
+        input_files.map do |input|
+          new_path_name = input.path.gsub(/\.js/, "") + "-dev.js"
+          input.original_inputs = [input_file(new_path_name)]
+        end.flatten
+      }
+
+      it "keeps inputs' original file names" do
+        expected = filter.output_files.map{ |o| o.original_inputs.to_a }.flatten
+        expected.should == input_files.to_a
+      end
+
+      it "takes original inputs from inputs if available" do
+        filter.input_files = original_inputs
+        expected = filter.output_files.map{ |o| o.original_inputs.to_a }.flatten
+        expected.should == original_inputs.to_a
+      end
+
+      it "doesn't repeat inputs if called more than once" do
+        filter.input_files = original_inputs
+        filter.output_files
+        filter.output_files.map{|o| o.original_inputs.to_a }.flatten.should == original_inputs.to_a
+      end
+
+    end
+
+  end
+
+  describe "generates rake tasks" do
+    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)
+        end
+      end
+    }
+    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 ember.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
+      filter.pipeline = pipeline
+    end
+
+    def output_task(path, app=Rake.application)
+      app.define_task(Rake::Pipeline::DynamicFileTask, File.join(output_root, path))
+    end
+
+    def input_task(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
+      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.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
+
+      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/ember.js"
+          inputs.should == [input_file("javascripts/ember.js")]
+          output.should == output_file("javascripts/ember.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/ember.js")].sort
+
+      tasks.sort[0].prerequisites.should == [
+        File.join(input_root, "javascripts/ember.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.pipeline = pipeline
+      filter.last_manifest = MemoryManifest.new
+      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 main file when it changes" do
+      invoke_filter(filter)
+      sleep 1
+      File.open(main.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]
+    end
+
+    it "rebuilds the main file when a dynamic dependency changes" do
+      invoke_filter(filter)
+      sleep 1
+      $LATCH = true
+      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
+