planter-cli 3.0.1 → 3.0.2

data/lib/tty-spinner/spec/unit/error_spec.rb

@@ -0,0 +1,53 @@
+RSpec.describe TTY::Spinner, "#error" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "marks spinner as error" do
+    spinner = TTY::Spinner.new(output: output)
+    3.times { spinner.spin }
+    spinner.error
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G|",
+      "\e[1G/",
+      "\e[1G-",
+      "\e[0m\e[2K",
+      "\e[1G#{TTY::Spinner::CROSS}\n"
+    ].join)
+
+    expect(spinner.error?).to be(true)
+  end
+
+  it "marks spinner as error with message" do
+    spinner = TTY::Spinner.new(output: output)
+    3.times { spinner.spin }
+    spinner.error("Error")
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G|",
+      "\e[1G/",
+      "\e[1G-",
+      "\e[0m\e[2K",
+      "\e[1G#{TTY::Spinner::CROSS} Error\n"
+    ].join)
+
+    expect(spinner.error?).to be(true)
+  end
+
+  it "changes error spinner marker" do
+    spinner = TTY::Spinner.new(error_mark: "x", output: output)
+    spinner.error("(error)")
+    output.rewind
+    expect(output.read).to eq("\e[0m\e[2K\e[1Gx (error)\n")
+
+    expect(spinner.error?).to be(true)
+  end
+
+  it "changes error spinner marker per method call" do
+    spinner = TTY::Spinner.new(error_mark: "x", output: output)
+    spinner.error("(error)", mark: "!")
+    output.rewind
+    expect(output.read).to eq("\e[0m\e[2K\e[1G! (error)\n")
+
+    expect(spinner.error?).to be(true)
+  end
+end

data/lib/tty-spinner/spec/unit/events_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe TTY::Spinner, "events" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "emits :done event" do
+    events = []
+    spinner = TTY::Spinner.new(output: output)
+    spinner.on(:done) { events << :done }
+
+    spinner.stop
+
+    expect(events).to eq([:done])
+  end
+
+  it "emits :success event" do
+    events = []
+    spinner = TTY::Spinner.new(output: output)
+    spinner.on(:done) { events << :done }
+    spinner.on(:success) { events << :success }
+
+    spinner.success
+
+    expect(events).to match_array(%i[done success])
+  end
+
+  it "emits :error event" do
+    events = []
+    spinner = TTY::Spinner.new(output: output)
+    spinner.on(:done) { events << :done }
+    spinner.on(:error) { events << :error }
+
+    spinner.error
+
+    expect(events).to match_array(%i[done error])
+  end
+end

data/lib/tty-spinner/spec/unit/formats_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Formats::FORMATS do
+  TTY::Formats::FORMATS.each do |token, properties|
+    it "#{token} contains proper defaults properties" do
+      expect(properties.keys.sort).to eq(%i[frames interval])
+    end
+  end
+end

data/lib/tty-spinner/spec/unit/frames_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe TTY::Spinner, ":frames" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "uses custom frames from string" do
+    frames = ".o0@*"
+    spinner = TTY::Spinner.new(frames: frames, output: output)
+    5.times { spinner.spin }
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G.",
+      "\e[1Go",
+      "\e[1G0",
+      "\e[1G@",
+      "\e[1G*"
+    ].join)
+  end
+
+  it "uses custom frames from array" do
+    frames = [".", "o", "0", "@", "*"]
+    spinner = TTY::Spinner.new(frames: frames, output: output)
+    5.times { spinner.spin }
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G.",
+      "\e[1Go",
+      "\e[1G0",
+      "\e[1G@",
+      "\e[1G*"
+    ].join)
+  end
+end

data/lib/tty-spinner/spec/unit/hide_cursor_spec.rb

