local_ci 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e82b2aed28cefc2d6c08727b6ea92821c2a8798786242c51eca088ad3b333fa
-  data.tar.gz: 1ee3d798f7756d4f9a6c4667a6d495a181665ab952b97de3a667dd2251f40e43
+  metadata.gz: 408a3e34c26196b5f280ffb77aa68162ea4118a13309d29365bb4e064ccc940f
+  data.tar.gz: 893f1167a5a294e58f9f8d27452c2e85879263cbc4e9cbe934ef555a760eb257
 SHA512:
-  metadata.gz: c246d0a0dc55146c54d945070c5c9b14cfc888e3ff581c6755fbafcd2569bcb820e286e76a9d3e5604512bc56752c3ba7cc947725340b9219a1c9329e43328bc
-  data.tar.gz: 23d2bc6e09c66226e7fa7e6bc7673e2f7ea7e047c6903822abe94a5de80aad4e948252eb3275a797b721bb03fffe735efe8991cb433f0a2685ef873a7829c25e
+  metadata.gz: d5e5b78327fa679adf3b29a7b658a7134713d07dd20abb19dde41130d373b490bb00c1241987886beafaa8dbb4c47abf64b0ab07a513f412dcbb3495f09eaef4
+  data.tar.gz: c36f886be0c3ddd7f98d24d850c89dabc2962cdf286baa8fde1fd927deab952ea5bc39b174609882e80992f8742546e62cb5f79b129b87ae3b85e399a7c48f5d

data/Gemfile.lock

@@ -1,12 +1,13 @@
 PATH
   remote: .
   specs:
-    local_ci (0.0.2)
+    local_ci (0.0.4)
       logger
       pastel
       rake
       tty-command
-      tty-spinner
+      tty-cursor
+      tty-screen
 
 GEM
   remote: https://rubygems.org/
@@ -78,8 +79,7 @@ GEM
     tty-command (0.10.1)
       pastel (~> 0.8)
     tty-cursor (0.7.1)
-    tty-spinner (0.9.3)
-      tty-cursor (~> 0.7)
+    tty-screen (0.8.2)
     unicode-display_width (3.2.0)
       unicode-emoji (~> 4.1)
     unicode-emoji (4.1.0)

data/Rakefile

@@ -36,8 +36,6 @@ flow "Build" do
     job "Compile - #{file}" do
       run "echo", "gcc", file
     end
-
-    job "Boom", "exit 1"
   end
 
   teardown do

data/lib/local_ci/failure.rb

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

data/lib/local_ci/flow.rb

@@ -1,25 +1,17 @@
 module LocalCI
   class Flow
-    attr_accessor :task, :heading, :spinner, :failures
+    attr_accessor :task, :heading, :spinner, :failures, :jobs, :output
 
     def initialize(name:, heading:, parallel:, block:, actions: true)
       @task = name
       @task = "ci:#{name}" unless @task.start_with?("ci:")
       @parallel = parallel
       @failures = []
-      @heading = heading
       @actions = actions
-      @spinner = TTY::Spinner::Multi.new(
-        "[:spinner] #{LocalCI::Helper.pastel.bold.blue(@heading)}",
-        format: :classic,
-        success_mark: LocalCI::Helper.pastel.green("✓"),
-        error_mark: LocalCI::Helper.pastel.red("✗"),
-        style: {
-          top: "",
-          middle: "    ",
-          bottom: "    "
-        }
-      )
+
+      @heading = heading
+      @jobs = []
+      @output = LocalCI::Output.new(flow: self)
 
       setup_required_tasks
       if actions?
@@ -59,14 +51,12 @@ module LocalCI
       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"
 
@@ -75,10 +65,8 @@ module LocalCI
 
     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"
+      LocalCI::Task[@task].add_prerequisite "#{@task}:jobs"
     end
 
     def after_jobs
@@ -88,11 +76,9 @@ module LocalCI
 
         if @failures.any?
           LocalCI::Task["ci:teardown"].invoke
