tty-progressbar 0.15.1 → 0.18.2

data/spec/unit/multi/events_spec.rb

@@ -1,115 +0,0 @@
-RSpec.describe TTY::ProgressBar::Multi, 'events' do
-  let(:output) { StringIO.new('', 'w+') }
-
-  it "emits :progress event when any of the registerd bars advances" do
-    events = []
-    bars = TTY::ProgressBar::Multi.new("[:bar]", output: output, total: 5)
-    bars.on(:progress) { events << :progress }
-
-    bar = bars.register "one [:bar]"
-    bar.advance
-
-    expect(events).to eq([:progress])
-  end
-
-  it "emits :done event when all progress bars finished under top level" do
-    events = []
-    bars = TTY::ProgressBar::Multi.new("[:bar]", output: output, total: 5)
-    bars.on(:done) { events << :done }
-    bar = bars.register "one [:bar]"
-
-    bar.finish
-
-    expect(events).to eq([:done])
-    expect(bar.complete?).to eq(true)
-  end
-
-  it "emits :done event when all progress bars finished without top level" do
-    events = []
-    bars = TTY::ProgressBar::Multi.new(output: output)
-    bars.on(:done) { events << :done }
-    bar = bars.register "one [:bar]", total: 5
-
-    bar.finish
-
-    expect(events).to eq([:done])
-    expect(bars.complete?).to eq(true)
-  end
-
-  it "emits :done event when top level registered bar finished" do
-    events = []
-    bars = TTY::ProgressBar::Multi.new("[:bar]", output: output, total: 5)
-    bars.on(:done) { events << :done }
-
-    bar = bars.register "one [:bar]", total: 5
-
-    bars.finish
-
-    expect(events).to eq([:done])
-    expect(bar.complete?).to eq(true)
-  end
-
-  it "emits :done event when top level bar finished" do
-    events = []
-    bars = TTY::ProgressBar::Multi.new(output: output)
-    bars.on(:done) { events << :done }
-
-    bar = bars.register "one [:bar]", total: 5
-
-    bars.finish
-
-    expect(events).to eq([:done])
-    expect(bar.complete?).to eq(true)
-  end
-
-  it "emits :stopped event when all registerd bars are stopped under top level" do
-    events = []
-    bars = TTY::ProgressBar::Multi.new("[:bar]", output: output, total: 5)
-    bars.on(:stopped) { events << :stopped }
-
-    bar = bars.register "one [:bar]"
-
-    bar.stop
-
-    expect(events).to eq([:stopped])
-    expect(bars.stopped?).to eq(true)
-  end
-
-  it "emits :stopped event when all registerd bars are stopped without top level" do
-    events = []
-    bars = TTY::ProgressBar::Multi.new(output: output)
-    bars.on(:stopped) { events << :stopped }
-
-    bar = bars.register "one [:bar]", total: 5
-
-    bar.stop
-
-    expect(events).to eq([:stopped])
-    expect(bars.stopped?).to eq(true)
-  end
-
-  it "emits :stopped event when registerd multi bar finished" do
-    events = []
-    bars = TTY::ProgressBar::Multi.new("[:bar]", output: output, total: 5)
-    bars.on(:stopped) { events << :stopped }
-
-    bars.register "one [:bar]"
-
-    bars.stop
-
-    expect(events).to eq([:stopped])
-  end
-
-  it "emits :stopped event when multi bar finished" do
-    events = []
-    bars = TTY::ProgressBar::Multi.new(output: output)
-    bars.on(:stopped) { events << :stopped }
-
-    bars.register "one [:bar]", total: 5
-
-    bars.stop
-
-    expect(events).to eq([:stopped])
-    expect(bars.stopped?).to eq(true)
-  end
-end

data/spec/unit/multi/finish_spec.rb

