tty-spinner 0.8.0 → 0.9.0

data/spec/unit/multi/on_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+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) { }
+    }.to raise_error(ArgumentError, /The event unknown_event does not exist/)
+  end
+end

data/spec/unit/multi/register_spec.rb

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

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

data/spec/unit/multi/stop_spec.rb

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

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

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

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

data/spec/unit/reset_spec.rb

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