rake-pipeline 0.5.0 → 0.7.0

data/lib/rake-pipeline/railtie.rb

@@ -2,14 +2,29 @@ require "rake-pipeline/middleware"
 
 module Rake
   class Pipeline
+    # Use Rake::Pipeline inside of Rails 3.x. To use, simply add
+    # Rake::Pipeline to your +Gemfile+:
+    #
+    #   !!!ruby
+    #   gem 'rake-pipeline'
+    #
+    # Then, activate it in development mode. In config/development.rb:
+    #
+    #   !!!ruby
+    #   config.rake_pipeline_enabled = true
+    #
     class Railtie < ::Rails::Railtie
       config.rake_pipeline_enabled = false
       config.rake_pipeline_assetfile = 'Assetfile'
 
+      rake_tasks do
+        load "rake-pipeline/precompile.rake"
+      end
+
       initializer "rake-pipeline.assetfile" do |app|
         if config.rake_pipeline_enabled
           assetfile = File.join(Rails.root, config.rake_pipeline_assetfile)
-          config.app_middleware.use(Rake::Pipeline::Middleware, assetfile)
+          config.app_middleware.insert ActionDispatch::Static, Rake::Pipeline::Middleware, assetfile
         end
       end
     end

data/lib/rake-pipeline/server.rb

@@ -0,0 +1,15 @@
+require "rake-pipeline/middleware"
+require "rack/server"
+
+module Rake
+  class Pipeline
+    class Server < Rack::Server
+      def app
+        not_found = proc { [404, { "Content-Type" => "text/plain" }, ["not found"]] }
+        config = "Assetfile"
+
+        Middleware.new(not_found, config)
+      end
+    end
+  end
+end

data/lib/rake-pipeline/version.rb

@@ -1,6 +1,6 @@
 module Rake
   class Pipeline
-    # @version 0.5.0
-    VERSION = "0.5.0"
+    # @version 0.7.0
+    VERSION = "0.7.0"
   end
 end

data/rake-pipeline.gemspec

@@ -16,6 +16,8 @@ Gem::Specification.new do |gem|
   gem.version       = Rake::Pipeline::VERSION
 
   gem.add_dependency "rake", "~> 0.9.0"
+  gem.add_dependency "thor"
+  gem.add_dependency "json"
 
   gem.add_development_dependency "rspec"
   gem.add_development_dependency "rack-test"

data/spec/cli_spec.rb

@@ -0,0 +1,71 @@
+describe "Rake::Pipeline::CLI" do
+  attr_reader :project, :pipeline
+
+  before do
+    @project = Rake::Pipeline::Project.new
+    @project.stub(:clean)
+    @project.stub(:invoke)
+    @project.stub(:output_files).and_return([])
+    Rake::Pipeline::Project.stub(:new).and_return(@project)
+  end
+
+  def rakep(*args)
+    Rake::Pipeline::CLI.start(args)
+  end
+
+  describe "build" do
+    context "with no arguments" do
+      it "invokes a project" do
+        project.should_receive :invoke
+        rakep "build"
+      end
+
+      it "cleans up the tmpdir" do
+        project.should_receive :cleanup_tmpdir
+        rakep "build"
+      end
+    end
+
+    context "with a --pretend argument" do
+      it "doesn't invoke a project" do
+        project.should_not_receive :invoke
+        rakep "build", "--pretend"
+      end
+    end
+
+    context "with a --clean argument" do
+      it "cleans a project" do
+        project.should_receive :clean
+        rakep "build", "--clean"
+      end
+
+      it "invokes a project" do
+        project.should_receive :invoke
+        rakep "build", "--clean"
+      end
+    end
+  end
+
+  describe "clean" do
+    context "with no arguments" do
+      it "cleans a project" do
+        project.should_receive :clean
+        rakep "clean"
+      end
+    end
+  end
+
+  describe "server" do
+    let(:server) { double "server" }
+
+    before do
+      require 'rake-pipeline/server'
+      Rake::Pipeline::Server.stub(:new).and_return(server)
+    end
+
+    it "starts a Rake::Pipeline::Server" do
+      server.should_receive :start
+      rakep "server"
+    end
+  end
+end

data/spec/concat_filter_spec.rb

@@ -1,31 +1,5 @@
 describe "ConcatFilter" do
