planter-cli 3.0.1 → 3.0.2

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

@@ -0,0 +1,95 @@
+RSpec.describe TTY::Spinner::Multi, "#stop" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "stops unregisterd multi spinner and emits a :done message" do
+    spinners = TTY::Spinner::Multi.new(output: output)
+    callbacks = []
+    sp1 = spinners.register "[:spinner] one"
+    sp2 = spinners.register "[:spinner] two"
+
+    expect(sp1.done?).to eq(false)
+    expect(sp2.done?).to eq(false)
+
+    spinners.on(:error)   { callbacks << :error }
+            .on(:done)    { callbacks << :done }
+            .on(:success) { callbacks << :success }
+
+    spinners.stop
+
+    expect(sp1.done?).to eq(true)
+    expect(sp2.done?).to eq(true)
+    expect(callbacks).to eq([:done])
+  end
+
+  it "stops registerd multi spinner and emits a :done message" do
+    spinners = TTY::Spinner::Multi.new(":spinner", output: output)
+    callbacks = []
+    sp1 = spinners.register "[:spinner] one"
+    sp2 = spinners.register "[:spinner] two"
+
+    expect(sp1.done?).to eq(false)
+    expect(sp2.done?).to eq(false)
+
+    spinners.on(:error)   { callbacks << :error }
+            .on(:done)    { callbacks << :done }
+            .on(:success) { callbacks << :success }
+
+    spinners.stop
+
+    expect(sp1.done?).to eq(true)
+    expect(sp2.done?).to eq(true)
+    expect(callbacks).to eq([:done])
+  end
+
+  it "stops all registered spinners and emits a :done message" do
+    spinners = TTY::Spinner::Multi.new(output: output)
+    callbacks = []
+    sp1 = spinners.register "[:spinner] one"
+    sp2 = spinners.register "[:spinner] two"
+
+    expect(sp1.done?).to eq(false)
+    expect(sp2.done?).to eq(false)
+
+    spinners.on(:error)   { callbacks << :error }
+            .on(:done)    { callbacks << :done }
+            .on(:success) { callbacks << :success }
+
+    sp1.stop
+    sp2.stop
+
+    expect(spinners.done?).to eq(true)
+    expect(callbacks).to eq([:done])
+  end
+
+  it "stops all registered spinners under multispinner and emits a :done message" do
+    spinners = TTY::Spinner::Multi.new(":spinner", output: output)
+    callbacks = []
+    sp1 = spinners.register "[:spinner] one"
+    sp2 = spinners.register "[:spinner] two"
+
+    expect(sp1.done?).to eq(false)
+    expect(sp2.done?).to eq(false)
+
+    spinners.on(:error)   { callbacks << :error }
+            .on(:done)    { callbacks << :done }
+            .on(:success) { callbacks << :success }
+
+    sp1.stop
+    sp2.stop
+
+    expect(spinners.done?).to eq(true)
+    expect(callbacks).to eq([:done])
+  end
+
+  it "returns true when spinner is done" do
+    spinners = TTY::Spinner::Multi.new(output: output)
+
+    sp1 = spinners.register "[:spinner] one"
+    sp2 = spinners.register "[:spinner] two"
+
+    sp1.stop
+    sp2.error
+
+    expect(spinners.done?).to eq(true)
+  end
+end

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

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

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Spinner, "#new" do
+  it "creates spinner with default format" do
+    spinner = TTY::Spinner.new
+    expect(spinner.format).to eq(:classic)
+  end
+
+  it "doesn't accept unknown formatting tokens" do
+    expect {
+      TTY::Spinner.new(format: :unknown)
+    }.to raise_error(ArgumentError, /Unknown format token `:unknown`/)
+  end
+
+  it "creates spinner with custom format" do
+    spinner = TTY::Spinner.new("Initializing... :spinner ")
+    expect(spinner.message).to eq("Initializing... :spinner ")
+  end
+
+  it "allows to set default output" do
+    output = $stdout
+    spinner = TTY::Spinner.new(output: output)
+    expect(spinner.output).to eq(output)
+  end
+end

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

