local_ci 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6da45961cab3661dd38b4c4c8df3317eb9ddd6b995f6dfa95e5d4083f704c3d1
-  data.tar.gz: a9545621f1d8baaf69730bc631a6f73f8c261e1740613f763348aae2233c2c8e
+  metadata.gz: 83a9843902d865aac3c8a3d995129379db5661f71fbece0537137f45fbed0b7e
+  data.tar.gz: 535d98f227e41f2aba8bbab39ec28b304d89cff2599cc2dc646cb103dc7ee465
 SHA512:
-  metadata.gz: fb9e176666f22257c6ac55dfa8991ed056acd330656312b61d9569c6bd764f0c9caf28064dbfb5252b4e30751c7026c22f5b20577da38b3de5995a3b760fcd1f
-  data.tar.gz: cdced51659d21eb82e050297a9267e8441e563eed6d2277f763c5bc1e5f3c2b530c2ee69cb6f26e24bbc75d2bf45e8a98c9467f475f703ccdc6c3d56516ebc5f
+  metadata.gz: 60376c8a194767876646b90604047e387071f46e77742e6d26ccc5f53ae69e39aa61633511482b4b6a27f2d9ec98a6369862740fcff862e8e030b0a6c16a4f31
+  data.tar.gz: 261ed6fce994c12fc161fa8c8c86bd580fa5c4ae228364e83d786f2b5af2a9e53b75db96b2636956e078417d9b430dbfdbcc3e58f2551e452dbe69aa7a894519

data/.gitignore

@@ -1 +1,2 @@
 *.log
+*.gem

data/Gemfile

@@ -6,5 +6,5 @@ group :development do
 end
 
 group :test do
-  gem "neospec"
+  gem "rspec"
 end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    local_ci (0.0.1)
+    local_ci (0.0.2)
       logger
       pastel
       rake
@@ -12,11 +12,11 @@ GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.3)
-    json (2.16.0)
+    diff-lcs (1.6.2)
+    json (2.17.1)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
     logger (1.7.0)
-    neospec (0.0.1)
     parallel (1.27.0)
     parser (3.3.10.0)
       ast (~> 2.4.1)
@@ -28,6 +28,19 @@ GEM
     rainbow (3.1.1)
     rake (13.3.1)
     regexp_parser (2.11.3)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.7)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.6)
     rubocop (1.81.7)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
@@ -77,7 +90,7 @@ PLATFORMS
 
 DEPENDENCIES
   local_ci!
-  neospec
+  rspec
   standardrb
 
 BUNDLED WITH

data/Rakefile

@@ -1,35 +1,44 @@
+require "standard/rake"
 require "local_ci"
 
-CHUNK = 15
+LocalCI::Rake.setup(self)
 
-desc "Run the CI suite locally"
-task :local_ci
+setup do
+  job "Bundle", "bundle check | bundle install"
+end
 
-LocalCI.flow(:linting, "Linting") do
-  job "StandardRB" do
-    run "bundle exec standardrb"
-  end
+teardown do
+  job "Echo", "echo", "global teardown"
 end
 
-LocalCI.flow(:build, "Build") do
-  CHUNK.times do |i|
-    job "build-#{i}" do
-      run "sleep 1"
-    end
+flow "Linting" do
+  job "StandardRB", "bundle exec rake standard"
+end
+
+flow "Specs" do
+  setup do
+    job "Specs Setup", "echo specs setup"
   end
+
+  teardown do
+    job "Specs Teardown", "echo specs teardown"
+  end
+
+  job "RSpec", "bundle exec rspec"
 end
 
-LocalCI.flow(:lint, "Lint") do
-  CHUNK.times do |i|
-    job "lint-#{i}" do
-      run "sleep 1"
-      run "echo 'hi'"
+flow "Build" do
+  setup do
+    job "Start docker", "echo docker start"
+  end
+
+  Dir.glob("*").each do |file|
+    job "Compile - #{file}" do
+      run "echo", "gcc", file
     end
   end
-end
 
-namespace :standardrb do
-  task :fix do
-    `bundle exec standardrb --fix-unsafely`
+  teardown do
+    job "Stop Docker", "echo docker stop"
   end
 end

data/lib/local_ci/dsl.rb

@@ -0,0 +1,30 @@
+module LocalCI
+  module DSL
+    def setup(heading = "Setup", parallel: false, &block)
+      LocalCI::Flow.new(
+        name: :setup,
+        heading: heading,
+        parallel: parallel,
+        actions: false,
+        block: block
+      )
+    end
+
+    def teardown(heading = "Teardown", parallel: false, &block)
+      LocalCI::Flow.new(
+        name: :teardown,
+        heading: heading,
+        parallel: parallel,
+        actions: false,
+        block: block
+      )
+    end
+
+    def flow(name, heading = nil, parallel: true, &block)
+      heading ||= name
+      name = LocalCI::Helper.taskize(heading) unless name.is_a?(Symbol)
+
+      LocalCI::Flow.new(name: name, heading: heading, parallel: parallel, block: block)
+    end
+  end
+end

