progress 2.4.0 → 3.0.0

data/spec/progress_spec.rb

@@ -1,321 +1,362 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'rspec'
+require 'progress'
 
 describe Progress do
-  let(:count){ 165 }
 
-  before :each do
-    @io = StringIO.new
-    Progress.instance_variable_set(:@io, @io)
-    def Progress.time_to_print?; true; end
-  end
-
-  def io_pop
-    @io.seek(0)
-    s = @io.read
-    @io.truncate(0)
-    @io.seek(0)
-    s
-  end
+  before do
+    Progress.stay_on_line = true
+    Progress.highlight = true
+    Progress.set_terminal_title = true
 
-  def io_pop_no_eta
-    io_pop.sub(/ \(ETA: \d+.\)$/, '')
+    Progress.stub(:start_beeper)
+    Progress.stub(:time_to_print?).and_return(true)
+    Progress.stub(:eta)
+    Progress.stub(:elapsed).and_return('0s')
   end
 
-  def verify_output_before_step(i, count)
-    io_pop.should =~ /#{Regexp.quote(i == 0 ? '......' : '%5.1f' % (i / count.to_f * 100.0))}/
-  end
-  def verify_output_after_stop
-    io_pop.should =~ /100\.0.*\n$/
-  end
+  describe "integrity" do
 
-  describe 'direct usage' do
-    describe 'procedural' do
-      it "should show valid output when called as Progress.start" do
-        Progress.start('Test', count)
-        count.times do |i|
-          verify_output_before_step(i, count)
-          Progress.step
-        end
-        Progress.stop
-        verify_output_after_stop
-      end
-
-      it "should show valid output when called as Progress" do
-        Progress('Test', count)
-        count.times do |i|
-          verify_output_before_step(i, count)
-          Progress.step
-        end
-        Progress.stop
-        verify_output_after_stop
-      end
+    before do
+      @io = double(:<< => nil, :tty? => true)
+      Progress.stub(:io).and_return(@io)
+    end
 
-      it "should show valid output when called without title" do
-        Progress(count)
-        count.times do |i|
-          verify_output_before_step(i, count)
-          Progress.step
-        end
-        Progress.stop
-        verify_output_after_stop
-      end
+    it "should return result from start block" do
+      Progress.start('Test') do
+        'test'
+      end.should == 'test'
     end
 
-    describe 'block' do
-      it "should show valid output when called as Progress.start" do
-        Progress.start('Test', count) do
-          count.times do |i|
-            verify_output_before_step(i, count)
-            Progress.step
-          end
-        end
-        verify_output_after_stop
+    it "should return result from step block" do
+      Progress.start 1 do
+        Progress.step{ 'test' }.should == 'test'
       end
+    end
 
-      it "should show valid output when called as Progress" do
-        Progress('Test', count) do
-          count.times do |i|
-            verify_output_before_step(i, count)
-            Progress.step
-          end
-        end
-        verify_output_after_stop
+    it "should return result from set block" do
+      Progress.start 1 do
+        Progress.set(1){ 'test' }.should == 'test'
       end
+    end
 
-      it "should show valid output when called without title" do
-        Progress(count) do
-          count.times do |i|
-            verify_output_before_step(i, count)
-            Progress.step
-          end
+    it "should return result from nested block" do
+      [1, 2, 3].with_progress.map do |a|
+        [1, 2, 3].with_progress.map do |b|
+          a * b
         end
-        verify_output_after_stop
-      end
+      end.should == [[1, 2, 3], [2, 4, 6], [3, 6, 9]]
     end
-  end
 
-  describe 'integrity' do
-    it "should not raise errors on extra Progress.stop" do
+    it "should not raise errors on extra step or stop" do
       proc{
-        10.times_with_progress('10') do
+        3.times_with_progress do
           Progress.start 'simple' do
-            Progress.start 'procedural'
-            Progress.stop
-            Progress.stop
+            Progress.step
+            Progress.step
+            Progress.step
           end
+          Progress.step
           Progress.stop
         end
+        Progress.step
         Progress.stop
       }.should_not raise_error
     end
 
-    it "should return result from block" do
-      Progress.start('Test') do
-        'qwerty'
-      end.should == 'qwerty'
-    end
+    describe Enumerable do
 
