tty-progressbar 0.11.0 → 0.12.0

data/spec/unit/inspect_spec.rb

@@ -3,7 +3,7 @@
 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="=", @incomplete=" ", @interval="">})
+    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

data/spec/unit/iterate_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+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)
+    bar.iterate(20.times, 5) {  }
+
+    expect(bar.complete?).to eq(true)
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G[=====               ]",
+      "\e[1G[==========          ]",
+      "\e[1G[===============     ]",
+      "\e[1G[====================]\n"
+    ].join)
+  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
+end

data/spec/unit/multi/advance_spec.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+
+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)
+
+    bars.start
+
+    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",
+      save,
+      "\e[3A",   # up 3 lines
+      "\e[1G#{top}[==        ] main",
+      restore
+    ].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,
+      save,
+      "\e[3A",   # up 3 lines
+      "\e[1G#{top}[===       ] main",
+      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,
+      save,
+      "\e[3A",   # up 3 lines
+      "\e[1G#{top}[====      ] main",
+      restore
+    ].join)
+  end
+end

data/spec/unit/multi/events_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+RSpec.describe TTY::ProgressBar::Multi, 'events' do
+  let(:output) { StringIO.new('', 'w+') }
+
+  it "emits :progress eent 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" 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])
+  end
+
+  it "emits :done event when top level bar finished" do
+    events = []
+    bars = TTY::ProgressBar::Multi.new("[:bar]", output: output, total: 5)
+    bars.on(:done) { events << :done }
+
+    bars.register "one [:bar]"
+
+    bars.finish
+
+    expect(events).to eq([:done])
+  end
+
+  it "emits :stopped event when all registerd bars are stopped" 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])
+  end
+
+  it "emits :stopped event when top level 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
+end

data/spec/unit/multi/finish_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+RSpec.describe TTY::ProgressBar::Multi, '#finish' do
+  let(:output) { StringIO.new('', 'w+') }
+
+  it "finishes all bars" 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
+end

data/spec/unit/multi/line_inset_spec.rb

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

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+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(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/stop_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+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/new_spec.rb

@@ -3,6 +3,12 @@
 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 "displays output where width == total" do
     progress = TTY::ProgressBar.new("[:bar]", output: output, total: 10)
     progress.advance

data/spec/unit/reset_spec.rb

@@ -11,7 +11,6 @@ RSpec.describe TTY::ProgressBar, '#reset' do
     output.rewind
     expect(output.read).to eq([
       "\e[1G[=====     ]",
-      "\e[1G[          ]",
       "\e[1G[===       ]",
       "\e[1G[======    ]"
     ].join)
@@ -27,7 +26,6 @@ RSpec.describe TTY::ProgressBar, '#reset' do
     output.rewind
     expect(output.read).to eq([
       "\e[1G[==========]\n",
-      "\e[1G[          ]",
       "\e[1G[===       ]",
       "\e[1G[======    ]"
     ].join)

data/spec/unit/stop_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+RSpec.describe TTY::ProgressBar, '#stop' do
+  let(:output) { StringIO.new('', 'w+') }
+
+  it 'stops progress' do
+    progress = TTY::ProgressBar.new("[:bar]", output: output, total: 10)
+    5.times { |i|
+      progress.stop if i == 3
+      progress.advance
+    }
+    expect(progress.complete?).to be(false)
+    output.rewind
+    expect(output.read).to eq([
+      "\e[1G[=         ]",
+      "\e[1G[==        ]",
+      "\e[1G[===       ]",
+      "\e[1G[===       ]\n"
+    ].join)
+  end
+end