-  class MemoryFileWrapper < Struct.new(:root, :path, :encoding, :body)
-    @@files = {}
-
-    def self.files
-      @@files
-    end
-
-    def with_encoding(new_encoding)
-      self.class.new(root, path, new_encoding, body)
-    end
-
-    def fullpath
-      File.join(root, path)
-    end
-
-    def create
-      @@files[fullpath] = self
-      self.body = ""
-      yield
-    end
-
-    alias read body
-
-    def write(contents)
-      self.body << contents
-    end
-  end
+  MemoryFileWrapper = Rake::Pipeline::SpecHelpers::MemoryFileWrapper
 
   let(:input_files) {
     [

data/spec/{dsl_spec.rb → dsl/pipeline_dsl_spec.rb}

@@ -1,11 +1,11 @@
-describe "Rake::Pipeline::DSL" do
+describe "Rake::Pipeline::PipelineDSL" do
   ConcatFilter = Rake::Pipeline::SpecHelpers::Filters::ConcatFilter
 
   let(:pipeline) { Rake::Pipeline.new }
-  let(:dsl) { Rake::Pipeline::DSL.new(pipeline) }
+  let(:dsl) { Rake::Pipeline::DSL::PipelineDSL.new(pipeline) }
 
-  before do
-    pipeline.input_root = "."
+  def filter
+    pipeline.filters.last
   end
 
   it "accepts a pipeline in its constructor" do
@@ -13,19 +13,19 @@ describe "Rake::Pipeline::DSL" do
   end
 
   describe "#input" do
-    it "configures the pipeline's input_root" do
+    it "adds an input to the pipeline" do
       dsl.input "/app"
-      pipeline.input_root.should == "/app"
+      pipeline.inputs["/app"].should == '**/*'
     end
 
-    it "configures the pipeline's input_glob" do
+    it "configures the input's glob" do
       dsl.input "/app", "*.js"
-      pipeline.input_glob.should == "*.js"
+      pipeline.inputs['/app'].should == "*.js"
     end
 
-    it "defaults the pipeline's input_glob to **/*" do
+    it "defaults input's glob to **/*" do
       dsl.input "/app"
-      pipeline.input_glob.should == "**/*"
+      pipeline.inputs['/app'].should == "**/*"
     end
   end
 
@@ -35,13 +35,13 @@ describe "Rake::Pipeline::DSL" do
       pipeline.filters.should be_empty
       dsl.filter ConcatFilter
       pipeline.filters.should_not be_empty
-      pipeline.filters.last.should be_kind_of(ConcatFilter)
+      filter.should be_kind_of(ConcatFilter)
     end
 
     it "takes a block to configure the filter's output file names" do
       generator = proc { |input| "main.js" }
       dsl.filter(ConcatFilter, &generator)
-      pipeline.filters.last.output_name_generator.should == generator
+      filter.output_name_generator.should == generator
     end
 
     it "passes any extra arguments to the filter's constructor" do
@@ -53,7 +53,7 @@ describe "Rake::Pipeline::DSL" do
       end
 
       dsl.filter filter_class, "foo", "bar"
-      pipeline.filters.last.args.should == %w(foo bar)
+      filter.args.should == %w(foo bar)
     end
   end
 
@@ -66,7 +66,7 @@ describe "Rake::Pipeline::DSL" do
 
     it "adds the new matcher to the pipeline's filters" do
       matcher = dsl.match("*.glob") {}
-      pipeline.filters.last.should == matcher
+      filter.should == matcher
     end
   end
 
@@ -77,10 +77,24 @@ describe "Rake::Pipeline::DSL" do
     end
   end
 
-  describe "#tmpdir" do
-    it "configures the pipeline's tmpdir" do
-      dsl.tmpdir "/temporary"
-      pipeline.tmpdir.should == "/temporary"
+  describe "#concat" do
+    it "creates a ConcatFilter" do
+      dsl.concat "octopus"
+      filter.should be_kind_of(Rake::Pipeline::ConcatFilter)
+    end
+
+    context "passed an Array first argument" do
+      it "creates an OrderingConcatFilter" do
+        dsl.concat ["octopus"]
+        filter.should be_kind_of(Rake::Pipeline::OrderingConcatFilter)
+      end
+    end
+  end
+
+  describe "#copy" do
+    it "creates a ConcatFilter" do
+      dsl.copy
+      filter.should be_kind_of(Rake::Pipeline::ConcatFilter)
     end
   end
 end

data/spec/dsl/project_dsl_spec.rb

@@ -0,0 +1,41 @@
+describe "Rake::Pipeline::ProjectDSL" do
+  ConcatFilter = Rake::Pipeline::SpecHelpers::Filters::ConcatFilter
+
+  let(:project) { Rake::Pipeline::Project.new }
+  let(:dsl) { Rake::Pipeline::DSL::ProjectDSL.new(project) }
+
+  it "accepts a project in its constructor" do
+    dsl.project.should == project
+  end
+
+  describe "#output" do
+    it "configures the project's default_output_root" do
+      dsl.output "/path/to/output"
+      project.default_output_root.should == "/path/to/output"
+    end
+  end
+
+  describe "#tmpdir" do
+    it "sets the project's tmpdir" do
+      dsl.tmpdir "/path/to/tmpdir"
+      project.tmpdir.should == "/path/to/tmpdir"
+    end
+  end
+
+  describe "#input" do
+    it "uses Project#build_pipeline to add a new pipeline to the project" do
+      project.should_receive(:build_pipeline)
+      dsl.input("app") {}
+    end
+  end
+
+  describe "#map" do
+    it "saves the block in a hash on the project" do
+      project.maps.keys.size.should == 0
+      run_me = lambda { }
+      dsl.map("foo", &run_me)
+      dsl.project.maps["foo"].should == run_me
+    end
+  end
+end
+

data/spec/dynamic_file_task_spec.rb

@@ -0,0 +1,111 @@
+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
+
+    klass.define_task(deps, &task_proc)
+  end
+
+  let(:task) { define_task('output') }
+
+  before do
+    # Make sure date conversions happen in UTC, not local time
+    ENV['TZ'] = 'UTC'
+  end
+
+  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')
+      }
+    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')
+    end
+  end
+
+  describe "#needed?" do
+    it "is true if the task has no previous manifest entry" do
+      task.last_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" => "2000-01-01 00:00:00 +0000"
+        },
+        "mtime" => "2000-01-01 00:00:00 +0000"
+      })
+
+      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/spec/encoding_spec.rb

@@ -57,11 +57,10 @@ if "".respond_to?(:encode)
       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"
+        input "#{tmp}/app/javascripts/", "*.js"
+        concat "javascripts/application.js"
+        filter Filters::StripAssertsFilter
       end
     end
 
@@ -86,11 +85,10 @@ if "".respond_to?(:encode)
       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"
+         pipeline = Rake::Pipeline.build do
           output "public"
+          input "#{tmp}/app/javascripts/", "*.js"
+          concat "javascripts/application.js"
         end
 
         pipeline.invoke