@@ -0,0 +1,51 @@
+RSpec.describe TTY::Spinner, ":hide_cursor" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "hides cursor" do
+    spinner = TTY::Spinner.new(output: output, hide_cursor: true)
+    4.times { spinner.spin }
+    spinner.stop
+    output.rewind
+    expect(output.read).to eq([
+      "\e[?25l\e[1G|",
+      "\e[1G/",
+      "\e[1G-",
+      "\e[1G\\",
+      "\e[0m\e[2K",
+      "\e[1G\\\n",
+      "\e[?25h"
+    ].join)
+  end
+
+  it "restores cursor on success" do
+    spinner = TTY::Spinner.new(output: output, hide_cursor: true)
+    4.times { spinner.spin }
+    spinner.success("success")
+    output.rewind
+    expect(output.read).to eq([
+      "\e[?25l\e[1G|",
+      "\e[1G/",
+      "\e[1G-",
+      "\e[1G\\",
+      "\e[0m\e[2K",
+      "\e[1G\u2714 success\n",
+      "\e[?25h"
+    ].join)
+  end
+
+  it "restores cursor on error" do
+    spinner = TTY::Spinner.new(output: output, hide_cursor: true)
+    4.times { spinner.spin }
+    spinner.error("error")
+    output.rewind
+    expect(output.read).to eq([
+      "\e[?25l\e[1G|",
+      "\e[1G/",
+      "\e[1G-",
+      "\e[1G\\",
+      "\e[0m\e[2K",
+      "\e[1G\u2716 error\n",
+      "\e[?25h"
+    ].join)
+  end
+end

data/lib/tty-spinner/spec/unit/job_spec.rb

@@ -0,0 +1,12 @@
+RSpec.describe TTY::Spinner, "#job" do
+  it "adds and executes job" do
+    spinner = TTY::Spinner.new("[:spinner] :title")
+    called = []
+    work = proc { |sp| called << sp }
+    spinner.job(&work)
+
+    spinner.execute_job
+
+    expect(called).to eq([spinner])
+  end
+end

data/lib/tty-spinner/spec/unit/join_spec.rb

@@ -0,0 +1,10 @@
+RSpec.describe TTY::Spinner, "#join" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "raises exception when not spinning" do
+    spinner = TTY::Spinner.new(output: output)
+    expect {
+      spinner.join
+    }.to raise_error(TTY::Spinner::NotSpinningError)
+  end
+end

data/lib/tty-spinner/spec/unit/log_spec.rb

@@ -0,0 +1,60 @@
+RSpec.describe TTY::Spinner, "#log" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "logs a message above a spinner" do
+    spinner = TTY::Spinner.new(output: output)
+
+    2.times {
+      spinner.log "foo\nbar"
+      spinner.spin
+    }
+    output.rewind
+
+    expect(output.read).to eq([
+      "\e[2K\e[1Gfoo\n",
+      "\e[2K\e[1Gbar\n",
+      "\e[1G|",
+      "\e[1G|",
+      "\e[2K\e[1Gfoo\n",
+      "\e[2K\e[1Gbar\n",
+      "\e[1G/",
+      "\e[1G/"
+    ].join)
+  end
+
+  it "logs a message ending with a newline above a spinner" do
+    spinner = TTY::Spinner.new(output: output)
+
+    2.times {
+      spinner.log "foo\n"
+      spinner.spin
+    }
+    output.rewind
+
+    expect(output.read).to eq([
+      "\e[2K\e[1Gfoo\n",
+      "\e[1G|",
+      "\e[1G|",
+      "\e[2K\e[1Gfoo\n",
+      "\e[1G/",
+      "\e[1G/"
+    ].join)
+  end
+
+  it "logs message under a spinner when done" do
+    spinner = TTY::Spinner.new(output: output)
+    2.times { spinner.spin }
+    spinner.stop
+
+    spinner.log "foo\nbar"
+
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G|",
+      "\e[1G/",
+      "\e[0m\e[2K\e[1G/\n",
+      "\e[2K\e[1Gfoo\n",
+      "\e[2K\e[1Gbar\n"
+    ].join)
+  end
+end