-          @failures.each do |failure|
-            puts failure.message
-          end
+          output.failures
 
-          abort LocalCI::Helper.pastel.red("#{@heading} failed, see CI.log for more.")
+          abort LocalCI::Helper.pastel.red("#{@heading} failed, see ci.log for more.")
         end
       end
     end

data/lib/local_ci/helper.rb

@@ -1,7 +1,8 @@
 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.color? = TTY::Color.support?
+    def self.pastel = @pastel ||= Pastel.new(enabled: color?)
+    def self.runner = @runner ||= TTY::Command.new(color: color?, output: Logger.new("ci.log"))
 
     def self.taskize(heading)
       heading.downcase.gsub(/\s/, "_").gsub(/[^\w]/, "").to_sym

data/lib/local_ci/job.rb

@@ -1,19 +1,23 @@
 module LocalCI
   class Job
-    attr_accessor :flow, :name, :command, :block, :task, :spinner
+    attr_reader :flow, :name, :command, :block, :task, :state, :duration
 
     def initialize(flow:, name:, command:, block:)
       @flow = flow
-      @name = name
+      @flow.jobs << self
+      @task = "#{@flow.task}:jobs:#{LocalCI::Helper.taskize(name)}"
+
       @command = command
       @block = block
-      @task = "#{@flow.task}:jobs:#{LocalCI::Helper.taskize(name)}"
+
+      @name = name
+      @state = :waiting
 
       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
+        @state = :running
+        @flow.output.update(self)
         start = Time.now
 
         if block
@@ -21,20 +25,27 @@ module LocalCI
         else
           LocalCI::Helper.runner.run(*command)
         end
-
-        took = Time.now - start
-        @spinner.success("(#{took.round(2)}s)")
+        @state = :success
       rescue TTY::Command::ExitError => e
-        spinner.error
+        @state = :failed
         @flow.failures << LocalCI::Failure.new(
           job: @name,
           message: e.message
         )
+      ensure
+        @duration = Time.now - start
+        @flow.output.update(self)
       end
 
       ::Rake::Task["#{@flow.task}:jobs"].prerequisites << task
 
       ::Rake::Task[task].prerequisites << "#{@flow.task}:setup" if @flow.actions?
     end
+
+    def waiting? = @state == :waiting
+    def running? = @state == :running
+    def success? = @state == :success
+    def failed? = @state == :failed
+    def done? = [:success, :failed].include? @state
   end
 end

data/lib/local_ci/output.rb

