tty-spinner 0.9.2 → 0.9.3

data/spec/unit/multi/error_spec.rb

@@ -1,109 +0,0 @@
-# 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

@@ -1,59 +0,0 @@
-# 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

data/spec/unit/multi/on_spec.rb

@@ -1,13 +0,0 @@
-# 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

@@ -1,47 +0,0 @@
-# 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

@@ -1,103 +0,0 @@
-# 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

@@ -1,97 +0,0 @@
-# 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

@@ -1,110 +0,0 @@
-# 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