-    it "should return result from step" do
-      Progress.start do
-        Progress.step{ 'qwerty' }.should == 'qwerty'
+      before :each do
+        @a = 0...1000
       end
-    end
 
-    it "should return result from set" do
-      Progress.start do
-        Progress.set(1){ 'qwerty' }.should == 'qwerty'
-      end
-    end
+      describe "with_progress" do
 
-    it "should return result from nested block" do
-      [1, 2, 3].with_progress('a').map do |a|
-        [1, 2, 3].with_progress('b').map do |b|
-          a * b
+        it "should not break each" do
+          reference = @a.each
+          @a.with_progress.each do |n|
+            n.should == reference.next
+          end
+          proc{ reference.next }.should raise_error(StopIteration)
         end
-      end.should == [[1, 2, 3], [2, 4, 6], [3, 6, 9]]
-    end
 
-    it "should kill progress on cycle break" do
-      2.times do
-        catch(:lalala) do
-          2.times_with_progress('A') do |a|
-            io_pop.should == "A: ......\n"
-            2.times_with_progress('B') do |b|
-              io_pop.should == "A: ...... > B: ......\n"
-              throw(:lalala)
-            end
-          end
+        it "should not break find" do
+          default = proc{ 'default' }
+          @a.with_progress.find{ |n| n == 100 }.should == @a.find{ |n| n == 100 }
+          @a.with_progress.find{ |n| n == 10000 }.should == @a.find{ |n| n == 10000 }
+          @a.with_progress.find(default){ |n| n == 10000 }.should == @a.find(default){ |n| n == 10000 }
+        end
+
+        it "should not break map" do
+          @a.with_progress.map{ |n| n * n }.should == @a.map{ |n| n * n }
         end
-        io_pop.should == "A: ......\n\n"
-      end
-    end
 
-    [[2, 200], [20, 20], [200, 2]].each do |_a, _b|
-      it "should allow enclosed progress [#{_a}, #{_b}]" do
-        _a.times_with_progress('A') do |a|
-          io_pop_no_eta.should == "A: #{a == 0 ? '......' : '%5.1f%%'}\n" % [a / _a.to_f * 100.0]
-          _b.times_with_progress('B') do |b|
-            io_pop_no_eta.should == "A: #{a == 0 && b == 0 ? '......' : '%5.1f%%'} > B: #{b == 0 ? '......' : '%5.1f%%'}\n" % [(a + b / _b.to_f) / _a.to_f * 100.0, b / _b.to_f * 100.0]
+        it "should not break grep" do
+          @a.with_progress.grep(100).should == @a.grep(100)
+        end
+
+        it "should not break each_cons" do
+          reference = @a.each_cons(3)
+          @a.with_progress.each_cons(3) do |values|
+            values.should == reference.next
           end
-          io_pop_no_eta.should == "A: %5.1f%% > B: 100.0%%\n" % [(a + 1) / _a.to_f * 100.0]
+          proc{ reference.next }.should raise_error(StopIteration)
         end
-        io_pop.should == "A: 100.0%\nA: 100.0%\n\n"
-      end
 
-      it "should not overlap outer progress if inner exceeds [#{_a}, #{_b}]" do
-        _a.times_with_progress('A') do |a|
-          io_pop_no_eta.should == "A: #{a == 0 ? '......' : '%5.1f%%'}\n" % [a / _a.to_f * 100.0]
-          Progress.start('B', _b) do
-            (_b * 2).times do |b|
-              io_pop_no_eta.should == "A: #{a == 0 && b == 0 ? '......' : '%5.1f%%'} > B: #{b == 0 ? '......' : '%5.1f%%'}\n" % [(a + [b / _b.to_f, 1].min) / _a.to_f * 100.0, b / _b.to_f * 100.0]
-              Progress.step
-            end
+        describe "with_progress.with_progress" do
+
+          it "should not change existing instance" do
+            wp = @a.with_progress('hello')
+            proc{ wp.with_progress('world') }.should_not change(wp, :title)
+          end
+
+          it "should create new instance with different title when called on WithProgress" do
+            wp = @a.with_progress('hello')
+            wp_wp = wp.with_progress('world')
+            wp.title.should == 'hello'
+            wp_wp.title.should == 'world'
+            wp_wp.should_not == wp
+            wp_wp.enumerable.should == wp.enumerable
           end