@@ -0,0 +1,150 @@
+module LocalCI
+  class Output
+    attr_reader :job
+
+    def initialize(flow:)
+      @flow = flow
+      @first_paint = true
+      @start = 0
+      @mutex = Mutex.new
+    end
+
+    def start_thread
+      @thread = Thread.new {
+        loop do
+          @mutex.synchronize { draw(final: @thread_should_exit) }
+          break if @thread_should_exit
+          sleep 0.1
+        end
+      }
+    end
+
+    def finish
+      @thread_should_exit = true
+      @thread.join
+    end
+
+    def pastel = LocalCI::Helper.pastel
+    def cursor = TTY::Cursor
+    def screen = TTY::Screen
+    def tty? = $stdout.isatty
+
+    def passed? = @flow.jobs.all?(&:success?)
+    def failed? = @flow.failures.any?
+    def done? = @flow.jobs.all?(&:done?)
+
+    def update(job)
+      if tty?
+        finish and return if done?
+
+        return if @thread&.alive?
+
+        start_thread
+      else
+        @job = job
+
+        @mutex.synchronize { json_output }
+      end
+    end
+
+    def failures
+      return unless tty?
+
+      @mutex.synchronize {
+        @flow.failures.each do |failure|
+          puts <<~STR
+            #{pastel.bold.red("FAIL:")} #{failure.job}
+            #{failure.message}
+
+          STR
+        end
+      }
+    end
+
+    def draw(final: false)
+      if @first_paint
+        @start = Time.now
+        @first_paint = false
+      else
+        print cursor.clear_line + cursor.up(@flow.jobs.size + 2)
+      end
+
+      puts heading_line
+      @flow.jobs.each { puts job_line it }
+      puts footer_line
+
+      puts if final
+    end
+
+    def color(message)
+      if passed?
+        pastel.green(message)
+      elsif failed?
+        pastel.red(message)
+      else
+        pastel.blue(message)
+      end
+    end
+
+    def heading_line
+      heading = @flow.heading.dup
+      heading = "#{heading[...(screen.width - 11)]}…" if heading.length > (screen.width - 10)
+
+      tail_length = screen.width - 5 - heading.length - 2
+
+      color "===| #{pastel.bold heading} |#{"=" * tail_length}"
+    end
+
+    def job_line(job)
+      name = job.name.dup
+
+      name = "#{name[...(screen.width - 4)]}…" if name.length > (screen.width - 3)
+
+      result = cursor.clear_line
+      if job.waiting?
+        result << "[ ] #{name}"
+      elsif job.running?
+        result << "[-] #{name}"
+      elsif job.success?
+        result << "[#{pastel.green "✓"}] #{name}"
+      elsif job.failed?
+        result << "[#{pastel.red "✗"}] #{name}"
+      end
+
+      result
+    end
+
+    def duration
+      seconds = Time.now - @start
+      minutes = seconds / 60
+      hours = minutes / 60
+
+      seconds %= 60
+      minutes %= 60
+
+      if hours >= 1
+        "#{hours}h #{minutes}m"
+
+      elsif minutes >= 1
+        "#{minutes}m #{seconds}s"
+
+      else
+        "#{seconds.round(2)}s"
+      end
+    end
+
+    def footer_line
+      start_length = screen.width - 4 - duration.size - 1
+      color "#{"-" * start_length}(#{pastel.bold duration})---"
+    end
+
+    def json_output
+      puts({
+        flow: @flow.heading,
+        job: @job.name,
+        duration: @job.duration,
+        state: @job.state
+      }.to_json)
+    end
+  end
+end

data/lib/local_ci.rb

@@ -1,7 +1,10 @@
 require "forwardable"
+require "json"
 require "logger"
+
 require "tty-command"
-require "tty-spinner"
+require "tty-cursor"
+require "tty-screen"
 require "pastel"
 
 require "local_ci/dsl"
@@ -10,5 +13,6 @@ require "local_ci/failure"
 require "local_ci/flow"
 require "local_ci/helper"
 require "local_ci/job"
+require "local_ci/output"
 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.3"
+  s.version = "0.0.4"
   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"]
@@ -14,5 +14,6 @@ Gem::Specification.new do |s|
   s.add_dependency "pastel"
   s.add_dependency "rake"
   s.add_dependency "tty-command"
-  s.add_dependency "tty-spinner"
+  s.add_dependency "tty-cursor"
+  s.add_dependency "tty-screen"
 end

data/spec/unit/local_ci/failure_spec.rb

@@ -1,24 +1,12 @@
 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")
+  describe "#initialize" do
+    it "sets up the instance variables" do
+      failure = LocalCI::Failure.new(job: "job", message: "message")
 
-      failure = LocalCI::Failure.new(
-        job: "job",
-        message: "message"
-      )
-
-      expect(failure.message).to eq(<<~STR)
-        red job
-        message
-
-      STR
+      expect(failure.job).to eq("job")
+      expect(failure.message).to eq("message")
     end
   end
 end

data/spec/unit/local_ci/flow_spec.rb

@@ -187,10 +187,14 @@ describe LocalCI::Flow do
 
     context "when there are failures" do
       before do
-        @failure = double(:failure, message: "hi")
+        @failure = double(:failure, job: "job", message: "hi")
         @flow.failures << @failure
 
         allow(@flow).to receive(:abort)
+
+        @output = double(:output)
+        allow(@output).to receive(:failures)
+        allow(@flow).to receive(:output).and_return(@output)
       end
 
       it "runs ci:flow:teardown" do