@@ -1,41 +0,0 @@
-RSpec.describe TTY::ProgressBar::Multi, '#finish' do
-  let(:output) { StringIO.new('', 'w+') }
-
-  it "finishes all bars with top level" do
-    bars = TTY::ProgressBar::Multi.new("main [:bar]", output: output)
-
-    bar1 = bars.register("[:bar]", total: 5)
-    bar2 = bars.register("[:bar]", total: 10)
-
-    expect(bars.complete?).to eq(false)
-
-    bar1.finish
-    bar2.finish
-
-    expect(bars.complete?).to eq(true)
-  end
-
-  it "finishes all bars without top level" do
-    bars = TTY::ProgressBar::Multi.new(output: output)
-
-    bar1 = bars.register("[:bar]", total: 5)
-    bar2 = bars.register("[:bar]", total: 10)
-
-    bar1.finish
-    bar2.finish
-
-    expect(bars.complete?).to eq(true)
-  end
-
-  it "finishes top level" do
-    bars = TTY::ProgressBar::Multi.new(output: output)
-
-    bar1 = bars.register("[:bar]", total: 5)
-    bar2 = bars.register("[:bar]", total: 10)
-
-    bars.finish
-
-    expect(bar1.complete?).to eq(true)
-    expect(bar2.complete?).to eq(true)
-  end
-end

data/spec/unit/multi/line_inset_spec.rb

@@ -1,65 +0,0 @@
-RSpec.describe TTY::ProgressBar::Multi, '#line_inset' do
-  let(:output) { StringIO.new('', 'w+') }
-
-  it "doesn't create inset when no top level bar" do
-    bars = TTY::ProgressBar::Multi.new(output: output)
-
-    bar = bars.register 'example'
-
-    expect(bars.line_inset(bar)).to eq('')
-  end
-
-  it "defaults to the empty string for the top level bar" do
-    bars = TTY::ProgressBar::Multi.new("Top level spinner", output: output)
-
-    expect(bars.line_inset(bars.top_bar))
-      .to eq(TTY::ProgressBar::Multi::DEFAULT_INSET[:top])
-  end
-
-  it "returns middle character for a top level bar" do
-    bars = TTY::ProgressBar::Multi.new("Top level bar", output: output)
-
-    bar = bars.register 'middle', total: 10
-    bar2 = bars.register 'bottom', total: 10
-
-    bar.start
-    bar2.start
-
-    expect(bars.line_inset(bar))
-      .to eq(TTY::ProgressBar::Multi::DEFAULT_INSET[:middle])
-  end
-
-  it "decorates last bar" do
-    bars = TTY::ProgressBar::Multi.new("Top spinner", output: output)
-
-    bar1 = bars.register 'middle', total: 10
-    bar = bars.register 'bottom', total: 10
-
-    bar1.start
-    bar.start
-
-    expect(bars.line_inset(bar))
-      .to eq(TTY::ProgressBar::Multi::DEFAULT_INSET[:bottom])
-  end
-
-  it "allows customization" do
-    opts = {
-        output: output,
-        style: {
-          top: ". ",
-          middle: "--",
-          bottom: "---",
-        }
-      }
-    bars = TTY::ProgressBar::Multi.new("Top level spinner", opts)
-    middle_bar = bars.register "", total: 10
-    bottom_bar = bars.register "", total: 10
-
-    middle_bar.start
-    bottom_bar.start
-
-    expect(bars.line_inset(bars.top_bar)).to eq(". ")
-    expect(bars.line_inset(middle_bar)).to eq("--")
-    expect(bars.line_inset(bottom_bar)).to eq("---")
-  end
-end

data/spec/unit/multi/register_spec.rb

@@ -1,35 +0,0 @@
-RSpec.describe TTY::ProgressBar::Multi, '#register' do
-  let(:output) { StringIO.new('', 'w+') }
-
-  it "registers a TTY::ProgressBar instance" do
-    bars = TTY::ProgressBar::Multi.new(output: output)
-    allow_any_instance_of(TTY::ProgressBar).to receive(:attach_to)
-    expect_any_instance_of(TTY::ProgressBar).to receive(:attach_to)
-
-    bar = bars.register("[:bar]")
-
-    expect(bar).to be_instance_of(TTY::ProgressBar)
-    expect(bars.length).to eq(1)
-  end
-
-  it "uses global options to register instance" do
-    bars = TTY::ProgressBar::Multi.new(output: output, total: 100)
-    bar = double(:bar, attach_to: nil)
-    allow(bar).to receive(:on).and_return(bar)
-    allow(TTY::ProgressBar).to receive(:new).and_return(bar)
-
-    bars.register("[:bar]")
-
-    expect(TTY::ProgressBar).to have_received(:new).with("[:bar]", {total: 100, output: output})
-  end
-
-  it "registers bars with top level" do
-    bars = TTY::ProgressBar::Multi.new("main [:bar]", output: output)
-
-    bars.register("[:bar]", total: 5)
-    bars.register("[:bar]", total: 10)
-
-    expect(bars.total).to eq(15)
-    expect(bars.current).to eq(0)
-  end
-end