data/lib/local_ci/exec_context.rb

@@ -0,0 +1,44 @@
+module LocalCI
+  class ExecContext
+    attr_reader :flow
+
+    def initialize(flow:)
+      @flow = flow
+    end
+
+    def run(command, *args)
+      LocalCI::Helper.runner.run command, *args
+    end
+
+    def job(name, *args, &block)
+      LocalCI::Job.new(
+        flow: @flow,
+        name: name,
+        command: args,
+        block: block
+      )
+    end
+
+    def setup(heading = nil, parallel: false, &block)
+      heading ||= "#{@flow.heading} - Setup"
+      LocalCI::Flow.new(
+        name: "#{@flow.task}:setup",
+        heading: heading,
+        parallel: parallel,
+        actions: false,
+        block: block
+      )
+    end
+
+    def teardown(heading = nil, parallel: false, &block)
+      heading ||= "#{@flow.heading} - Teardown"
+      LocalCI::Flow.new(
+        name: "#{@flow.task}:teardown",
+        heading: heading,
+        parallel: parallel,
+        actions: false,
+        block: block
+      )
+    end
+  end
+end

data/lib/local_ci/failure.rb

@@ -1,16 +1,18 @@
 module LocalCI
   class Failure
-    def pastel = @pastel ||= Pastel.new
+    attr_reader :job
 
     def initialize(job:, message:)
       @job = job
       @message = message
     end
 
-    def display
-      puts "#{pastel.bold.red("FAIL:")} #{@job}"
-      puts @message
-      puts
+    def message
+      <<~STR
+        #{LocalCI::Helper.pastel.bold.red("FAIL:")} #{@job}
+        #{@message}
+
+      STR
     end
   end
 end

data/lib/local_ci/flow.rb

@@ -1,19 +1,19 @@
 module LocalCI
   class Flow
-    attr_reader :heading, :job_spinner
+    attr_accessor :task, :heading, :spinner, :failures
 
-    def pastel = @pastel ||= Pastel.new
-    def runner = @runner ||= TTY::Command.new(output: Logger.new("ci.log"))
-
-    def initialize(task:, heading:, parallel:, block:)
+    def initialize(name:, heading:, parallel:, block:, actions: true)
+      @task = name
+      @task = "ci:#{name}" unless @task.start_with?("ci:")
+      @parallel = parallel
       @failures = []
-      @task = task
       @heading = heading