@@ -206,13 +210,13 @@ describe LocalCI::Flow do
       end
 
       it "displays the failures" do
-        expect(@failure).to receive(:message)
+        expect(@output).to receive(:failures)
 
         ::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\./)
+        expect(@flow).to receive(:abort).with(/heading failed, see ci\.log for more\./)
 
         ::Rake::Task["ci:flow"].invoke
       end

data/spec/unit/local_ci/helper_spec.rb

@@ -13,8 +13,10 @@ describe LocalCI::Helper do
 
   describe ".runner" do
     it "returns a TTY::Command instance" do
+      expect(TTY::Color).to receive(:support?).and_return("support")
       expect(Logger).to receive(:new).with("ci.log").and_return("logger")
-      expect(TTY::Command).to receive(:new).with(output: "logger")
+      expect(TTY::Command).to receive(:new)
+        .with(color: "support", output: "logger")
         .and_return("tty-command")
 
       expect(LocalCI::Helper.runner).to eq("tty-command")

data/spec/unit/local_ci/job_spec.rb

@@ -2,12 +2,16 @@ require "spec_helper"
 
 describe LocalCI::Job do
   before do
+    @output = double(:output)
+    allow(@output).to receive(:update)
+
     @flow = LocalCI::Flow.new(
       name: "flow",
       heading: "heading",
       parallel: true,
       block: -> {}
     )
+    allow(@flow).to receive(:output).and_return(@output)
   end
 
   describe "#initialize" do
@@ -24,6 +28,7 @@ describe LocalCI::Job do
       expect(job.command).to eq("command")
       expect(job.block).to eq("block")
       expect(job.task).to eq("ci:flow:jobs:the_job_name")
+      expect(job.state).to eq(:waiting)
     end
 
     context "when passed no block or command" do
@@ -80,6 +85,31 @@ describe LocalCI::Job do
 
         ::Rake::Task["ci:flow:jobs:block_task"].invoke
       end
+
+      it "sets the state" do
+        job = LocalCI::Job.new(
+          flow: @flow,
+          name: "block task",
+          command: nil,
+          block: -> {}
+        )
+
+        ::Rake::Task["ci:flow:jobs:block_task"].invoke
+
+        expect(job.state).to eq(:success)
+      end
+
+      it "updates the output" do
+        job = LocalCI::Job.new(
+          flow: @flow,
+          name: "block task",
+          command: nil,
+          block: -> {}
+        )
+        expect(@output).to receive(:update).with(job)
+
+        ::Rake::Task["ci:flow:jobs:block_task"].invoke
+      end
     end
 
     context "when running one command inline" do
@@ -97,6 +127,15 @@ describe LocalCI::Job do
     end
 
     context "when the job fails" do
+      before do
+        @job = LocalCI::Job.new(
+          flow: @flow,
+          name: "Raises an Error",
+          command: "exit 1",
+          block: nil
+        )
+      end
+
       it "is recorded against the flow" do
         expect(LocalCI::Helper.runner).to receive(:run).with("exit 1")
           .and_raise(
@@ -110,17 +149,23 @@ describe LocalCI::Job do
             )
           )
 
-        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
+
+      it "sets the state" do
+        ::Rake::Task["ci:flow:jobs:raises_an_error"].invoke
+
+        expect(@job.state).to eq(:failed)
+      end
+
+      it "updates the output" do
+        expect(@output).to receive(:update).with(@job)
+
+        ::Rake::Task["ci:flow:jobs:raises_an_error"].invoke
+      end
     end
   end
 end

data/spec/unit/local_ci/output_spec.rb