data/spec/unit/multi/reset_spec.rb

@@ -1,28 +0,0 @@
-RSpec.describe TTY::ProgressBar::Multi, '#reset' do
-  let(:output) { StringIO.new('', 'w+') }
-
-  it "leaves multibar state alone" do
-    main = TTY::ProgressBar::Multi.new("", output: output, total: 10)
-    progress = main.register("[:bar]")
-    progress.advance(10)
-    expect(progress.complete?).to be(true)
-    progress.reset
-    expect(progress.complete?).to be(false)
-    progress.advance(10)
-    output.rewind
-
-    top    = TTY::ProgressBar::Multi::DEFAULT_INSET[:top]
-    bottom = TTY::ProgressBar::Multi::DEFAULT_INSET[:bottom]
-
-    progress_updates =
-      output.read.scan(/#{Regexp.escape top}|#{Regexp.escape bottom}/)
-    expect(progress_updates.shift).to match(top)
-    expect(progress_updates.shift).to match(top)
-    expect(progress_updates.shift).to match(bottom)
-    expect(progress_updates.shift).to match(bottom)
-    expect(progress_updates.shift).to match(bottom)
-    expect(progress_updates.shift).to match(bottom)
-
-    expect(progress_updates).to be_empty
-  end
-end

data/spec/unit/multi/stop_spec.rb

@@ -1,15 +0,0 @@
-RSpec.describe TTY::ProgressBar::Multi, '#stop' do
-  let(:output) { StringIO.new('', 'w+') }
-
-  it "stops all bars when top level stops" do
-    bars = TTY::ProgressBar::Multi.new("main [:bar]", output: output)
-
-    bar1 = bars.register("[:bar]", total: 5)
-    bar2 = bars.register("[:bar]", total: 10)
-
-    bars.stop
-
-    expect(bar1.stopped?).to eq(true)
-    expect(bar2.stopped?).to eq(true)
-  end
-end

data/spec/unit/multi/width_spec.rb

@@ -1,118 +0,0 @@
-RSpec.describe TTY::ProgressBar::Multi, 'width' do
-  let(:output) { StringIO.new('', 'w+') }
-  let(:save)    { TTY::Cursor.save }
-  let(:restore) { TTY::Cursor.restore }
-  let(:top) { TTY::ProgressBar::Multi::DEFAULT_INSET[:top] }
-  let(:middle) { TTY::ProgressBar::Multi::DEFAULT_INSET[:middle] }
-  let(:bottom) { TTY::ProgressBar::Multi::DEFAULT_INSET[:bottom] }
-
-  it "sets top level bar width to maximum columns when exceeds terminal width" do
-    allow(TTY::Screen).to receive(:width).and_return(15)
-
-    bars = TTY::ProgressBar::Multi.new("[:bar] main", output: output)
-
-    bar1 = bars.register("[:bar] one", total: 20)
-    bar2 = bars.register("[:bar] two", total: 20)
-
-    bar1.advance(10)
-    bar2.advance(10)
-
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G#{top}[==    ] main\n",
-      "\e[1G#{bottom}[===  ] one\n",
-      save,
-      "\e[2A",   # up 2 lines
-      "\e[1G#{top}[===   ] main",
-      restore,
-      "\e[1G#{bottom}[===  ] two\n"
-    ].join)
-
-    bar1.advance(10)
-
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G#{top}[==    ] main\n",
-      "\e[1G#{bottom}[===  ] one\n",
-      save,
-      "\e[2A",   # up 2 lines
-      "\e[1G#{top}[===   ] main",
-      restore,
-      "\e[1G#{bottom}[===  ] two\n",
-      save,
-      "\e[3A",   # up 3 lines
-      "\e[1G#{top}[===== ] main",
-      restore,
-      save,
-      "\e[2A",   # up 2 lines
-      "\e[1G#{middle}[=====] one",
-      restore,
-      save,
-      "\e[2A",   # up 2 lines
-      "#{middle}\n", # bar finished
-      restore
-    ].join)
-
-    bar2.advance(10)
-
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G#{top}[==    ] main\n",
-      "\e[1G#{bottom}[===  ] one\n",
-      save,
-      "\e[2A",   # up 2 lines
-      "\e[1G#{top}[===   ] main",
-      restore,
-      "\e[1G#{bottom}[===  ] two\n",
-      save,
-      "\e[3A",   # up 3 lines
-      "\e[1G#{top}[===== ] main",
-      restore,
-      save,
-      "\e[2A",   # up 2 lines
-      "\e[1G#{middle}[=====] one",
-      restore,
-      save,
-      "\e[2A",   # up 2 lines
-      "#{middle}\n", # bar finished
-      restore,
-      save,
-      "\e[3A",   # up 3 lines
-      "\e[1G#{top}[======] main",
-      restore,
-      save,
-      "\e[3A",  # up 1 line
-      "#{top}\n",
-      restore,
-      save,
-      "\e[1A",  # up 1 line
-      "\e[1G#{bottom}[=====] two",
-      restore,
-      save,
-      "\e[1A",  # up 1 line
-      "#{bottom}\n",
-      restore
-    ].join)
-  end
-
-  it "sets top level bar width to a custom value" do
-    bars = TTY::ProgressBar::Multi.new("[:bar] main", output: output, width: 20)
-
-    bar1 = bars.register("[:bar] one", total: 20)
-    bar2 = bars.register("[:bar] two", total: 20)
-
-    bar1.advance(10)
-    bar2.advance(10)
-
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G#{top}[=====               ] main\n",
-      "\e[1G#{bottom}[==========          ] one\n",
-      save,
-      "\e[2A",   # up 2 lines
-      "\e[1G#{top}[==========          ] main",
-      restore,
-      "\e[1G#{bottom}[==========          ] two\n"
-    ].join)
-  end
-end