-          io_pop_no_eta.should == "A: %5.1f%% > B: 200.0%%\n" % [(a + 1) / _a.to_f * 100.0]
+
         end
-        io_pop.should == "A: 100.0%\nA: 100.0%\n\n"
-      end
 
-      it "should allow step with block to validly count custom progresses [#{_a}, #{_b}]" do
-        a_step = 99
-        Progress.start('A', _a * 100) do
-          io_pop_no_eta.should == "A: ......\n"
-          _a.times do |a|
-            Progress.step(a_step) do
-              _b.times_with_progress('B') do |b|
-                io_pop_no_eta.should == "A: #{a == 0 && b == 0 ? '......' : '%5.1f%%'} > B: #{b == 0 ? '......' : '%5.1f%%'}\n" % [(a * a_step + b / _b.to_f * a_step) / (_a * 100).to_f * 100.0, b / _b.to_f * 100.0]
+        describe "calls to each" do
+
+          def without_warnings
+            verbosity = $VERBOSE
+            $VERBOSE = nil
+            result = yield
+            $VERBOSE = verbosity
+            result
+          end
+
+          it "should call each only once for Array" do
+            enum = [1, 2, 3]
+            enum.should_receive(:each).once
+            enum.with_progress.each{ }.should == enum
+          end
+
+          it "should call each only once for Hash" do
+            enum = {1 => 1, 2 => 2, 3 => 3}
+            enum.should_receive(:each).once
+            enum.with_progress.each{ }.should == enum
+          end
+
+          it "should call each only once for Set" do
+            enum = [1, 2, 3].to_set
+            enum.should_receive(:each).once
+            enum.with_progress.each{ }.should == enum
+          end
+
+          if ''.is_a?(Enumerable) # ruby1.8
+            it "should call each only once for String" do
+              enum = "a\nb\nc"
+              enum.should_receive(:each).once
+              without_warnings do
+                enum.with_progress.each{ }.should == enum
               end
-              io_pop_no_eta.should == "A: %5.1f%% > B: 100.0%\n" % [(a + 1) * a_step.to_f / (100.0 * _a.to_f) * 100.0]
             end
-            io_pop_no_eta.should == "A: %5.1f%%\n" % [(a + 1) * a_step.to_f / (100.0 * _a.to_f) * 100.0]
           end
-          Progress.step _a
+
+          it "should call each only once for File (IO)" do
+            enum = File.open(__FILE__)
+            enum.should_receive(:each).once
+            without_warnings do
+              enum.with_progress.each{ }.should == enum
+            end
+          end
+
+          it "should call each only once for StringIO" do
+            enum = StringIO.new("a\nb\nc")
+            enum.should_receive(:each).once
+            without_warnings do
+              enum.with_progress.each{ }.should == enum
+            end
+          end
+
         end
-        io_pop.should == "A: 100.0%\nA: 100.0%\n\n"
       end
     end
-  end
 
-  describe Enumerable do
-    before :each do
-      @a = 0...1000
+    describe Integer do
+
+      let(:count){ 108 }
+
+      it "should not break times_with_progress" do
+        reference = count.times
+        count.times_with_progress do |i|
+          i.should == reference.next
+        end
+        proc{ reference.next }.should raise_error(StopIteration)
+      end
+
+      it "should not break times.with_progress" do
+        reference = count.times
+        count.times.with_progress do |i|
+          i.should == reference.next
+        end
+        proc{ reference.next }.should raise_error(StopIteration)
+      end
+
     end
 
-    describe 'with_progress' do
-      it "should not break each" do
-        with, without = [], []
-        @a.with_progress.each{ |n| with << n }
-        @a.each{ |n| without << n }
-        with.should == without
+  end
+
+  describe "output" do
+
+    class ChunkIo
+      attr_reader :chunks
+      def initialize
+        @chunks = []
       end
 
-      it "should not break find" do
-        @a.with_progress('Hello').find{ |n| n == 100 }.should == @a.find{ |n| n == 100 }
-        @a.with_progress('Hello').find{ |n| n == 10000 }.should == @a.find{ |n| n == 10000 }
-        default = proc{ 'default' }
-        @a.with_progress('Hello').find(default){ |n| n == 10000 }.should == @a.find(default){ |n| n == 10000 }
+      def <<(data)
+        @chunks << data.to_s
       end
