tty-progressbar 0.17.0 → 0.18.0

data/spec/unit/log_spec.rb

@@ -1,29 +0,0 @@
-RSpec.describe TTY::ProgressBar, '#log' do
-  let(:output) { StringIO.new('', 'w+') }
-
-  it "logs message" do
-    progress = TTY::ProgressBar.new("[:bar]", output: output, total: 10)
-    2.times {
-      progress.log 'foo bar'
-      progress.advance
-    }
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1Gfoo bar\n",
-      "\e[1G[          ]",
-      "\e[1G[=         ]",
-      "\e[1Gfoo bar     \n",
-      "\e[1G[=         ]",
-      "\e[1G[==        ]",
-    ].join)
-  end
-
-  it "logs message under when complete" do
-    progress = TTY::ProgressBar.new("[:bar]", output: output, total: 10)
-    progress.advance(10)
-    expect(progress.complete?).to eq(true)
-    progress.log 'foo bar'
-    output.rewind
-    expect(output.read).to eq("\e[1G[==========]\nfoo bar\n")
-  end
-end

data/spec/unit/meter_spec.rb

@@ -1,70 +0,0 @@
-RSpec.describe TTY::ProgressBar::Meter, '#rate' do
-
-  before { Timecop.safe_mode = false }
-
-  after { Timecop.return }
-
-  it "measures with no samples" do
-    meter = TTY::ProgressBar::Meter.new(1)
-
-    meter.start
-
-    expect(meter.rate).to eq(0)
-    expect(meter.mean_rate).to eq(0)
-  end
-
-  it "measures with a single sample" do
-    meter = TTY::ProgressBar::Meter.new(1)
-    start_time = Time.at(10, 0)
-    Timecop.freeze(start_time)
-    meter.start
-
-    meter.sample(Time.at(10, 100_000), 10)
-
-    expect(meter.rate).to eq(100)
-    expect(meter.mean_rate).to eq(100)
-  end
-
-  it "measures rate per second" do
-    meter = TTY::ProgressBar::Meter.new(1)
-    start_time = Time.at(10, 0)
-    Timecop.freeze(start_time)
-    meter.start
-
-    # First sample batch
-    meter.sample Time.at(10, 100_000), 5
-    expect(meter.rate).to eq(50)
-    expect(meter.mean_rate).to eq(50)
-
-    meter.sample Time.at(10, 500_000), 5
-    expect(meter.rate).to eq(20)
-    expect(meter.mean_rate).to eq(20)
-
-    meter.sample Time.at(11, 000_000), 5
-    expect(meter.rate).to eq(15)
-    expect(meter.mean_rate).to eq(15)
-
-    meter.sample Time.at(11, 500_000), 5
-    expect(meter.rate).to eq(10)
-    expect(meter.mean_rate).to be_within(0.001).of(13.333)
-
-    meter.sample Time.at(12, 000_000), 10
-    expect(meter.rate).to eq(15)
-    expect(meter.mean_rate).to eq(15)
-  end
-
-  it "clears measurements" do
-    meter = TTY::ProgressBar::Meter.new(1)
-    start_time = Time.at(10, 0)
-    Timecop.freeze(start_time)
-    meter.start
-
-    meter.sample(start_time + 1, 1000)
-    expect(meter.rates).to eq([1000, 1000])
-    expect(meter.rate).to eq(1000)
-
-    meter.clear
-    expect(meter.rates).to eq([0])
-    expect(meter.rate).to eq(0)
-  end
-end

data/spec/unit/multi/advance_spec.rb

@@ -1,123 +0,0 @@
-RSpec.describe TTY::ProgressBar::Multi, 'advance' 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 "advances progress bars correctly under multibar" do
-    bars = TTY::ProgressBar::Multi.new(output: output)
-
-    bar1 = bars.register("[:bar] one", total: 5)
-    bar2 = bars.register("[:bar] two", total: 5)
-
-    bar2.advance
-    bar1.advance
-
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G[=    ] two\n",
-      "\e[1G[=    ] one\n"
-    ].join)
-
-    bar2.advance
-
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G[=    ] two\n",
-      "\e[1G[=    ] one\n",
-      save,
-      "\e[2A", # up 2 lines
-      "\e[1G[==   ] two",
-      restore
-    ].join)
-
-    bar1.advance
-
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G[=    ] two\n",
-      "\e[1G[=    ] one\n",
-      save,
-      "\e[2A", # up 2 lines
-      "\e[1G[==   ] two",
-      restore,
-      save,
-      "\e[1A", # up 1 line
-      "\e[1G[==   ] one",
-      restore
-    ].join)
-  end
-
-  it "advances progress bars correctly under top level multibar" do
-    bars = TTY::ProgressBar::Multi.new("[:bar] main", output: output)
-
-    bar1 = bars.register("[:bar] one", total: 5)
-    bar2 = bars.register("[:bar] two", total: 5)
-
-    bar2.advance
-    bar1.advance
-
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G#{top}[=         ] main\n",
-      "\e[1G#{bottom}[=    ] two\n",
-      save,
-      "\e[2A",   # up 2 lines
-      "\e[1G#{top}[==        ] main",
-      restore,
-      "\e[1G#{bottom}[=    ] one\n"
-    ].join)
-
-    bar2.advance
-
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G#{top}[=         ] main\n",
-      "\e[1G#{bottom}[=    ] two\n",
-      save,
-      "\e[2A",   # up 2 lines
-      "\e[1G#{top}[==        ] main",
-      restore,
-      "\e[1G#{bottom}[=    ] one\n",
-      save,
-      "\e[3A",   # up 3 lines
-      "\e[1G#{top}[===       ] main",
-      restore,
-      save,
-      "\e[2A",   # up 2 lines,
-      "\e[1G#{middle}[==   ] two",
-      restore,
-    ].join)
-
-    bar1.advance
-
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G#{top}[=         ] main\n",
-      "\e[1G#{bottom}[=    ] two\n",
-      save,
-      "\e[2A",   # up 2 lines
-      "\e[1G#{top}[==        ] main",
-      restore,
-      "\e[1G#{bottom}[=    ] one\n",
-      save,
-      "\e[3A",   # up 3 lines
-      "\e[1G#{top}[===       ] main",
-      restore,
-      save,
-      "\e[2A",   # up 2 lines,
-      "\e[1G#{middle}[==   ] two",
-      restore,
-      save,
-      "\e[3A",   # up 3 lines
-      "\e[1G#{top}[====      ] main",
-      restore,
-      save,
-      "\e[1A",   # up 1 line
-      "\e[1G#{bottom}[==   ] one",
-      restore
-    ].join)
-  end
-end

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