@@ -0,0 +1,406 @@
+require "spec_helper"
+
+describe LocalCI::Output do
+  before do
+    @job = double(:job)
+    @flow = double(:flow, jobs: [])
+    @thread = double(:thread, alive?: true)
+    allow(@thread).to receive(:join)
+
+    @output = LocalCI::Output.new(flow: @flow)
+    @output.instance_variable_set(:@thread, @thread)
+  end
+
+  describe "#update" do
+    before do
+      allow(@output).to receive(:output)
+      allow(@output).to receive(:json_output)
+    end
+
+    context "when we are not in a TTY" do
+      before do
+        expect(@output).to receive(:tty?).and_return(false)
+      end
+
+      it "sets the job" do
+        @output.update(@job)
+        expect(@output.job).to eq(@job)
+      end
+
+      it "calls json_output" do
+        expect(@output).to receive(:json_output)
+        @output.update(@job)
+      end
+    end
+
+    context "when we are in a TTY" do
+      before do
+        allow(@output).to receive(:tty?).and_return(true)
+      end
+
+      context "when all jobs are done" do
+        before do
+          allow(@output).to receive(:done?).and_return(true)
+        end
+
+        it "calls finish" do
+          expect(@output).to receive(:finish)
+          @output.update(@job)
+        end
+
+        it "does not call start_thread" do
+          expect(@output).not_to receive(:start_thread)
+          @output.update(@job)
+        end
+      end
+
+      context "the thread is alive" do
+        before do
+          allow(@output).to receive(:done?).and_return(false)
+        end
+
+        it "does not call finish" do
+          expect(@output).not_to receive(:finish)
+          @output.update(@job)
+        end
+
+        it "does not call start_thread" do
+          expect(@output).not_to receive(:start_thread)
+          @output.update(@job)
+        end
+      end
+
+      context "the thread is not alive" do
+        before do
+          allow(@output).to receive(:done?).and_return(false)
+          allow(@thread).to receive(:alive?).and_return(false)
+        end
+
+        it "starts the thread" do
+          expect(@output).to receive(:start_thread)
+
+          @output.update(@job)
+        end
+      end
+    end
+  end
+
+  describe "#failures" do
+    before do
+      allow(@flow).to receive(:failures).and_return(
+        [
+          double(:failure, job: "job-1", message: "message-1"),
+          double(:failure, job: "job-2", message: "message-2")
+        ]
+      )
+    end
+
+    context "when we are in a TTY" do
+      it "displays the errors" do
+        expect(@output).to receive(:tty?).and_return(true)
+
+        expect(@output).to receive(:puts).with(/job-1\nmessage-1/)
+        expect(@output).to receive(:puts).with(/job-2\nmessage-2/)
+
+        @output.failures
+      end
+    end
+
+    context "when we are not in a TTY" do
+      it "does nothing" do
+        expect(@output).to receive(:tty?).and_return(false)
+
+        expect(@output).not_to receive(:puts)
+
+        @output.failures
+      end
+    end
+  end
+
+  describe "#draw" do
+    before do
+      allow(@output).to receive(:print)
+      allow(@output).to receive(:puts)
+      allow(@output).to receive(:heading_line).and_return("heading-line")
+      allow(@output).to receive(:job_line).and_return("job-line")
+      allow(@output).to receive(:footer_line).and_return("footer-line")
+
+      allow(@flow).to receive(:jobs).and_return(["job-1", "job-2"])
+    end
+
+    context "on first paint for the flow" do
+      before do
+        @output.instance_variable_set(:@first_paint, true)
+      end
+
+      it "does not clear lines" do
+        expect(TTY::Cursor).not_to receive(:clear_line)
+        expect(TTY::Cursor).not_to receive(:up)
+
+        @output.draw
+      end
+
+      it "sets the start time" do
+        expect(Time).to receive(:now).and_return("time")
+
+        @output.draw
+
+        expect(@output.instance_variable_get(:@start)).to eq("time")
+      end
+    end
+
+    context "on subsequent paints" do
+      before do
+        @output.instance_variable_set(:@first_paint, false)
+
+        allow(TTY::Cursor).to receive(:clear_line).and_return("")
+        allow(TTY::Cursor).to receive(:up).and_return("")
+        allow(@output).to receive(:print)
+      end
+
+      it "moves up and clears the line" do
+        expect(TTY::Cursor).to receive(:clear_line).and_return("clear-line")
+        expect(TTY::Cursor).to receive(:up).with(4).and_return("up")
+
+        expect(@output).to receive(:print).with("clear-lineup")
+
+        @output.draw
+      end
+    end
+
+    it "paints the heading" do
+      expect(@output).to receive(:heading_line).and_return("heading-line")
+
+      expect(@output).to receive(:puts).with("heading-line")
+
+      @output.draw
+    end
+
+    it "paints the jobs" do
+      expect(@output).to receive(:job_line).with("job-1").and_return("job-line-1")
+      expect(@output).to receive(:job_line).with("job-2").and_return("job-line-2")
+
+      expect(@output).to receive(:puts).with("job-line-1")
+      expect(@output).to receive(:puts).with("job-line-2")
+
+      @output.draw
+    end
+
+    it "paints the footer" do
+      expect(@output).to receive(:footer_line).and_return("footer-line")
+
+      expect(@output).to receive(:puts).with("footer-line")
+
+      @output.draw
+    end
+
+    context "when final is true" do
+      it "draws an extra new line" do
+        expect(@output).to receive(:puts).with(no_args)
+
+        @output.draw(final: true)
+      end
+    end
+  end
+
+  describe "#color" do
+    before do
+      @pastel = double(:pastel)
+      allow(@output).to receive(:pastel).and_return(@pastel)
+    end
+
+    context "when the flow is running" do
+      it "returns blue" do
+        expect(@output).to receive(:passed?).and_return(false)
+        expect(@output).to receive(:failed?).and_return(false)
+
+        expect(@pastel).to receive(:blue).with("message")
+
+        @output.color("message")
+      end
+    end
+
+    context "when the flow has passed" do
+      it "returns blue" do
+        expect(@output).to receive(:passed?).and_return(true)
+
+        expect(@pastel).to receive(:green).with("message")
+
+        @output.color("message")
+      end
+    end
+
+    context "when the flow has failed" do
+      it "returns blue" do
+        expect(@output).to receive(:passed?).and_return(false)
+        expect(@output).to receive(:failed?).and_return(true)
+
+        expect(@pastel).to receive(:red).with("message")
+
+        @output.color("message")
+      end
+    end
+  end
+
+  describe "#heading_line" do
+    before do
+      allow(@flow).to receive(:heading).and_return("flow-heading")
+      allow(@output).to receive(:screen).and_return(double(width: 40))
+      @pastel = Pastel.new
+    end
+
+    it "returns a heading the width of the terminal" do
+      expect(@pastel.strip(@output.heading_line)).to eq(
+        "===| flow-heading |====================="
+      )
+    end
+
+    context "when the heading is too long" do
+      it "truncates it with an ellipsis" do
+        allow(@flow).to receive(:heading).and_return("Some really long heading that really probably shouldn't be this long but is I guess")
+        expect(@pastel.strip(@output.heading_line)).to eq(
+          "===| Some really long heading that… |==="
+        )
+      end
+    end
+
+    context "when the heading is just short enough" do
+      it "does not truncate" do
+        allow(@flow).to receive(:heading).and_return("Something long, but not silly!")
+
+        expect(@pastel.strip(@output.heading_line)).to eq(
+          "===| Something long, but not silly! |==="
+        )
+      end
+    end
+  end
+
+  describe "#job_line" do
+    before do
+      @pastel = Pastel.new
+
+      @job = double(:job, name: "job-name")
+      allow(@job).to receive(:waiting?).and_return(false)
+      allow(@job).to receive(:running?).and_return(false)
+      allow(@job).to receive(:success?).and_return(false)
+      allow(@job).to receive(:failed?).and_return(false)
+
+      allow(@output).to receive_message_chain(:cursor, :clear_line).and_return("")
+      allow(@output).to receive(:screen).and_return(double(width: 20))
+    end
+
+    context "when the job is waiting" do
+      it "returns no indicator and the job name" do
+        expect(@job).to receive(:waiting?).and_return(true)
+        expect(@pastel.strip(@output.job_line(@job))).to eq("[ ] job-name")
+      end
+    end
+
+    context "when the job is running" do
+      it "returns an indicator and the job name" do
+        expect(@job).to receive(:running?).and_return(true)
+        expect(@pastel.strip(@output.job_line(@job))).to eq("[-] job-name")
+      end
+    end
+
+    context "when the job was successful" do
+      it "returns an indicator and the job name" do
+        expect(@job).to receive(:success?).and_return(true)
+        expect(@pastel.strip(@output.job_line(@job))).to eq("[✓] job-name")
+      end
+    end
+
+    context "when the job failed" do
+      it "returns an indicator and the job name" do
+        expect(@job).to receive(:failed?).and_return(true)
+        expect(@pastel.strip(@output.job_line(@job))).to eq("[✗] job-name")
+      end
+    end
+
+    context "when the name is too long" do
+      it "truncates it with an ellipsis" do
+        allow(@job).to receive(:waiting?).and_return(true)
+        allow(@job).to receive(:name).and_return("A really long job name, obviously just way too long, what are you even doing!")
+
+        expect(@pastel.strip(@output.job_line(@job))).to eq(
+          "[ ] A really long jo…"
+        )
+      end
+    end
+
+    context "when the name is just short enough" do
+      it "does not truncate" do
+        allow(@job).to receive(:waiting?).and_return(true)
+        allow(@job).to receive(:name).and_return("A long job name!!")
+
+        expect(@pastel.strip(@output.job_line(@job))).to eq(
+          "[ ] A long job name!!"
+        )
+      end
+    end
+  end
+
+  describe "#footer_line" do
+    before do
+      allow(@output).to receive(:screen).and_return(double(width: 20))
+      allow(@output).to receive(:duration).and_return("duration")
+      @pastel = Pastel.new
+    end
+
+    it "returns a footer the length of the terminal with the duration" do
+      expect(@pastel.strip(@output.footer_line)).to eq(
+        "-------(duration)---"
+      )
+    end
+  end
+
+  describe "#duration" do
+    context "when less than 60 seconds" do
+      it "shows seconds with two decimal places" do
+        @output.instance_variable_set(:@start, 5.567)
+        allow(Time).to receive(:now).and_return(45)
+
+        expect(@output.duration).to eq("39.43s")
+      end
+    end
+
+    context "when less than 60 minutes" do
+      it "shows the minutes and seconds" do
+        @output.instance_variable_set(:@start, 10)
+        allow(Time).to receive(:now).and_return(1240)
+
+        expect(@output.duration).to eq("20m 30s")
+      end
+    end
+
+    context "when greater than 60 minutes" do
+      it "shows the hours and minutes" do
+        @output.instance_variable_set(:@start, 10)
+        allow(Time).to receive(:now).and_return(3800)
+
+        expect(@output.duration).to eq("1h 3m")
+      end
+    end
+  end
+
+  describe "#json_output" do
+    it "returns the state as json" do
+      allow(@flow).to receive(:heading).and_return("flow-heading")
+      @output.instance_variable_set(:@job, double(
+        :job,
+        name: "job-name",
+        duration: "job-duration",
+        state: "job-state"
+      ))
+
+      expect(@output).to receive(:puts).with({
+        flow: "flow-heading",
+        job: "job-name",
+        duration: "job-duration",
+        state: "job-state"
+      }.to_json)
+
+      @output.json_output
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: local_ci
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Sean Earle
@@ -66,7 +66,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: tty-spinner
+  name: tty-cursor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-screen
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -96,6 +110,7 @@ files:
 - lib/local_ci/flow.rb
 - lib/local_ci/helper.rb
 - lib/local_ci/job.rb
+- lib/local_ci/output.rb
 - lib/local_ci/rake.rb
 - lib/local_ci/task.rb
 - local_ci.gemspec
@@ -107,6 +122,7 @@ files:
 - 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/output_spec.rb
 - spec/unit/local_ci/rake_spec.rb
 - spec/unit/local_ci/task_spec.rb
 homepage: https://github.com/HellRok/local_ci