tty-progressbar 0.14.0 → 0.18.0

data/spec/unit/frequency_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe TTY::ProgressBar, 'frequency' do
-  let(:output) { StringIO.new('', 'w+') }
-
-  before { Timecop.safe_mode = false }
-
-  it "limits frequency to 500Hz, permiting every second one" do
-    time_now = Time.local(2014, 10, 5, 12, 0, 0, 0)
-    Timecop.freeze(time_now)
-    progress = TTY::ProgressBar.new("[:bar]", output: output, total: 10, frequency: 500)
-
-    10.times do |sec|
-      time_now = Time.local(2014, 10, 5, 12, 0, 0, sec * 1000)
-      Timecop.freeze(time_now)
-      progress.advance
-    end
-
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G[===       ]",
-      "\e[1G[=====     ]",
-      "\e[1G[=======   ]",
-      "\e[1G[========= ]",
-      "\e[1G[==========]\n"
-    ].join)
-    Timecop.return
-  end
-end

data/spec/unit/head_spec.rb

@@ -1,32 +0,0 @@
-RSpec.describe TTY::ProgressBar, ':head' do
-  let(:output) { StringIO.new('', 'w+')}
-
-  it "animates head" do
-    progress = TTY::ProgressBar.new("[:bar]", output: output, head: '>', total: 5)
-    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 "customises all output characters" do
-    progress = TTY::ProgressBar.new("[:bar]",
-      output: output,
-      head: 'ᗧ',
-      complete: '-', incomplete: '.', total: 5)
-    5.times { progress.advance }
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G[ᗧ....]",
-      "\e[1G[-ᗧ...]",
-      "\e[1G[--ᗧ..]",
-      "\e[1G[---ᗧ.]",
-      "\e[1G[----ᗧ]\n"
-    ].join)
-  end
-end

data/spec/unit/hide_cursor_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe TTY::ProgressBar, '#hide_cursor' do
-  let(:output) { StringIO.new('', 'w+') }
-
-  it "hides cursor" do
-    progress = TTY::ProgressBar.new("[:bar]", output: output,
-      total: 5, hide_cursor: true)
-    5.times { progress.advance }
-    output.rewind
-    expect(output.read).to eq([
-      "\e[?25l\e[1G[=    ]",
-      "\e[1G[==   ]",
-      "\e[1G[===  ]",
-      "\e[1G[==== ]",
-      "\e[?25h\e[1G[=====]\n"
-    ].join)
-  end
-
-  it "reenables cursor on finish" do
-    progress = TTY::ProgressBar.new("[:bar]", output: output,
-      total: 5, hide_cursor: true)
-
-    progress.advance(6)
-    expect(progress.complete?).to eq(true)
-    output.rewind
-    expect(output.read).to eq("\e[1G[=====]\n")
-  end
-end

data/spec/unit/inspect_spec.rb

@@ -1,11 +0,0 @@
-RSpec.describe TTY::ProgressBar, '#inspect' do
-  it "inspects bar properties" do
-    bar = described_class.new("downloading [:bar] :total", total: 30)
-    expect(bar.inspect).to eq(%q{#<TTY::ProgressBar @format="downloading [:bar] :total", @current="0", @total="30", @width="30", @complete="=", @head="=", @incomplete=" ", @interval="1">})
-  end
-
-  it "prints string format" do
-    bar = described_class.new("downloading [:bar] :total", total: 30)
-    expect(bar.to_s).to eq("downloading [:bar] :total")
-  end
-end

data/spec/unit/iterate_spec.rb

@@ -1,79 +0,0 @@
-RSpec.describe TTY::ProgressBar, '#iterate' do
-  let(:output) { StringIO.new('', 'w+') }
-
-  it "iterates over a collection and yields" do
-    bar = TTY::ProgressBar.new("[:bar]", output: output)
-    values = []
-    bar.iterate(5.times) { |val| values << val}
-
-    expect(bar.complete?).to eq(true)
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G[=    ]",
-      "\e[1G[==   ]",
-      "\e[1G[===  ]",
-      "\e[1G[==== ]",
-      "\e[1G[=====]\n"
-    ].join)
-    expect(values).to eq([0, 1, 2, 3, 4])
-  end
-
-  it "iterates over a collection with a step" do
-    bar = TTY::ProgressBar.new("[:bar]", output: output)
-    values = []
-    bar.iterate(4.times, 5) { |val| values << val }
-
-    expect(bar.complete?).to eq(true)
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G[=====               ]",
-      "\e[1G[==========          ]",
-      "\e[1G[===============     ]",
-      "\e[1G[====================]\n"
-    ].join)
-    expect(values).to eq([0, 1, 2, 3])
-  end
-
-  it "iterates over a collection and returns enumerable" do
-    bar = TTY::ProgressBar.new("[:bar]", output: output)
-    values = []
-    progress = bar.iterate(5.times)
-
-    expect(bar.complete?).to eq(false)
-
-    progress.each { |v| values << v }
-
-    expect(values).to eq([0,1,2,3,4])
-  end
-
-  it "does not uses collection's count if total is provided" do
-    bar = TTY::ProgressBar.new("[:bar]", output: output, total: 5)
-    iterable = 5.times
-    expect(iterable).not_to receive(:count)
-    progress = bar.iterate(iterable)
-    values = []
-
-    progress.each { |v| values << v }
-
-    expect(values).to eq([0,1,2,3,4])
-  end
-
-  it "iterates over an infinite enumerator and renders bar correctly" do
-    bar = TTY::ProgressBar.new("[:bar]", output: output, total: 5)
-    infinite_iter = (1..Float::INFINITY).lazy
-
-    progress = bar.iterate(infinite_iter)
-
-    10.times { progress.next }
-
-    expect(bar.complete?).to eq(true)
-    output.rewind
-    expect(output.read).to eq([
-      "\e[1G[=    ]",
-      "\e[1G[==   ]",
-      "\e[1G[===  ]",
-      "\e[1G[==== ]",
-      "\e[1G[=====]\n"
-    ].join)
-  end
-end

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