-      @job_spinner = TTY::Spinner::Multi.new(
-        "[:spinner] #{pastel.bold.blue(heading)}",
+      @actions = actions
+      @spinner = TTY::Spinner::Multi.new(
+        "[:spinner] #{LocalCI::Helper.pastel.bold.blue(@heading)}",
         format: :classic,
-        success_mark: pastel.green("✓"),
-        error_mark: pastel.red("✗"),
+        success_mark: LocalCI::Helper.pastel.green("✓"),
+        error_mark: LocalCI::Helper.pastel.red("✗"),
         style: {
           top: "",
           middle: "    ",
@@ -21,44 +21,80 @@ module LocalCI
         }
       )
 
-      klass = parallel ? Rake::MultiTask : Rake::Task
-      @flow = klass.define_task(task) do
-        @failures.each do |failure|
-          failure.display
-        end
-
-        abort pastel.red("#{@heading} failed, see CI.log for more.") if @failures.any?
+      setup_required_tasks
+      if actions?
+        setup_flow_tasks
+      else
+        setup_actionless_flow_tasks
       end
 
-      @flow.comment = heading
-      Rake::Task[:local_ci].prerequisites << @task
+      after_jobs
 
-      instance_exec(&block)
+      LocalCI::ExecContext.new(flow: self).instance_exec(&block)
     end
 
-    def job(title, &block)
-      task = "#{@task}:#{title}"
-      spinner = job_spinner.register("[:spinner] #{title}")
-
-      Rake::Task.define_task(task) do
-        spinner.auto_spin
-        start = Time.now
-        instance_exec(&block)
-        took = Time.now - start
-        spinner.success("(#{took.round(2)}s)")
-      rescue TTY::Command::ExitError => e
-        spinner.error
-        @failures << LocalCI::Failure.new(
-          job: title,
-          message: e.message
-        )
+    def actions? = !!@actions
+
+    def actionless? = !actions?
+
+    def isolated? = LocalCI::Task["ci"].already_invoked
+
+    private
+
+    def setup_required_tasks
+      ci_task = LocalCI::Task["ci", "Run the CI suite"]
+
+      LocalCI::Task["ci:setup", "Setup the system to run CI"]
+      LocalCI::Task["ci:teardown", "Cleanup after the CI"]
+
+      ci_task.add_prerequisite "ci:setup"
+      ci_task.define do
+        LocalCI::Task["ci:teardown"].invoke
       end
+    end
+
+    def setup_flow_tasks
+      LocalCI::Task["#{@task}:setup"]
 
-      @flow.prerequisites << task
+      LocalCI::Task.new("#{@task}:jobs", parallel_prerequisites: @parallel)
+
+      LocalCI::Task["#{@task}:teardown"]
+      LocalCI::Task["#{@task}:failure_check"]
+      LocalCI::Task[@task, @heading]
+
+      LocalCI::Task["#{@task}:setup"]
+      LocalCI::Task["#{@task}:setup"].add_prerequisite "ci:setup"
+
+      LocalCI::Task[@task].add_prerequisite "#{@task}:teardown"
+      LocalCI::Task["#{@task}:failure_check"].add_prerequisite "#{@task}:teardown"
+      LocalCI::Task["#{@task}:teardown"].add_prerequisite "#{@task}:jobs"
+      LocalCI::Task["#{@task}:jobs"].add_prerequisite "#{@task}:setup"
+
+      LocalCI::Task["ci"].add_prerequisite @task
     end
 
-    def run(command)
-      runner.run command
+    def setup_actionless_flow_tasks
+      LocalCI::Task.new("#{@task}:jobs", parallel_prerequisites: @parallel)
+      LocalCI::Task["#{@task}:failure_check"]
+
+      LocalCI::Task[@task].add_prerequisite "#{@task}:failure_check"
+      LocalCI::Task["#{@task}:failure_check"].add_prerequisite "#{@task}:jobs"
+    end
+
+    def after_jobs
+      LocalCI::Task[@task].define do
+        LocalCI::Task["#{@task}:teardown"].invoke
+        LocalCI::Task["ci:teardown"].invoke unless isolated? || actionless?
+
+        if @failures.any?
+          LocalCI::Task["ci:teardown"].invoke
+          @failures.each do |failure|
+            puts failure.display
+          end
+
+          abort LocalCI::Helper.pastel.red("#{@heading} failed, see CI.log for more.")
+        end
+      end
     end
   end
 end

data/lib/local_ci/helper.rb

@@ -0,0 +1,10 @@
+module LocalCI
+  module Helper
+    def self.pastel = @pastel ||= Pastel.new(enabled: TTY::Color.support?)
+    def self.runner = @runner ||= TTY::Command.new(output: Logger.new("ci.log"))
+
+    def self.taskize(heading)
+      heading.downcase.gsub(/\s/, "_").gsub(/[^\w]/, "").to_sym
+    end
+  end
+end

data/lib/local_ci/job.rb

@@ -0,0 +1,40 @@
+module LocalCI
+  class Job
+    attr_accessor :flow, :name, :command, :block, :task, :spinner
+
+    def initialize(flow:, name:, command:, block:)
+      @flow = flow
+      @name = name
+      @command = command
+      @block = block
+      @task = "#{@flow.task}:jobs:#{LocalCI::Helper.taskize(name)}"
+
+      raise ArgumentError, "Must specify a block or command" unless command || block
+      @spinner = flow.spinner.register("[:spinner] #{name}")
+
+      ::Rake::Task.define_task(task) do
+        @spinner.auto_spin
+        start = Time.now
+
+        if block
+          LocalCI::ExecContext.new(flow: @flow).instance_exec(&block)
+        else
+          LocalCI::Helper.runner.run(*command)
+        end
+
+        took = Time.now - start
+        @spinner.success("(#{took.round(2)}s)")
+      rescue TTY::Command::ExitError => e
+        spinner.error
+        @flow.failures << LocalCI::Failure.new(
+          job: @name,
+          message: e.message
+        )
+      end
+
+      ::Rake::Task["#{@flow.task}:jobs"].prerequisites << task
+
+      ::Rake::Task[task].prerequisites << "#{@flow.task}:setup" if @flow.actions?
+    end
+  end
+end

data/lib/local_ci/rake.rb

@@ -0,0 +1,7 @@
+module LocalCI
+  module Rake
+    def self.setup(klass)
+      klass.send(:include, LocalCI::DSL)
+    end
+  end
+end

data/lib/local_ci/task.rb

@@ -0,0 +1,37 @@
+module LocalCI
+  class Task
+    extend Forwardable
+
+    def self.[](task, comment = nil)
+      new(task, comment: comment)
+    end
+
+    attr_accessor :task
+
+    def_delegators :@task, :comment=, :invoke, :already_invoked, :prerequisites
+
+    def initialize(task, comment: nil, parallel_prerequisites: false)
+      @parallel_prerequisites = parallel_prerequisites
+      klass.define_task(task) unless klass.task_defined?(task)
+      @task = klass[task]
+      @task.comment = comment if comment
+    end
+
+    def add_prerequisite(prerequisite)
+      return if prerequisites.include?(prerequisite)
+      prerequisites << prerequisite
+    end
+
+    def define(&block)
+      ::Rake::Task.define_task(@task.to_s) do
+        block.call
+      end
+    end
+
+    private
+
+    def klass
+      @parallel_prerequisites ? ::Rake::MultiTask : ::Rake::Task
+    end
+  end
+end

data/lib/local_ci.rb

@@ -1,13 +1,14 @@
+require "forwardable"
 require "logger"
 require "tty-command"
 require "tty-spinner"
 require "pastel"
 
+require "local_ci/dsl"
+require "local_ci/exec_context"
 require "local_ci/failure"
 require "local_ci/flow"
-
-module LocalCI
-  def self.flow(task, heading, parallel: true, &block)
-    LocalCI::Flow.new(task: task, heading: heading, parallel: parallel, block: block)
-  end
-end
+require "local_ci/helper"
+require "local_ci/job"
+require "local_ci/rake"
+require "local_ci/task"

data/local_ci.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "local_ci"
-  s.version = "0.0.1"
+  s.version = "0.0.2"
   s.summary = "Run CI locally"
   s.description = "A way to run CI locally but also able to run easily on your hosted CI"
   s.authors = ["Sean Earle"]

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require "rspec"
+require "rake"
+
+require "local_ci"
+
+require "support/dsl_klass"
+
+RSpec.configure do |config|
+  config.after(:example) do
+    Rake::Task.clear
+
+    LocalCI::Helper.instance_variable_set(:@pastel, nil)
+    LocalCI::Helper.instance_variable_set(:@runner, nil)
+  end
+end

data/spec/support/dsl_klass.rb

@@ -0,0 +1,5 @@
+module Support
+  class DSLKlass
+    include LocalCI::DSL
+  end
+end

data/spec/unit/local_ci/dsl_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+
+describe LocalCI::DSL do
+  before do
+    @block = -> {}
+  end
+
+  describe ".flow" do
+    it "calls LocalCI::Flow" do
+      expect(LocalCI::Flow).to receive(:new).with(
+        name: :name,
+        heading: "heading",
+        parallel: "parallel",
+        block: @block
+      )
+
+      Support::DSLKlass.new.flow(:name, "heading", parallel: "parallel", &@block)
+    end
+
+    context "when only passed a heading" do
+      it "converts the heading to a sensible name name" do
+        expect(LocalCI::Flow).to receive(:new).with(
+          name: :my_cool_flow,
+          heading: "My Cool Flow!",
+          parallel: true,
+          block: @block
+        )
+
+        Support::DSLKlass.new.flow("My Cool Flow!", &@block)
+      end
+    end
+  end
+
+  describe ".setup" do
+    it "calls LocalCI::Flow" do
+      expect(LocalCI::Flow).to receive(:new).with(
+        name: :setup,
+        heading: "Setup",
+        parallel: "parallel",
+        actions: false,
+        block: @block
+      )
+
+      Support::DSLKlass.new.setup(parallel: "parallel", &@block)
+    end
+
+    it "passes through the heading" do
+      expect(LocalCI::Flow).to receive(:new).with(
+        name: :setup,
+        heading: "My Cool Setup",
+        parallel: "parallel",
+        actions: false,
+        block: @block
+      )
+
+      Support::DSLKlass.new.setup("My Cool Setup", parallel: "parallel", &@block)
+    end
+  end
+
+  describe ".teardown" do
+    it "calls LocalCI::Flow" do
+      expect(LocalCI::Flow).to receive(:new).with(
+        name: :teardown,
+        heading: "Teardown",
+        parallel: "parallel",
+        actions: false,
+        block: @block
+      )
+
+      Support::DSLKlass.new.teardown(parallel: "parallel", &@block)
+    end
+
+    it "passes through the heading" do
+      expect(LocalCI::Flow).to receive(:new).with(
+        name: :teardown,
+        heading: "My Cool Teardown",
+        parallel: "parallel",
+        actions: false,
+        block: @block
+      )
+
+      Support::DSLKlass.new.teardown("My Cool Teardown", parallel: "parallel", &@block)
+    end
+  end
+end

data/spec/unit/local_ci/exec_context_spec.rb

@@ -0,0 +1,106 @@
+require "spec_helper"
+
+describe LocalCI::ExecContext do
+  before do
+    @block = -> {}
+    @flow = double(
+      :flow,
+      task: "flow-task",
+      heading: "flow-heading"
+    )
+    @context = LocalCI::ExecContext.new(flow: @flow)
+  end
+
+  describe "#initialize" do
+    it "assigns the flow" do
+      expect(@context.flow).to eq(@flow)
+    end
+  end
+
+  describe "#run" do
+    it "runs the commands" do
+      expect(LocalCI::Helper.runner).to receive(:run)
+        .with("command", "arg1", "arg2")
+
+      @context.instance_exec {
+        run "command", "arg1", "arg2"
+      }
+    end
+  end
+
+  describe "#setup" do
+    it "creates a new flow" do
+      expect(LocalCI::Flow).to receive(:new)
+        .with(
+          name: "flow-task:setup",
+          heading: "flow-heading - Setup",
+          parallel: false,
+          actions: false,
+          block: @block
+        )
+
+      block = @block
+      @context.instance_exec {
+        setup(&block)
+      }
+    end
+
+    it "passes through heading and parallel" do
+      expect(LocalCI::Flow).to receive(:new)
+        .with(
+          name: "flow-task:setup",
+          heading: "Special Setup",
+          parallel: "parallel",
+          actions: false,
+          block: @block
+        )
+
+      block = @block
+      @context.instance_exec {
+        setup(
+          "Special Setup",
+          parallel: "parallel",
+          &block
+        )
+      }
+    end
+  end
+
+  describe "#teardown" do
+    it "creates a new flow" do
+      expect(LocalCI::Flow).to receive(:new)
+        .with(
+          name: "flow-task:teardown",
+          heading: "flow-heading - Teardown",
+          parallel: false,
+          actions: false,
+          block: @block
+        )
+
+      block = @block
+      @context.instance_exec {
+        teardown(&block)
+      }
+    end
+
+    it "passes through heading and parallel" do
+      expect(LocalCI::Flow).to receive(:new)
+        .with(
+          name: "flow-task:teardown",
+          heading: "Special Teardown",
+          parallel: "parallel",
+          actions: false,
+          block: @block
+        )
+
+      block = @block
+      @context.instance_exec {
+        teardown(
+          "Special Teardown",
+          parallel: "parallel",
+          &block
+        )
+      }
+    end
+  end
+end

data/spec/unit/local_ci/failure_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe LocalCI::Failure do
+  describe "#message" do
+    it "returns information about the failure" do
+      pastel = double(:pastel)
+      expect(LocalCI::Helper).to receive(:pastel).and_return(pastel)
+      expect(pastel).to receive(:bold).and_return(pastel)
+      expect(pastel).to receive(:red).with("FAIL:")
+        .and_return("red")
+
+      failure = LocalCI::Failure.new(
+        job: "job",
+        message: "message"
+      )
+
+      expect(failure.message).to eq(<<~STR)
+        red job
+        message
+
+      STR
+    end
+  end
+end

data/spec/unit/local_ci/flow_spec.rb

@@ -0,0 +1,221 @@
+require "spec_helper"
+
+describe LocalCI::Flow do
+  describe "#initialize" do
+    context "when creating parallel" do
+      it "call Rake::MultiTask" do
+        task = double(:task, prerequisites: [])
+        allow(task).to receive(:comment=)
+        allow(Rake::Task).to receive(:[]).and_return(task)
+        allow(Rake::Task).to receive(:define_task)
+        expect(Rake::MultiTask).to receive(:define_task).with("ci:parallel:jobs")
+
+        LocalCI::Flow.new(
+          name: "parallel",
+          heading: "heading",
+          parallel: true,
+          block: -> {}
+        )
+      end
+    end
+
+    context "when creating sequential" do
+      it "call Rake::Task" do
+        task = double(:task, prerequisites: [])
+        expect(task).to receive(:comment=).at_least(:once)
+        expect(Rake::Task).to receive(:[]).and_return(task).at_least(:once)
+        expect(Rake::Task).to receive(:define_task).with("ci:sequential:jobs").at_least(:once)
+        expect(Rake::Task).to receive(:define_task).at_least(:once)
+
+        LocalCI::Flow.new(
+          name: "sequential",
+          heading: "heading",
+          parallel: false,
+          block: -> {}
+        )
+      end
+    end
+
+    context "when actions is true" do
+      it "creates the expected tasks" do
+        LocalCI::Flow.new(
+          name: "actions",
+          heading: "heading",
+          parallel: true,
+          actions: true,
+          block: -> {}
+        )
+
+        expect(Rake::Task.task_defined?("ci")).to be(true)
+        expect(Rake::Task.task_defined?("ci:setup")).to be(true)
+        expect(Rake::Task.task_defined?("ci:actions")).to be(true)
+        expect(Rake::Task.task_defined?("ci:actions:setup")).to be(true)
+        expect(Rake::Task.task_defined?("ci:actions:jobs")).to be(true)
+        expect(Rake::Task.task_defined?("ci:actions:teardown")).to be(true)
+        expect(Rake::Task.task_defined?("ci:teardown")).to be(true)
+      end
+    end
+
+    context "when actions is false" do
+      it "creates the expected tasks" do
+        LocalCI::Flow.new(
+          name: "actionless",
+          heading: "heading",
+          parallel: true,
+          actions: false,
+          block: -> {}
+        )
+
+        expect(Rake::Task.task_defined?("ci")).to be(true)
+        expect(Rake::Task.task_defined?("ci:setup")).to be(true)
+        expect(Rake::Task.task_defined?("ci:actionless")).to be(true)
+        expect(Rake::Task.task_defined?("ci:actionless:setup")).to be(false)
+        expect(Rake::Task.task_defined?("ci:actionless:jobs")).to be(true)
+        expect(Rake::Task.task_defined?("ci:actionless:teardown")).to be(false)
+        expect(Rake::Task.task_defined?("ci:teardown")).to be(true)
+      end
+    end
+
+    it "gives tasks the right comments" do
+      LocalCI::Flow.new(
+        name: "test",
+        heading: "heading",
+        parallel: true,
+        block: -> {}
+      )
+
+      expect(Rake::Task["ci"].comment).to eq("Run the CI suite")
+      expect(Rake::Task["ci:setup"].comment).to eq("Setup the system to run CI")
+      expect(Rake::Task["ci:teardown"].comment).to eq("Cleanup after the CI")
+      expect(Rake::Task["ci:test"].comment).to eq("heading")
+    end
+
+    it "has the correct prerequisites for all tasks" do
+      LocalCI::Flow.new(
+        name: "test",
+        heading: "heading",
+        parallel: true,
+        block: -> {}
+      )
+
+      expect(Rake::Task["ci"].prerequisites).to eq(["ci:setup", "ci:test"])
+      expect(Rake::Task["ci:test"].prerequisites).to eq(["ci:test:teardown"])
+      expect(Rake::Task["ci:test:teardown"].prerequisites).to eq(["ci:test:jobs"])
+      expect(Rake::Task["ci:test:jobs"].prerequisites).to eq(["ci:test:setup"])
+      expect(Rake::Task["ci:test:setup"].prerequisites).to eq(["ci:setup"])
+    end
+
+    it "calls the expected jobs" do
+      allow(LocalCI::Job).to receive(:new)
+
+      job_1_block = -> {}
+
+      flow = LocalCI::Flow.new(
+        name: "test",
+        heading: "heading",
+        parallel: true,
+        block: -> {
+          job("Job 1", &job_1_block)
+          job("Job 2", "ls", "-la")
+        }
+      )
+
+      expect(LocalCI::Job).to have_received(:new).with(
+        flow: flow,
+        name: "Job 1",
+        command: [],
+        block: job_1_block
+      )
+
+      expect(LocalCI::Job).to have_received(:new).with(
+        flow: flow,
+        name: "Job 2",
+        command: ["ls", "-la"],
+        block: nil
+      )
+    end
+  end
+
+  describe "#after_jobs" do
+    before do
+      @flow = LocalCI::Flow.new(
+        name: "flow",
+        heading: "heading",
+        parallel: true,
+        block: -> {}
+      )
+
+      @ci = double(:ci, already_invoked: false)
+      allow(LocalCI::Task).to receive(:[]).with("ci").and_return(@ci)
+
+      @flow_teardown = double(:flow_teardown)
+      allow(@flow_teardown).to receive(:invoke)
+      allow(LocalCI::Task).to receive(:[]).with("ci:flow:teardown").and_return(@flow_teardown)
+
+      @teardown = double(:teardown)
+      allow(@teardown).to receive(:invoke)
+      allow(LocalCI::Task).to receive(:[]).with("ci:teardown").and_return(@teardown)
+    end
+
+    context "when there are no failures" do
+      it "runs ci:flow:teardown" do
+        expect(@flow_teardown).to receive(:invoke)
+
+        ::Rake::Task["ci:flow"].invoke
+      end
+
+      context "when run in isolation" do
+        it "runs ci:teardown" do
+          expect(@teardown).to receive(:invoke)
+
+          ::Rake::Task["ci:flow"].invoke
+        end
+      end
+
+      context "when not run in isolation" do
+        before do
+          allow(@ci).to receive(:already_invoked).and_return(true)
+        end
+
+        it "does not run ci:teardown" do
+          expect(@teardown).not_to receive(:invoke)
+
+          ::Rake::Task["ci:flow"].invoke
+        end
+      end
+    end
+
+    context "when there are failures" do
+      before do
+        @failure = double(:failure, display: "hi")
+        @flow.failures << @failure
+
+        allow(@flow).to receive(:abort)
+      end
+
+      it "runs ci:flow:teardown" do
+        expect(@flow_teardown).to receive(:invoke)
+
+        ::Rake::Task["ci:flow"].invoke
+      end
+
+      it "invokes ci:teardown" do
+        expect(@teardown).to receive(:invoke)
+
+        ::Rake::Task["ci:flow"].invoke
+      end
+
+      it "displays the failures" do
+        expect(@failure).to receive(:display)
+
+        ::Rake::Task["ci:flow"].invoke
+      end
+
+      it "aborts with a message" do
+        expect(@flow).to receive(:abort).with(/heading failed, see CI\.log for more\./)
+
+        ::Rake::Task["ci:flow"].invoke
+      end
+    end
+  end
+end

data/spec/unit/local_ci/helper_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe LocalCI::Helper do
+  describe ".pastel" do
+    it "returns a Pastel instance" do
+      expect(TTY::Color).to receive(:support?).and_return("support")
+      expect(Pastel).to receive(:new).with(enabled: "support")
+        .and_return("pastel")
+
+      expect(LocalCI::Helper.pastel).to eq("pastel")
+    end
+  end
+
+  describe ".runner" do
+    it "returns a TTY::Command instance" do
+      expect(Logger).to receive(:new).with("ci.log").and_return("logger")
+      expect(TTY::Command).to receive(:new).with(output: "logger")
+        .and_return("tty-command")
+
+      expect(LocalCI::Helper.runner).to eq("tty-command")
+    end
+  end
+
+  describe ".taskize" do
+    it "returns a task-ized version of a string" do
+      expect(LocalCI::Helper.taskize("Hello There!")).to eq(:hello_there)
+    end
+  end
+end

data/spec/unit/local_ci/job_spec.rb

@@ -0,0 +1,126 @@
+require "spec_helper"
+
+describe LocalCI::Job do
+  before do
+    @flow = LocalCI::Flow.new(
+      name: "flow",
+      heading: "heading",
+      parallel: true,
+      block: -> {}
+    )
+  end
+
+  describe "#initialize" do
+    it "creates a new job with the right arguments" do
+      job = LocalCI::Job.new(
+        flow: @flow,
+        name: "The Job Name!",
+        command: "command",
+        block: "block"
+      )
+
+      expect(job.flow).to eq(@flow)
+      expect(job.name).to eq("The Job Name!")
+      expect(job.command).to eq("command")
+      expect(job.block).to eq("block")
+      expect(job.task).to eq("ci:flow:jobs:the_job_name")
+    end
+
+    context "when passed no block or command" do
+      it "raises an error" do
+        expect do
+          LocalCI::Job.new(
+            flow: @flow,
+            name: "name",
+            command: nil,
+            block: nil
+          )
+        end.to raise_error(ArgumentError, "Must specify a block or command")
+      end
+    end
+
+    it "defines a rake task" do
+      LocalCI::Job.new(
+        flow: @flow,
+        name: "The Job Name!",
+        command: "command",
+        block: "block"
+      )
+
+      expect(Rake::Task.task_defined?("ci:flow:jobs:the_job_name")).to be(true)
+    end
+
+    it "gives the rake task the right prerequisite" do
+      LocalCI::Job.new(
+        flow: @flow,
+        name: "The Job Name!",
+        command: "command",
+        block: "block"
+      )
+
+      expect(Rake::Task["ci:flow:jobs"].prerequisites).to include("ci:flow:jobs:the_job_name")
+    end
+  end
+
+  describe "task" do
+    context "when running a block" do
+      it "runs all the commands from the block" do
+        expect(LocalCI::Helper.runner).to receive(:run).with("command 1")
+        expect(LocalCI::Helper.runner).to receive(:run).with("command", "2")
+
+        LocalCI::Job.new(
+          flow: @flow,
+          name: "block task",
+          command: nil,
+          block: -> {
+            run "command 1"
+            run "command", "2"
+          }
+        )
+
+        ::Rake::Task["ci:flow:jobs:block_task"].invoke
+      end
+    end
+
+    context "when running one command inline" do
+      it "runs the commands" do
+        expect(LocalCI::Helper.runner).to receive(:run).with("command", "by", "argument")
+
+        LocalCI::Job.new(
+          flow: @flow,
+          name: "command task",
+          command: ["command", "by", "argument"],
+          block: nil
+        )
+        ::Rake::Task["ci:flow:jobs:command_task"].invoke
+      end
+    end
+
+    context "when the job fails" do
+      it "is recorded against the flow" do
+        expect(LocalCI::Helper.runner).to receive(:run).with("exit 1")
+          .and_raise(
+            TTY::Command::ExitError.new(
+              "exit 1",
+              double(
+                exit_status: 1,
+                err: "oops!",
+                out: ""
+              )
+            )
+          )
+
+        LocalCI::Job.new(
+          flow: @flow,
+          name: "Raises an Error",
+          command: "exit 1",
+          block: nil
+        )
+        ::Rake::Task["ci:flow:jobs:raises_an_error"].invoke
+
+        expect(@flow.failures.size).to eq(1)
+        expect(@flow.failures.first.job).to eq("Raises an Error")
+      end
+    end
+  end
+end

data/spec/unit/local_ci/rake_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe LocalCI::Rake do
+  describe ".setup" do
+    before do
+      @klass = double(:klass)
+      allow(@klass).to receive(:send)
+    end
+
+    it "includes the DSL" do
+      expect(@klass).to receive(:send).with(:include, LocalCI::DSL)
+
+      LocalCI::Rake.setup(@klass)
+    end
+  end
+end

data/spec/unit/local_ci/task_spec.rb

@@ -0,0 +1,114 @@
+require "spec_helper"
+
+describe LocalCI::Task do
+  describe "#initialize" do
+    context "with parallel preqresuites" do
+      it "creates a MultiTask" do
+        expect(::Rake::MultiTask).to receive(:[]).with("task")
+
+        LocalCI::Task.new("task", parallel_prerequisites: true)
+      end
+
+      context "with a comment" do
+        it "sets the comment" do
+          task = double(:task)
+          allow(::Rake::MultiTask).to receive(:[]).and_return(task)
+          expect(task).to receive(:comment=).with("comment")
+
+          LocalCI::Task.new("task", comment: "comment", parallel_prerequisites: true)
+        end
+      end
+
+      context "without a comment" do
+        it "does not set the comment" do
+          task = double(:task)
+          allow(::Rake::MultiTask).to receive(:[]).and_return(task)
+          expect(task).not_to receive(:comment=)
+
+          LocalCI::Task.new("task", parallel_prerequisites: true)
+        end
+      end
+    end
+
+    context "with sequential preqresuites" do
+      it "creates a Task" do
+        expect(::Rake::Task).to receive(:[]).with("task")
+
+        LocalCI::Task.new("task", parallel_prerequisites: false)
+      end
+
+      context "with a comment" do
+        it "sets the comment" do
+          task = double(:task)
+          allow(::Rake::Task).to receive(:[]).and_return(task)
+          expect(task).to receive(:comment=).with("comment")
+
+          LocalCI::Task.new("task", comment: "comment", parallel_prerequisites: false)
+        end
+      end
+
+      context "without a comment" do
+        it "does not set the comment" do
+          task = double(:task)
+          allow(::Rake::Task).to receive(:[]).and_return(task)
+          expect(task).not_to receive(:comment=)
+
+          LocalCI::Task.new("task", parallel_prerequisites: false)
+        end
+      end
+    end
+  end
+
+  describe ".[]" do
+    it "creates a LocalCI::Task" do
+      expect(LocalCI::Task).to receive(:new).with(
+        "task",
+        comment: "comment"
+      )
+
+      LocalCI::Task["task", "comment"]
+    end
+  end
+
+  describe "#add_prerequisite" do
+    before do
+      @task = LocalCI::Task.new("task", parallel_prerequisites: true)
+    end
+
+    it "adds the prerequisite" do
+      expect(@task.prerequisites).to receive(:<<).with("prereq")
+
+      @task.add_prerequisite("prereq")
+    end
+
+    context "When it already has that prerequisite" do
+      it "doesn't add it again" do
+        expect(@task.prerequisites).not_to receive(:<<)
+        expect(@task).to receive(:prerequisites).and_return(["prereq"])
+
+        @task.add_prerequisite("prereq")
+      end
+    end
+  end
+
+  describe "#define" do
+    before do
+      @task = LocalCI::Task.new("task", parallel_prerequisites: true)
+    end
+
+    it "calls define_task" do
+      expect(::Rake::Task).to receive(:define_task).with("task")
+
+      @task.define {}
+    end
+
+    it "uses the passed in block as the task body" do
+      @block_run = false
+
+      @task.define { @block_run = true }
+
+      @task.invoke
+      expect(@block_run).to be(true)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: local_ci
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Sean Earle
@@ -90,9 +90,25 @@ files:
 - Gemfile.lock
 - Rakefile
 - lib/local_ci.rb
+- lib/local_ci/dsl.rb
+- lib/local_ci/exec_context.rb
 - lib/local_ci/failure.rb
 - lib/local_ci/flow.rb
+- lib/local_ci/helper.rb
+- lib/local_ci/job.rb
+- lib/local_ci/rake.rb
+- lib/local_ci/task.rb
 - local_ci.gemspec
+- spec/spec_helper.rb
+- spec/support/dsl_klass.rb
+- spec/unit/local_ci/dsl_spec.rb
+- spec/unit/local_ci/exec_context_spec.rb
+- spec/unit/local_ci/failure_spec.rb
+- spec/unit/local_ci/flow_spec.rb
+- spec/unit/local_ci/helper_spec.rb
+- spec/unit/local_ci/job_spec.rb
+- spec/unit/local_ci/rake_spec.rb
+- spec/unit/local_ci/task_spec.rb
 homepage: https://github.com/HellRok/local_ci
 licenses:
 - MIT