@@ -0,0 +1,43 @@
+RSpec.describe TTY::Spinner, "#pause" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "allows to pause auto spinning" do
+    spinner = TTY::Spinner.new(output: output, interval: 100)
+    allow(spinner).to receive(:spin)
+
+    spinner.auto_spin
+    expect(spinner.paused?).to eq(false)
+
+    sleep(0.02)
+
+    spinner.pause
+    expect(spinner.paused?).to eq(true)
+
+    spinner.resume
+    expect(spinner.paused?).to eq(true)
+
+    spinner.stop
+
+    expect(spinner).to have_received(:spin).at_least(1)
+  end
+
+  it "pauses auto-spin with a custom mark" do
+    spinner = TTY::Spinner.new("[:spinner]", output: output)
+    thread = spy(:thread)
+    allow(Thread).to receive(:new).and_return(thread)
+    spinner.auto_spin
+
+    allow(spinner).to receive(:paused?).and_return(false)
+    spinner.pause(mark: "?")
+    allow(spinner).to receive(:paused?).and_return(true)
+    spinner.resume
+    spinner.auto_spin
+
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G[|]",
+      "\e[1G[?]",
+      "\e[1G[|]"
+    ].join)
+  end
+end

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

@@ -0,0 +1,19 @@
+RSpec.describe TTY::Spinner, "#reset" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "spins default frames" do
+    spinner = TTY::Spinner.new(output: output)
+    5.times do |n|
+      spinner.spin
+      spinner.reset if n == 2
+    end
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G|",
+      "\e[1G/",
+      "\e[1G-",
+      "\e[1G|",
+      "\e[1G/"
+    ].join)
+  end
+end

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

@@ -0,0 +1,30 @@
+RSpec.describe TTY::Spinner, "#run" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "runs animation while executing block" do
+    spinner = TTY::Spinner.new(output: output, interval: 100)
+    allow(spinner).to receive(:spin)
+    spinner.run("done") { sleep(0.1) }
+    expect(spinner).to have_received(:spin).at_least(5).times
+  end
+
+  it "runs animation and executes block within context" do
+    context = spy("context")
+    spinner = TTY::Spinner.new(":title", output: output)
+
+    spinner.run("done") do
+      context.call
+      spinner.update(title: "executing")
+    end
+
+    expect(context).to have_received(:call).once
+  end
+
+  it "yields spinner instance when block argument is provided" do
+    spinner = TTY::Spinner.new(":title", output: output)
+
+    expect { |job|
+      spinner.run("done", &job)
+    }.to yield_with_args(spinner)
+  end
+end

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