data/lib/tty-spinner/spec/unit/multi/auto_spin_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe TTY::Spinner::Multi, "#auto_spin" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "doesn't auto spin top level spinner" do
+    spinners = TTY::Spinner::Multi.new("Top level spinner", output: output)
+    allow(spinners.top_spinner).to receive(:auto_spin)
+
+    spinners.auto_spin
+
+    expect(spinners.top_spinner).to_not have_received(:auto_spin)
+  end
+
+  it "raises an exception when called without a top spinner" do
+    spinners = TTY::Spinner::Multi.new(output: output)
+
+    expect {
+      spinners.auto_spin
+    }.to raise_error(RuntimeError, /No top level spinner/)
+  end
+
+  it "auto spins top level & child spinners with jobs" do
+    spinners = TTY::Spinner::Multi.new("top", output: output)
+    jobs = []
+
+    spinners.register("one") { |sp| jobs << "one"; sp.success }
+    spinners.register("two") { |sp| jobs << "two"; sp.success }
+
+    spinners.auto_spin
+
+    expect(jobs).to match_array(%w[one two])
+  end
+end

data/lib/tty-spinner/spec/unit/multi/error_spec.rb

@@ -0,0 +1,107 @@
+RSpec.describe TTY::Spinner::Multi, "#error" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "stops registerd multi spinner and emits an :error message" do
+    spinners = TTY::Spinner::Multi.new(":spinner", output: output)
+    callbacks = []
+    sp1 = spinners.register "[:spinner] one"
+    sp2 = spinners.register "[:spinner] two"
+
+    expect(sp1.error?).to eq(false)
+    expect(sp2.error?).to eq(false)
+
+    spinners.on(:error)   { callbacks << :error }
+            .on(:done)    { callbacks << :done }
+            .on(:success) { callbacks << :success }
+
+    spinners.error
+
+    expect(sp1.error?).to eq(true)
+    expect(sp2.error?).to eq(true)
+    expect(callbacks).to match_array(%i[done error])
+  end
+
+  it "stops unregistered top level spinner and emits an :error message" do
+    spinners = TTY::Spinner::Multi.new(output: output)
+    callbacks = []
+    sp1 = spinners.register "[:spinner] one"
+    sp2 = spinners.register "[:spinner] two"
+
+    expect(sp1.error?).to eq(false)
+    expect(sp2.error?).to eq(false)
+
+    spinners.on(:error)   { callbacks << :error }
+            .on(:done)    { callbacks << :done }
+            .on(:success) { callbacks << :success }
+
+    spinners.error
+
+    expect(sp1.error?).to eq(true)
+    expect(sp2.error?).to eq(true)
+    expect(callbacks).to match_array(%i[done error])
+  end
+
+  it "stops registed spinners under top level and emits an error message" do
+    spinners = TTY::Spinner::Multi.new(":spinner", output: output)
+    callbacks = []
+    sp1 = spinners.register "[:spinner] one"
+    sp2 = spinners.register "[:spinner] two"
+
+    expect(sp1.error?).to eq(false)
+    expect(sp2.error?).to eq(false)
+
+    spinners.on(:error)   { callbacks << :error }
+            .on(:done)    { callbacks << :done }
+            .on(:success) { callbacks << :success }
+
+    sp1.error
+    sp2.error
+
+    expect(spinners.error?).to eq(true)
+    expect(callbacks).to match_array(%i[done error])
+  end
+
+  it "stops registed spinners under top level and emits an error message" do
+    spinners = TTY::Spinner::Multi.new(output: output)
+    callbacks = []
+    sp1 = spinners.register "[:spinner] one"
+    sp2 = spinners.register "[:spinner] two"
+
+    expect(sp1.error?).to eq(false)
+    expect(sp2.error?).to eq(false)
+
+    spinners.on(:error)   { callbacks << :error }
+            .on(:done)    { callbacks << :done }
+            .on(:success) { callbacks << :success }
+
+    sp1.error
+    sp2.error
+
+    expect(spinners.error?).to eq(true)
+    expect(callbacks).to match_array(%i[done error])
+  end
+
+  it "returns true when any spinner failed" do
+    spinners = TTY::Spinner::Multi.new(output: output)
+    sp1 = spinners.register("one")
+    sp2 = spinners.register("two")
+
+    sp1.success
+    sp2.error
+
+    expect(spinners.error?).to eq(true)
+  end
+
+  it "updates top spinner error state based on child spinners jobs failure" do
+    spinners = TTY::Spinner::Multi.new("top", output: output)
+
+    spinners.register("one") { |sp| sp.success }
+    spinners.register("two") { |sp| sp.error }
+
+    expect(spinners.error?).to eq(false)
+
+    spinners.auto_spin
+
+    expect(spinners.error?).to eq(true)
+  end
+end