+    end
 
-      it "should not break map" do
-        @a.with_progress('Hello').map{ |n| n * n }.should == @a.map{ |n| n * n }
+    def stub_progress_io(klass)
+      io = klass.new
+      io.stub(:tty?).and_return(true)
+      Progress.stub(:io).and_return(io)
+      io
+    end
+
+    describe "validity" do
+
+      def run_example_progress
+        Progress.start 5, 'Test' do
+          Progress.step 2, 'simle'
+
+          Progress.step 2, 'times' do
+            3.times.with_progress {}
+          end
+
+          Progress.step 'enum' do
+            3.times.to_a.with_progress {}
+          end
+        end
       end
 
-      it "should not break grep" do
-        @a.with_progress('Hello').grep(100).should == @a.grep(100)
+      def title(s)
+        "\e]0;#{s}\a"
       end
 
-      it "should not break each_cons" do
-        without_progress = []
-        @a.each_cons(3){ |values| without_progress << values }
-        with_progress = []
-        @a.with_progress('Hello').each_cons(3){ |values| with_progress << values }
-        without_progress.should == with_progress
+      def hl(s)
+        "\e[1m#{s}\e[0m"
       end
 
-      describe "with_progress.with_progress" do
-        it "should not change existing instance" do
-          wp = @a.with_progress('hello')
-          proc{ wp.with_progress('world') }.should_not change(wp, :title)
-        end
+      def on_line(s)
+        "\r" + s + "\e[K"
+      end
 
-        it "should create new instance with different title when called on WithProgress" do
-          wp = @a.with_progress('hello')
-          wp_wp = wp.with_progress('world')
-          wp.title.should == 'hello'
-          wp_wp.title.should == 'world'
-          wp_wp.should_not == wp
-          wp_wp.enumerable.should == wp.enumerable
-        end
+      def line(s)
+        s + "\n"
       end
 
-      describe "calls to each" do
-        class CallsToEach
-          include Enumerable
+      it "should produce valid output when staying on line" do
+        Progress.stay_on_line = true
+
+        @io = stub_progress_io(ChunkIo)
+        run_example_progress
+
+        @io.chunks.should == [
+          on_line("Test: #{hl '......'}"),                      title('Test: ......'),
+          on_line("Test: #{hl ' 40.0%'} - simle"),              title('Test:  40.0% - simle'),
+          on_line("Test: #{hl ' 40.0%'} > #{hl '......'}"),     title('Test:  40.0% > ......'),
+          on_line("Test: #{hl ' 53.3%'} > #{hl ' 33.3%'}"),     title('Test:  53.3% >  33.3%'),
+          on_line("Test: #{hl ' 66.7%'} > #{hl ' 66.7%'}"),     title('Test:  66.7% >  66.7%'),
+          on_line("Test: #{hl ' 80.0%'} > 100.0%"),             title('Test:  80.0% > 100.0%'),
+          on_line("Test: #{hl ' 80.0%'} - times"),              title('Test:  80.0% - times'),
+          on_line("Test: #{hl ' 80.0%'} > #{hl '......'}"),     title('Test:  80.0% > ......'),
+          on_line("Test: #{hl ' 86.7%'} > #{hl ' 33.3%'}"),     title('Test:  86.7% >  33.3%'),
+          on_line("Test: #{hl ' 93.3%'} > #{hl ' 66.7%'}"),     title('Test:  93.3% >  66.7%'),
+          on_line("Test: 100.0% > 100.0%"),                     title('Test: 100.0% > 100.0%'),
+          on_line("Test: 100.0% - enum"),                       title('Test: 100.0% - enum'),
+          on_line("Test: 100.0% (elapsed: 0s) - enum") + "\n",  title(''),
+        ]
+      end
 