@@ -0,0 +1,117 @@
+RSpec.describe TTY::Spinner, "#spin" do
+  let(:output) { StringIO.new("", "w+") }
+  let(:save)    { TTY::Cursor.save }
+  let(:restore) { TTY::Cursor.restore }
+
+  it "spins default frames" do
+    spinner = TTY::Spinner.new(output: output)
+
+    expect(spinner.done?).to eq(false)
+
+    5.times { spinner.spin }
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G|",
+      "\e[1G/",
+      "\e[1G-",
+      "\e[1G\\",
+      "\e[1G|"
+    ].join)
+  end
+
+  it "spins chosen frame" do
+    spinner = TTY::Spinner.new(output: output, format: :spin)
+    5.times { spinner.spin }
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G◴",
+      "\e[1G◷",
+      "\e[1G◶",
+      "\e[1G◵",
+      "\e[1G◴"
+    ].join)
+  end
+
+  it "spins with message" do
+    spinner = TTY::Spinner.new("Loading ... :spinner", output: output)
+    4.times { spinner.spin }
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1GLoading ... |",
+      "\e[1GLoading ... /",
+      "\e[1GLoading ... -",
+      "\e[1GLoading ... \\"
+    ].join)
+  end
+
+  context "with the cursor" do
+    before do
+      multi_spinner = double("MultiSpinner")
+      allow(multi_spinner).to receive(:synchronize).and_yield
+      allow(multi_spinner).to receive(:next_row).and_return(1)
+      allow(multi_spinner).to receive(:rows).and_return(1)
+      allow(multi_spinner).to receive(:line_inset).and_return("--- ")
+
+      spinner = TTY::Spinner.new(output: output, hide_cursor: hide_cursor)
+      spinner.attach_to(multi_spinner)
+      spinner.spin
+      spinner.redraw_indent
+
+      output.rewind
+    end
+
+    context "on" do
+      let(:hide_cursor) { false }
+
+      it "can spin and redraw indent" do
+        expect(output.read).to eq([
+          "\e[1G--- |\n",
+          save,
+          "\e[1A",
+          "--- ",
+          restore
+        ].join)
+      end
+    end
+
+    context "off" do
+      let(:hide_cursor) { true }
+
+      it "can spin and redraw indent" do
+        expect(output.read).to eq([
+          "--- ",
+          "\e[?25l\n",
+          save,
+          "\e[1A",
+          "\e[1G",
+          "--- |",
+          restore,
+          save,
+          "\e[1A",
+          "--- ",
+          restore
+        ].join)
+      end
+    end
+  end
+
+  it "spins with many threads" do
+    spinner = TTY::Spinner.new(output: output)
+
+    th1 = Thread.new { 3.times { spinner.spin; sleep(0.05) } }
+    th2 = Thread.new { 4.times { spinner.spin; sleep(0.05) } }
+
+    [th1, th2].each(&:join)
+
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G|",
+      "\e[1G/",
+      "\e[1G-",
+      "\e[1G\\",
+      "\e[1G|",
+      "\e[1G/",
+      "\e[1G-"
+    ].join)
+  end
+end

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

@@ -0,0 +1,88 @@
+RSpec.describe TTY::Spinner, "#stop" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "doesn't reprint stop message" do
+    spinner = TTY::Spinner.new(output: output)
+    spinner.spin
+    3.times { spinner.stop }
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G|",
+      "\e[0m\e[2K",
+      "\e[1G|\n"
+    ].join)
+  end
+
+  it "stops after 2 spins" do
+    spinner = TTY::Spinner.new(output: output)
+    5.times do |n|
+      spinner.spin
+      spinner.stop if n == 1
+    end
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G|",
+      "\e[1G/",
+      "\e[0m\e[2K",
+      "\e[1G/\n"
+    ].join)
+  end
+
+  it "stops after 2 spins and prints stop message" do
+    spinner = TTY::Spinner.new(output: output)
+    5.times do |n|
+      spinner.spin
+      spinner.stop("Done!") if n == 1
+    end
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G|",
+      "\e[1G/",
+      "\e[0m\e[2K",
+      "\e[1G/ Done!\n"
+    ].join)
+
+    expect(spinner.done?).to eq(true)
+  end
+
+  it "stops after 2 spins with message and prints stop message" do
+    spinner = TTY::Spinner.new("Loading ... :spinner", output: output)
+    5.times do |n|
+      spinner.spin
+      spinner.stop("Done!") if n == 1
+    end
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1GLoading ... |",
+      "\e[1GLoading ... /",
+      "\e[0m\e[2K",
+      "\e[1GLoading ... / Done!\n"
+    ].join)
+  end
+
+  it "sets a custom mark when done" do
+    spinner = TTY::Spinner.new("[:spinner]", output: output)
+    2.times { spinner.spin }
+    spinner.stop(mark: "!")
+
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G[|]\e[1G[/]",
+      "\e[0m\e[2K",
+      "\e[1G[!]\n"
+    ].join)
+  end
+
+  it "sets a custom message and mark when done" do
+    spinner = TTY::Spinner.new("[:spinner]", output: output)
+    2.times { spinner.spin }
+    spinner.stop("Done", mark: "!")
+
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G[|]\e[1G[/]",
+      "\e[0m\e[2K",
+      "\e[1G[!] Done\n"
+    ].join)
+  end
+end

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

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

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+RSpec.describe TTY::Spinner, "#tty?" do
+  it "responds to tty?" do
+    spinner = TTY::Spinner.new
+    expect(spinner).to respond_to(:tty?)
+  end
+end

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