data/lib/tty-spinner/spec/unit/multi/line_inset_spec.rb

@@ -0,0 +1,57 @@
+RSpec.describe TTY::Spinner::Multi, "#line_inset" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "doesn't create inset when no top level spinner" do
+    spinners = TTY::Spinner::Multi.new(output: output)
+
+    spinner = spinners.register "example"
+
+    expect(spinners.line_inset(spinner)).to eq("")
+  end
+
+  it "defaults to the empty string for the top level spinner" do
+    spinners = TTY::Spinner::Multi.new("Top level spinner", output: output)
+
+    expect(spinners.line_inset(1))
+      .to eq(TTY::Spinner::Multi::DEFAULT_INSET[:top])
+  end
+
+  it "returns four spaces when there is a top level spinner" do
+    spinners = TTY::Spinner::Multi.new("Top level spinner", output: output)
+
+    spinners.register "middle"
+    spinners.register "bottom"
+
+    expect(spinners.line_inset(2))
+      .to eq(TTY::Spinner::Multi::DEFAULT_INSET[:middle])
+  end
+
+  it "decorates last spinner" do
+    spinners = TTY::Spinner::Multi.new("Top spinner", output: output)
+
+    spinners.register "middle"
+    spinners.register "bottom"
+
+    expect(spinners.line_inset(3))
+      .to eq(TTY::Spinner::Multi::DEFAULT_INSET[:bottom])
+  end
+
+  it "allows customization" do
+    opts = {
+        output: output,
+        indent: 4,
+        style: {
+          top: ". ",
+          middle: "--",
+          bottom: "---"
+        }
+      }
+    spinners = TTY::Spinner::Multi.new("Top level spinner", opts)
+    spinners.register ""
+    spinners.register ""
+
+    expect(spinners.line_inset(1)).to eq(". ")
+    expect(spinners.line_inset(2)).to eq("--")
+    expect(spinners.line_inset(3)).to eq("---")
+  end
+end

data/lib/tty-spinner/spec/unit/multi/on_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe TTY::Spinner::Multi, "#on" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "fails to register a callback with invalid event name" do
+    spinners = TTY::Spinner::Multi.new(output: output)
+
+    expect {
+      spinners.on(:unknown_event) { :noop }
+    }.to raise_error(ArgumentError, /The event unknown_event does not exist/)
+  end
+end

data/lib/tty-spinner/spec/unit/multi/register_spec.rb