-          COUNT = 100
-        end
+      it "should produce valid output when not staying on line" do
+        Progress.stay_on_line = false
+
+        @io = stub_progress_io(ChunkIo)
+        run_example_progress
+
+        @io.chunks.should == [
+          line("Test: #{hl '......'}"),                  title('Test: ......'),
+          line("Test: #{hl ' 40.0%'} - simle"),          title('Test:  40.0% - simle'),
+          line("Test: #{hl ' 40.0%'} > #{hl '......'}"), title('Test:  40.0% > ......'),
+          line("Test: #{hl ' 53.3%'} > #{hl ' 33.3%'}"), title('Test:  53.3% >  33.3%'),
+          line("Test: #{hl ' 66.7%'} > #{hl ' 66.7%'}"), title('Test:  66.7% >  66.7%'),
+          line("Test: #{hl ' 80.0%'} > 100.0%"),         title('Test:  80.0% > 100.0%'),
+          line("Test: #{hl ' 80.0%'} - times"),          title('Test:  80.0% - times'),
+          line("Test: #{hl ' 80.0%'} > #{hl '......'}"), title('Test:  80.0% > ......'),
+          line("Test: #{hl ' 86.7%'} > #{hl ' 33.3%'}"), title('Test:  86.7% >  33.3%'),
+          line("Test: #{hl ' 93.3%'} > #{hl ' 66.7%'}"), title('Test:  93.3% >  66.7%'),
+          line("Test: 100.0% > 100.0%"),                 title('Test: 100.0% > 100.0%'),
+          line("Test: 100.0% - enum"),                   title('Test: 100.0% - enum'),
+          line("Test: 100.0% (elapsed: 0s) - enum"),     title(''),
+        ]
+      end
 
-        def init_calls_to_each
-          @enum = CallsToEach.new
-          @objects = 10.times.to_a
-          @enum.should_receive(:each).once{ |&block|
-            @objects.each(&block)
-          }
-        end
+    end
 
-        it "should call each only one time for object with length" do
-          init_calls_to_each
-          @enum.should_receive(:length).and_return(10)
-          got = []
-          @enum.with_progress.each{ |o| got << o }.should == @enum
-          got.should == @objects
-        end
+    describe "different call styles" do
 
-        it "should call each only one time for object without length" do
-          init_calls_to_each
-          got = []
-          @enum.with_progress.each{ |o| got << o }.should == @enum
-          got.should == @objects
-        end
+      let(:count_a){ 13 }
+      let(:count_b){ 17 }
 
-        it "should call each only one time for String" do
-          @objects = ('a'..'z').map{ |c| "#{c}\n" }
-          str = @objects.join('')
-          str.should_not_receive(:length)
-          str.should_receive(:each).once{ |&block|
-            @objects.each(&block)
-          }
-          got = []
-          str.with_progress.each{ |o| got << o }.should == str
-          got.should == @objects
+      before do
+        reference_io = stub_progress_io(StringIO)
+        count_a.times.with_progress('Test') do
+          count_b.times.with_progress {}
         end
+        @reference_output = reference_io.string
+
+        @io = stub_progress_io(StringIO)
       end
-    end
-  end
 
-  describe Integer do
-    describe 'with times_with_progress' do
-      it "should not break times" do
-        ii = 0
-        count.times_with_progress('Test') do |i|
-          i.should == ii
-          ii += 1
+      it "should output same when called without block" do
+        Progress(count_a, 'Test')
+        count_a.times do
+          Progress.step do
+            Progress.start(count_b)
+            count_b.times do
+              Progress.step
+            end
+            Progress.stop
+          end
         end
+        Progress.stop
+        @io.string.should == @reference_output
       end
 
-      it "should show valid output for each_with_progress" do
-        count.times_with_progress('Test') do |i|
-          verify_output_before_step(i, count)
+      it "should output same when called with block" do
+        Progress(count_a, 'Test') do
+          count_a.times do
+            Progress.step do
+              Progress.start(count_b) do
+                count_b.times do
+                  Progress.step
+                end
+              end
+            end
+          end
         end
-        verify_output_after_stop
+        @io.string.should == @reference_output
       end
 
-      it "should show valid output for each_with_progress without title" do
-        count.times_with_progress do |i|
-          verify_output_before_step(i, count)
+      it "should output same when called using with_progress on list" do
+        count_a.times.to_a.with_progress('Test') do
+          count_b.times.to_a.with_progress {}
         end
-        verify_output_after_stop
+        @io.string.should == @reference_output
       end
+
     end
+
   end
+
 end