@@ -0,0 +1,85 @@
+RSpec.describe TTY::Spinner, "#update" do
+  let(:output) { StringIO.new("", "w+") }
+
+  it "updates message content with custom token" do
+    spinner = TTY::Spinner.new(":title :spinner", output: output, interval: 100)
+    spinner.update(title: "task")
+    5.times { spinner.spin }
+    spinner.stop("done")
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1Gtask |",
+      "\e[1Gtask /",
+      "\e[1Gtask -",
+      "\e[1Gtask \\",
+      "\e[1Gtask |",
+      "\e[0m\e[2K",
+      "\e[1Gtask | done\n"
+    ].join)
+  end
+
+  it "updates message many times before stopping" do
+    spinner = TTY::Spinner.new(":title :spinner", output: output)
+
+    spinner.update(title: "task_a")
+    2.times { spinner.spin }
+    spinner.update(title: "task_b")
+    2.times { spinner.spin }
+    spinner.stop("done")
+    output.rewind
+
+    expect(output.read).to eq([
+      "\e[1Gtask_a |",
+      "\e[1Gtask_a /",
+      "\e[0m\e[2K\e[1G",
+      "\e[1Gtask_b -",
+      "\e[1Gtask_b \\",
+      "\e[0m\e[2K",
+      "\e[1Gtask_b \\ done\n"
+    ].join)
+  end
+
+  it "updates message after stopping" do
+    spinner = TTY::Spinner.new(":title :spinner", output: output)
+
+    spinner.update(title: "task_a")
+    2.times { spinner.spin }
+    spinner.stop("done")
+
+    spinner.start
+    spinner.update(title: "task_b")
+    2.times { spinner.spin }
+    spinner.stop("done")
+
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1Gtask_a |",
+      "\e[1Gtask_a /",
+      "\e[0m\e[2K",
+      "\e[1Gtask_a / done\n",
+      "\e[1Gtask_b |",
+      "\e[1Gtask_b /",
+      "\e[0m\e[2K",
+      "\e[1Gtask_b / done\n"
+    ].join)
+  end
+
+  it "maintains current tokens" do
+    spinner = TTY::Spinner.new(":foo :bar", output: output)
+    expect(spinner.tokens).to eq({})
+
+    spinner.update(foo: "FOO")
+    spinner.update(bar: "BAR")
+
+    expect(spinner.tokens).to include({foo: "FOO", bar: "BAR"})
+  end
+
+  it "updates more than one token" do
+    spinner = TTY::Spinner.new(":foo :bar", output: output)
+    expect(spinner.tokens).to eq({})
+
+    spinner.update(foo: "FOO", bar: "BAR")
+
+    expect(spinner.tokens).to include({foo: "FOO", bar: "BAR"})
+  end
+end

data/lib/tty-spinner/tasks/console.rake

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+desc "Load gem inside irb console"
+task :console do
+  require "irb"
+  require "irb/completion"
+  require_relative "../lib/tty-spinner"
+  ARGV.clear
+  IRB.start
+end
+task :c => :console

data/lib/tty-spinner/tasks/coverage.rake

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+desc "Measure code coverage"
+task :coverage do
+  begin
+    original, ENV["COVERAGE"] = ENV["COVERAGE"], "true"
+    Rake::Task["spec"].invoke
+  ensure
+    ENV["COVERAGE"] = original
+  end
+end