tty-spinner 0.8.0 → 0.9.0

data/spec/unit/auto_spin_spec.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+RSpec.describe TTY::Spinner, '#auto_spin' do
+  let(:output) { StringIO.new('', 'w+') }
+
+  it "starts and auto spins" do
+    spinner = TTY::Spinner.new(output: output, interval: 100)
+    allow(spinner).to receive(:spin)
+
+    spinner.auto_spin
+    sleep 0.1
+    spinner.stop
+
+    expect(spinner).to have_received(:spin).at_least(5).times
+  end
+
+  it "restores cursor when erorr is raised" do
+    spinner = TTY::Spinner.new(output: output, hide_cursor: true)
+
+    spinner.auto_spin {
+      raise 'boom'
+    }
+
+    output.rewind
+    expect(output.read).to start_with("\e[?25l").and end_with("\e[?25h")
+  end
+end

data/spec/unit/clear_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+RSpec.describe TTY::Spinner, ':clear' do
+  let(:output) { StringIO.new('', 'w+') }
+
+  it "clears output when done" do
+    spinner = TTY::Spinner.new(clear: true, output: output)
+    3.times { spinner.spin }
+    spinner.stop('Done!')
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G|",
+      "\e[1G/",
+      "\e[1G-",
+      "\e[0m\e[2K\e[1G"
+    ].join)
+  end
+end

data/spec/unit/error_spec.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+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
+end

data/spec/unit/events_spec.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+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([: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([:done, :error])
+  end
+end

data/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|
+    specify "#{token} contains proper defaults properties" do
+      expect(properties.keys.sort).to eq(%i[frames interval])
+    end
+  end
+end

data/spec/unit/frames_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+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/spec/unit/hide_cursor_spec.rb

@@ -0,0 +1,53 @@
+# coding: utf-8
+
+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/spec/unit/job_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+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/spec/unit/join_spec.rb

@@ -0,0 +1,12 @@
+# coding: utf-8
+
+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/spec/unit/multi/auto_spin_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+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(['one', 'two'])
+  end
+end

data/spec/unit/multi/error_spec.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+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([: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([: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([: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([: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/spec/unit/multi/line_inset_spec.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+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