data/spec/unit/new_spec.rb

@@ -1,76 +0,0 @@
-RSpec.describe TTY::ProgressBar, '::new' do
-  let(:output) { StringIO.new('', 'w+') }
-
-  it "fails to initialize without formatting string" do
-    expect {
-      TTY::ProgressBar.new(output: output)
-    }.to raise_error(ArgumentError, /Expected bar formatting string, got `{:output=>#{output}}` instead\./)
-  end
-
-  it "allows to change formatting string" do
-    bar = TTY::ProgressBar.new("[:bar]", output: output, total: 4)
-    bar.advance(2)
-    bar.format = "(:bar)"
-    bar.advance(2)
-    output.rewind
-
-    expect(output.read).to eq("\e[1G[==  ]\e[1G(====)\n")
-  end
-
-  it "displays output where width == total" do
-    progress = TTY::ProgressBar.new("[:bar]", output: output, total: 10)
-    progress.advance
-    output.rewind
-    expect(output.read).to eq("\e[1G[=         ]")
-  end
-
-  it "yields configuration to block" do
-    progress = TTY::ProgressBar.new "[:bar]" do |config|
-      config.output = output
-      config.total  = 10
-      config.clear  = true
-    end
-    expect(progress.output).to eq(output)
-    expect(progress.total).to eq(10)
-    expect(progress.width).to eq(10)
-    expect(progress.clear).to eq(true)
-  end
-
-  it "displays output where width > total" do
-    progress = TTY::ProgressBar.new("[:bar]", output: output, total: 5, width: 10)
-    5.times { progress.advance }
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G[==        ]",
-      "\e[1G[====      ]",
-      "\e[1G[======    ]",
-      "\e[1G[========  ]",
-      "\e[1G[==========]\n"
-    ].join)
-  end
-
-  it "displays output where width < total" do
-    progress = TTY::ProgressBar.new("[:bar]", output: output, total: 10, width: 5)
-    10.times { progress.advance }
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G[=    ]",
-      "\e[1G[=    ]",
-      "\e[1G[==   ]",
-      "\e[1G[==   ]",
-      "\e[1G[===  ]",
-      "\e[1G[===  ]",
-      "\e[1G[==== ]",
-      "\e[1G[==== ]",
-      "\e[1G[=====]",
-      "\e[1G[=====]\n"
-    ].join)
-  end
-
-  it "displays total value" do
-    progress = TTY::ProgressBar.new("|:total|", output: output, total: 10)
-    progress.advance(3)
-    output.rewind
-    expect(output.read).to eq("\e[1G|10|")
-  end
-end