@@ -0,0 +1,46 @@
+RSpec.describe TTY::Spinner::Multi, "#register" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "registers a TTY::Spinner instance from a pattern" do
+    spinners = TTY::Spinner::Multi.new(output: output, interval: 100)
+    allow_any_instance_of(TTY::Spinner).to receive(:attach_to)
+    expect_any_instance_of(TTY::Spinner).to receive(:attach_to)
+
+    spinner = spinners.register ""
+
+    expect(spinner).to be_instance_of(TTY::Spinner)
+    expect(spinners.length).to eq(1)
+  end
+
+  it "registers a TTY::Spinner instance from a spinner instance" do
+    spinners = TTY::Spinner::Multi.new(output: output, interval: 100)
+    spinner_to_register = ::TTY::Spinner.new
+
+    spinner = spinners.register spinner_to_register
+
+    expect(spinner).to eq(spinner_to_register)
+    expect(spinners.length).to eq(1)
+  end
+
+  it "raises an erro when given neither a string or spinner instance" do
+    spinners = TTY::Spinner::Multi.new(output: output, interval: 100)
+
+    expect { spinners.register [] }
+      .to raise_error(
+        ArgumentError,
+        "Expected a pattern or spinner, got: Array"
+      )
+  end
+
+  it "uses global options to register instance" do
+    spinners = TTY::Spinner::Multi.new(output: output, interval: 100)
+    spinner = double(:spinner, attach_to: nil)
+    allow(spinner).to receive(:on).and_return(spinner)
+    allow(TTY::Spinner).to receive(:new).and_return(spinner)
+
+    spinners.register "[:spinner]"
+
+    expect(TTY::Spinner).to have_received(:new)
+      .with("[:spinner]", {interval: 100, output: output})
+  end
+end

data/lib/tty-spinner/spec/unit/multi/spin_spec.rb

@@ -0,0 +1,101 @@
+RSpec.describe TTY::Spinner::Multi, "#spin" do
+  let(:output) { StringIO.new("", "w+") }
+  let(:save)    { TTY::Cursor.save }
+  let(:restore) { TTY::Cursor.restore }
+  let(:top) { TTY::Spinner::Multi::DEFAULT_INSET[:top] }
+  let(:middle) { TTY::Spinner::Multi::DEFAULT_INSET[:middle] }
+  let(:bottom) { TTY::Spinner::Multi::DEFAULT_INSET[:bottom] }
+
+  it "spins spinners correctly under multi spinner" do
+    spinners = TTY::Spinner::Multi.new(output: output)
+
+    spinner1 = spinners.register(":spinner one")
+    spinner2 = spinners.register(":spinner two")
+
+    spinner2.spin
+    spinner1.spin
+
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G| two\n",
+      "\e[1G| one\n"
+    ].join)
+
+    spinner1.spin
+
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G| two\n",
+      "\e[1G| one\n",
+      save,
+      "\e[1A",          # up 1 line
+      "\e[1G/ one",
+      restore
+    ].join)
+
+    spinner2.spin
+
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G| two\n",
+      "\e[1G| one\n",
+      save,
+      "\e[1A",          # up 1 line
+      "\e[1G/ one",
+      restore,
+      save,
+      "\e[2A",          # up 2 lines
+      "\e[1G/ two",
+      restore
+    ].join)
+  end
+
+  it "spins registerd spinners correctly under top level multi spinner" do
+    spinners = TTY::Spinner::Multi.new(":spinner top", output: output)
+
+    spinner1 = spinners.register(":spinner one")
+    spinner2 = spinners.register(":spinner two")
+
+    spinners.spin
+
+    spinner2.spin
+    spinner1.spin
+
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G#{top}| top\n",
+      "\e[1G#{middle}| two\n",
+      "\e[1G#{bottom}| one\n"
+    ].join)
+
+    spinner1.spin
+
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G#{top}| top\n",
+      "\e[1G#{middle}| two\n",
+      "\e[1G#{bottom}| one\n",
+      save,
+      "\e[1A",          # up 1 line
+      "\e[1G#{bottom}/ one",
+      restore
+    ].join)
+
+    spinner2.spin
+
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G#{top}| top\n",
+      "\e[1G#{middle}| two\n",
+      "\e[1G#{bottom}| one\n",
+      save,
+      "\e[1A",          # up 1 line
+      "\e[1G#{bottom}/ one",
+      restore,
+      save,
+      "\e[2A",          # up 2 lines
+      "\e[1G#{middle}/ two",
+      restore
+    ].join)
+  end
+end