progress 3.0.2 → 3.1.0

data/lib/progress/enumerable.rb

@@ -1,9 +1,11 @@
 require 'enumerator'
 require 'progress/with_progress'
 
+# Add with_progress method to Enumerable
 module Enumerable
   # run any Enumerable method with progress
-  # methods which don't necessarily go through all items (like find, any? or all?) will not show 100%
+  # methods which don't necessarily go through all items (like find, any? or
+  # all?) will not show 100%
   # ==== Example
   #   [1, 2, 3].with_progress('Numbers').each do |number|
   #     # code

data/lib/progress/eta.rb

@@ -1,4 +1,5 @@
 class Progress
+  # Estimate time of arrival
   class Eta
     def initialize
       @started_at = Time.now
@@ -6,9 +7,8 @@ class Progress
 
     def left(completed)
       seconds = seconds_left(completed)
-      if seconds && seconds > 0
-        seconds_to_string(seconds)
-      end
+      return unless seconds && seconds > 0
+      seconds_to_string(seconds)
     end
 
     def elapsed
@@ -18,31 +18,29 @@ class Progress
   private
 
     def seconds_to_string(seconds)
-      if seconds
-        case seconds
-        when 0...60
-          '%.0fs' % seconds
-        when 60...3600
-          '%.1fm' % (seconds / 60)
-        when 3600...86400
-          '%.1fh' % (seconds / 3600)
-        else
-          '%.1fd' % (seconds / 86400)
-        end
+      return unless seconds
+      case seconds
+      when 0...60
+        format '%.0fs', seconds
+      when 60...3600
+        format '%.1fm', seconds / 60
+      when 3600...86_400
+        format '%.1fh', seconds / 3600
+      else
+        format '%.1fd', seconds / 86_400
       end
     end
 
     def seconds_left(completed)
       now = Time.now
-      if completed > 0 && now - @started_at >= 1
-        current_eta = @started_at + (now - @started_at) / completed
-        @left = if @left
-          @left + (current_eta - @left) * (1 + completed) * 0.5
-        else
-          current_eta
-        end
-        @left - now
+      return unless completed > 0 && now - @started_at >= 1
+      current_eta = @started_at + (now - @started_at) / completed
+      @left = if @left
+        @left + (current_eta - @left) * (1 + completed) * 0.5
+      else
+        current_eta
       end
+      @left - now
     end
   end
 end

data/lib/progress/integer.rb

@@ -1,5 +1,6 @@
 require 'progress'
 
+# Add times_with_progress method to Integer
 class Integer
   # run `times` with progress
   #   100.times_with_progress('Numbers') do |number|

data/lib/progress/kernel.rb

@@ -0,0 +1,9 @@
+require 'progress'
+
+# Add Progress method as alias to Progress.start
+module Kernel
+  define_method :Progress do |*args, &block|
+    Progress.start(*args, &block)
+  end
+  private :Progress
+end

data/lib/progress/with_progress.rb

@@ -1,30 +1,37 @@
 require 'progress'
+require 'stringio'
 
 class Progress
+  # Handling with_progress
   class WithProgress
-    attr_reader :enumerable, :title
+    attr_reader :enum, :title
+    alias_method :enumerable, :enum
+
+    # If block given run each on instance otherwise return instance
+    def self.new(*args, &block)
+      block ? super.each(&block) : super
+    end
 
     # initialize with object responding to each, title and optional length
     # if block is provided, it is passed to each
-    def initialize(enumerable, title, length = nil, &block)
-      @enumerable, @title, @length = enumerable, title, length
-      each(&block) if block
+    def initialize(enum, title = nil, length = nil)
+      @enum, @title, @length = enum, title, length
     end
 
     # returns self but changes title
     def with_progress(title = nil, length = nil, &block)
-      self.class.new(@enumerable, title, length || @length, &block)
+      self.class.new(@enum, title, length || @length, &block)
     end
 
     # befriend with in_threads gem
     def in_threads(*args, &block)
-      @enumerable.in_threads(*args).with_progress(@title, @length, &block)
+      @enum.in_threads(*args).with_progress(@title, @length, &block)
     rescue
       super
     end
 
-    def respond_to?(sym, include_private = false)
-      enumerable_method?(method) || super(sym, include_private)
+    def respond_to?(method, include_private = false)
+      enumerable_method?(method) || super
     end
 
     def method_missing(method, *args, &block)
@@ -42,54 +49,95 @@ class Progress
     end
 
     def run(method, *args, &block)
-      enumerable = case
+      case
+      when !block
+        run_without_block(@enum, method, *args)
       when @length
-        @enumerable
-      when
-            @enumerable.is_a?(String),
-            @enumerable.is_a?(IO),
-            Object.const_defined?(:StringIO) && @enumerable.is_a?(StringIO),
-            Object.const_defined?(:TempFile) && @enumerable.is_a?(TempFile)
-        warn "Progress: collecting elements for instance of class #{@enumerable.class}"
-        lines = []
-        @enumerable.each{ |line| lines << line }
-        lines
+        run_with_length(@enum, @length, method, *args, &block)
+      when @enum.is_a?(String)
+        run_for_string(method, *args, &block)
+      when io?
+        run_for_io(method, *args, &block)
+      when defined?(CSV::Reader) && @enum.is_a?(CSV::Reader)
+        run_for_ruby18_csv(method, *args, &block)
       else
-        @enumerable
+        run_with_length(@enum, enum_length(@enum), method, *args, &block)
       end
+    end
 
-      length = case
-      when @length
-        @length
-      when enumerable.respond_to?(:size)
-        enumerable.size
-      when enumerable.respond_to?(:length)
-        enumerable.length
-      else
-        enumerable.count
+    def run_for_string(method, *args, &block)
+      with_substitute(StringIO.new(@enum)) do |io|
+        run_with_pos(io, method, *args, &block)
       end
+    end
 
-      if block
-        result = Progress.start(@title, length) do
-          enumerable.send(method, *args) do |*block_args|
-            Progress.step do
-              block.call(*block_args)
-            end
-          end
+    def run_for_io(method, *args, &block)
+      if io_pos?
+        run_with_pos(@enum, method, *args, &block)
+      else
+        warn "Progress: can't get #{@enum.class} pos, collecting elements"
+        with_substitute(@enum.to_a) do |lines|
+          run_with_length(lines, lines.length, method, *args, &block)
         end
-        if result.eql?(enumerable)
-          @enumerable
-        else
-          result
+      end
+    end
+
+    def run_for_ruby18_csv(method, *args, &block)
+      warn "Progress: #{@enum.class} doesn't expose IO, collecting elements"
+      with_substitute(@enum.to_a) do |lines|
+        run_with_length(lines, lines.length, method, *args, &block)
+      end
+    end
+
+    def run_without_block(enum, method, *args)
+      Progress.start(@title) do
+        Progress.step do
+          enum.send(method, *args)
         end
-      else
-        Progress.start(@title) do
+      end
+    end
+
+    def run_with_length(enum, length, method, *args, &block)
+      Progress.start(@title, length) do
+        enum.send(method, *args) do |*block_args|
           Progress.step do
-            enumerable.send(method, *args)
+            block.call(*block_args)
+          end
+        end
+      end
+    end
+
+    def run_with_pos(io, method, *args, &block)
+      size = io.respond_to?(:size) ? io.size : io.stat.size
+      Progress.start(@title, size) do
+        io.send(method, *args) do |*block_args|
+          Progress.set(io.pos) do
+            block.call(*block_args)
           end
         end
       end
     end
 
+    def with_substitute(enum)
+      result = yield enum
+      result.eql?(enum) ? @enum : result
+    end
+
+    def io?
+      @enum.respond_to?(:pos) &&
+        (@enum.respond_to?(:size) || @enum.respond_to?(:stat))
+    end
+
+    def io_pos?
+      @enum.pos; true
+    rescue Errno::ESPIPE
+      false
+    end
+
+    def enum_length(enum)
+      enum.respond_to?(:size) && enum.size ||
+        enum.respond_to?(:length) && enum.length ||
+        enum.count
+    end
   end
 end

data/progress.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'progress'
-  s.version     = '3.0.2'
+  s.version     = '3.1.0'
   s.summary     = %q{Show progress of long running tasks}
   s.homepage    = "http://github.com/toy/#{s.name}"
   s.authors     = ['Ivan Kuchin']
@@ -15,5 +15,8 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = %w[lib]
 
-  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('1.9.3')
+    s.add_development_dependency 'rubocop', '~> 0.27'
+  end
 end

data/spec/progress_spec.rb

@@ -1,55 +1,56 @@
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 require 'rspec'
 require 'progress'
+require 'tempfile'
+require 'shellwords'
+require 'csv'
 
 describe Progress do
-
   before do
     Progress.stay_on_line = true
     Progress.highlight = true
-    Progress.set_terminal_title = true
+    Progress.terminal_title = true
 
-    Progress.stub(:start_beeper)
-    Progress.stub(:time_to_print?).and_return(true)
-    Progress.stub(:eta)
-    Progress.stub(:elapsed).and_return('0s')
-  end
+    allow(Progress).to receive(:start_beeper)
+    allow(Progress).to receive(:time_to_print?).and_return(true)
 
-  describe "integrity" do
+    eta = instance_double(Progress::Eta, :left => nil, :elapsed => '0s')
+    allow(Progress).to receive(:eta).and_return(eta)
+  end
 
+  describe 'integrity' do
     before do
-      @io = double(:<< => nil, :tty? => true)
-      Progress.stub(:io).and_return(@io)
+      io = double(:<< => nil, :tty? => true)
+      allow(Progress).to receive(:io).and_return(io)
     end
 
-    it "should return result from start block" do
-      Progress.start('Test') do
+    it 'returns result from start block' do
+      expect(Progress.start('Test') do
         'test'
-      end.should == 'test'
+      end).to eq('test')
     end
 
-    it "should return result from step block" do
+    it 'returns result from step block' do
       Progress.start 1 do
-        Progress.step{ 'test' }.should == 'test'
+        expect(Progress.step{ 'test' }).to eq('test')
       end
     end
 
-    it "should return result from set block" do
+    it 'returns result from set block' do
       Progress.start 1 do
-        Progress.set(1){ 'test' }.should == 'test'
+        expect(Progress.set(1){ 'test' }).to eq('test')
       end
     end
 
-    it "should return result from nested block" do
-      [1, 2, 3].with_progress.map do |a|
+    it 'returns result from nested block' do
+      expect([1, 2, 3].with_progress.map do |a|
         [1, 2, 3].with_progress.map do |b|
           a * b
         end
-      end.should == [[1, 2, 3], [2, 4, 6], [3, 6, 9]]
+      end).to eq([[1, 2, 3], [2, 4, 6], [3, 6, 9]])
     end
 
-    it "should not raise errors on extra step or stop" do
-      proc{
+    it 'does not raise errors on extra step or stop' do
+      expect do
         3.times_with_progress do
           Progress.start 'simple' do
             Progress.step
@@ -61,180 +62,235 @@ describe Progress do
         end
         Progress.step
         Progress.stop
-      }.should_not raise_error
+      end.not_to raise_error
     end
 
     describe Enumerable do
+      let(:enum){ 0...1000 }
 
-      before :each do
-        @a = 0...1000
-      end
-
-      describe "with_progress" do
+      describe 'with_progress' do
+        it 'returns with block same as when called with each' do
+          expect(enum.with_progress{}).to eq(enum.with_progress.each{})
+        end
 
-        it "should not break each" do
-          reference = @a.each
-          @a.with_progress.each do |n|
-            n.should == reference.next
+        it 'does not break each' do
+          reference = enum.each
+          enum.with_progress.each do |n|
+            expect(n).to eq(reference.next)
           end
-          proc{ reference.next }.should raise_error(StopIteration)
+          expect{ reference.next }.to raise_error(StopIteration)
         end
 
-        it "should not break find" do
+        it 'does 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 }
+          expect(enum.with_progress.find{ |n| n == 100 }).
+            to eq(enum.find{ |n| n == 100 })
+          expect(enum.with_progress.find{ |n| n == 10_000 }).
+            to eq(enum.find{ |n| n == 10_000 })
+          expect(enum.with_progress.find(default){ |n| n == 10_000 }).
+            to eq(enum.find(default){ |n| n == 10_000 })
         end
 
-        it "should not break map" do
-          @a.with_progress.map{ |n| n * n }.should == @a.map{ |n| n * n }
+        it 'does not break map' do
+          expect(enum.with_progress.map{ |n| n**2 }).to eq(enum.map{ |n| n**2 })
         end
 
-        it "should not break grep" do
-          @a.with_progress.grep(100).should == @a.grep(100)
+        it 'does not break grep' do
+          expect(enum.with_progress.grep(100)).to eq(enum.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
+        it 'does not break each_cons' do
+          reference = enum.each_cons(3)
+          enum.with_progress.each_cons(3) do |values|
+            expect(values).to eq(reference.next)
           end
-          proc{ reference.next }.should raise_error(StopIteration)
+          expect{ reference.next }.to raise_error(StopIteration)
         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)
+        describe 'with_progress.with_progress' do
+          it 'does not change existing instance' do
+            wp = enum.with_progress('hello')
+            expect{ wp.with_progress('world') }.not_to change(wp, :title)
           end
 
-          it "should create new instance with different title when called on WithProgress" do
-            wp = @a.with_progress('hello')
+          it 'returns new instance with different title' do
+            wp = enum.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
+            expect(wp.title).to eq('hello')
+            expect(wp_wp.title).to eq('world')
+            expect(wp_wp).not_to eq(wp)
+            expect(wp_wp.enumerable).to eq(wp.enumerable)
           end
-
         end
 
-        describe "calls to each" do
+        describe 'collections' do
+          [
+            [1, 2, 3],
+            {1 => 1, 2 => 2, 3 => 3},
+            [1, 2, 3].to_set,
+          ].each do |enum|
+            it "calls each only once for #{enum.class}" do
+              expect(enum).to receive(:each).once.and_call_original
+              expect(enum.with_progress.each{}).to eq(enum)
+            end
 
-          def without_warnings
-            verbosity = $VERBOSE
-            $VERBOSE = nil
-            result = yield
-            $VERBOSE = verbosity
-            result
+            it "yields same objects for #{enum.class}" do
+              expect(enum.with_progress.entries).to eq(enum.entries)
+            end
           end
 
-          it "should call each only once for Array" do
-            enum = [1, 2, 3]
-            enum.should_receive(:each).once.and_return(enum)
-            enum.with_progress.each{ }.should == enum
+          [
+            100.times,
+            'a'..'z',
+          ].each do |enum|
+            it "calls each twice for #{enum.class}" do
+              enum_each = enum.each{}
+              expect(enum).to receive(:each).at_most(:twice).and_call_original
+              expect(enum.with_progress.each{}).to eq(enum_each)
+            end
+
+            it "yields same objects for #{enum.class}" do
+              expect(enum.with_progress.entries).to eq(enum.entries)
+            end
           end
+        end
 
-          it "should call each only once for Hash" do
-            enum = {1 => 1, 2 => 2, 3 => 3}
-            enum.should_receive(:each).once.and_return(enum)
-            enum.with_progress.each{ }.should == enum
+        describe String do
+          it 'calls each only once on StringIO' do
+            enum = "a\nb\nc"
+            expect(enum).not_to receive(:each)
+            io = StringIO.new(enum)
+            expect(StringIO).to receive(:new).with(enum).and_return(io)
+            expect(io).to receive(:each).once.and_call_original
+
+            with_progress = Progress::WithProgress.new(enum)
+            expect(with_progress).not_to receive(:warn)
+            expect(with_progress.each{}).to eq(enum)
           end
 
-          it "should call each only once for Set" do
-            enum = [1, 2, 3].to_set
-            enum.should_receive(:each).once.and_return(enum)
-            enum.with_progress.each{ }.should == enum
+          it 'yields same lines' do
+            enum = "a\nb\nc"
+            lines = []
+            Progress::WithProgress.new(enum).each{ |line| lines << line }
+            expect(lines).to eq(enum.lines.to_a)
           end
+        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.and_return(enum)
-              without_warnings do
-                enum.with_progress.each{ }.should == enum
-              end
+        describe IO do
+          [
+            File.open(__FILE__),
+            StringIO.new(File.read(__FILE__)),
+          ].each do |enum|
+            it "calls each only once for #{enum.class}" do
+              expect(enum).to receive(:each).once.and_call_original
+
+              with_progress = enum.with_progress
+              expect(with_progress).not_to receive(:warn)
+              expect(with_progress.each{}).to eq(enum)
             end
           end
 
-          it "should call each only once for File (IO)" do
-            enum = File.open(__FILE__)
-            enum.should_receive(:each).once.and_return(enum)
-            without_warnings do
-              enum.with_progress.each{ }.should == enum
+          it 'calls each only once for Tempfile' do
+            enum = Tempfile.open('progress')
+            enum_each = enum.each{} # returns underlying File
+            expect(enum_each).to receive(:each).once.and_call_original
+
+            with_progress = enum.with_progress
+            expect(with_progress).not_to receive(:warn)
+            expect(with_progress.each{}).to eq(enum_each)
+          end
+
+          it 'calls each only once for IO and shows warning' do
+            enum = IO.popen("cat #{__FILE__.shellescape}")
+            expect(enum).to receive(:each).once.and_call_original
+
+            with_progress = enum.with_progress
+            expect(with_progress).to receive(:warn)
+            expect(with_progress.each{}).to eq(enum)
+          end
+
+          [
+            File.open(__FILE__),
+            StringIO.new(File.read(__FILE__)),
+            Tempfile.open('progress').tap do |f|
+              f.write(File.read(__FILE__))
+              f.rewind
+            end,
+            IO.popen("cat #{__FILE__.shellescape}"),
+          ].each do |enum|
+            it "yields same lines for #{enum.class}" do
+              expect(enum.with_progress.entries).to eq(File.readlines(__FILE__))
             end
           end
+        end
 
-          it "should call each only once for StringIO" do
-            enum = StringIO.new("a\nb\nc")
-            enum.should_receive(:each).once.and_return(enum)
-            without_warnings do
-              enum.with_progress.each{ }.should == enum
+        describe CSV do
+          if CSV.method_defined?(:pos)
+            it 'calls each only once for CSV' do
+              enum = CSV.open('spec/test.csv')
+              expect(enum).to receive(:each).once.and_call_original
+
+              with_progress = enum.with_progress
+              expect(with_progress).not_to receive(:warn)
+              expect(with_progress.each{}).to eq(nil)
+            end
+          else
+            it 'calls each only once for CSV and shows warning' do
+              enum = CSV.open('spec/test.csv', 'r')
+              expect(enum).to receive(:each).once.and_call_original
+
+              with_progress = enum.with_progress
+              expect(with_progress).to receive(:warn)
+              expect(with_progress.each{}).to eq(enum)
             end
           end
 
+          it 'yields same lines for CSV' do
+            csv = proc{ CSV.open('spec/test.csv', 'r') }
+            expect(csv[].with_progress.entries).to eq(csv[].entries)
+          end
         end
       end
     end
 
     describe Integer do
-
       let(:count){ 108 }
 
-      it "should not break times_with_progress" do
+      it 'does not break times_with_progress' do
         reference = count.times
         count.times_with_progress do |i|
-          i.should == reference.next
+          expect(i).to eq(reference.next)
         end
-        proc{ reference.next }.should raise_error(StopIteration)
+        expect{ reference.next }.to raise_error(StopIteration)
       end
 
-      it "should not break times.with_progress" do
+      it 'does not break times.with_progress' do
         reference = count.times
         count.times.with_progress do |i|
-          i.should == reference.next
+          expect(i).to eq(reference.next)
         end
-        proc{ reference.next }.should raise_error(StopIteration)
+        expect{ reference.next }.to raise_error(StopIteration)
       end
-
     end
-
   end
 
-  describe "output" do
-
-    class ChunkIo
-      attr_reader :chunks
-      def initialize
-        @chunks = []
-      end
-
-      def <<(data)
-        @chunks << data.to_s
-      end
+  describe 'output' do
+    def stub_progress_io(io)
+      allow(io).to receive(:tty?).and_return(true)
+      allow(Progress).to receive(:io).and_return(io)
     end
 
-    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
-
+    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 {}
+            3.times.with_progress{}
           end
 
           Progress.step 'enum' do
-            3.times.to_a.with_progress {}
+            3.times.to_a.with_progress{}
           end
         end
       end
@@ -247,6 +303,10 @@ describe Progress do
         "\e[1m#{s}\e[0m"
       end
 
+      def unhl(s)
+        s.gsub(/\e\[\dm/, '')
+      end
+
       def on_line(s)
         "\r" + s + "\e[K"
       end
@@ -255,70 +315,80 @@ describe Progress do
         s + "\n"
       end
 
-      it "should produce valid output when staying on line" do
+      def on_line_n_title(s)
+        [on_line(s), title(unhl(s))]
+      end
+
+      def line_n_title(s)
+        [line(s), title(unhl(s))]
+      end
+
+      it 'produces valid output when staying on line' do
         Progress.stay_on_line = true
 
-        @io = stub_progress_io(ChunkIo)
+        stub_progress_io(io = StringIO.new)
         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(''),
-        ]
+        expect(io.string).to eq([
+          on_line_n_title("Test: #{hl '......'}"),
+          on_line_n_title("Test: #{hl ' 40.0%'} - simle"),
+          on_line_n_title("Test: #{hl ' 40.0%'} > #{hl '......'}"),
+          on_line_n_title("Test: #{hl ' 53.3%'} > #{hl ' 33.3%'}"),
+          on_line_n_title("Test: #{hl ' 66.7%'} > #{hl ' 66.7%'}"),
+          on_line_n_title("Test: #{hl ' 80.0%'} > 100.0%"),
+          on_line_n_title("Test: #{hl ' 80.0%'} - times"),
+          on_line_n_title("Test: #{hl ' 80.0%'} > #{hl '......'}"),
+          on_line_n_title("Test: #{hl ' 86.7%'} > #{hl ' 33.3%'}"),
+          on_line_n_title("Test: #{hl ' 93.3%'} > #{hl ' 66.7%'}"),
+          on_line_n_title('Test: 100.0% > 100.0%'),
+          on_line_n_title('Test: 100.0% - enum'),
+          on_line('Test: 100.0% (elapsed: 0s) - enum') + "\n",
+          title(''),
+        ].flatten.join)
       end
 
-      it "should produce valid output when not staying on line" do
+      it 'produces valid output when not staying on line' do
         Progress.stay_on_line = false
 
-        @io = stub_progress_io(ChunkIo)
+        stub_progress_io(io = StringIO.new)
         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(''),
-        ]
+        expect(io.string).to eq([
+          line_n_title("Test: #{hl '......'}"),
+          line_n_title("Test: #{hl ' 40.0%'} - simle"),
+          line_n_title("Test: #{hl ' 40.0%'} > #{hl '......'}"),
+          line_n_title("Test: #{hl ' 53.3%'} > #{hl ' 33.3%'}"),
+          line_n_title("Test: #{hl ' 66.7%'} > #{hl ' 66.7%'}"),
+          line_n_title("Test: #{hl ' 80.0%'} > 100.0%"),
+          line_n_title("Test: #{hl ' 80.0%'} - times"),
+          line_n_title("Test: #{hl ' 80.0%'} > #{hl '......'}"),
+          line_n_title("Test: #{hl ' 86.7%'} > #{hl ' 33.3%'}"),
+          line_n_title("Test: #{hl ' 93.3%'} > #{hl ' 66.7%'}"),
+          line_n_title('Test: 100.0% > 100.0%'),
+          line_n_title('Test: 100.0% - enum'),
+          line('Test: 100.0% (elapsed: 0s) - enum'),
+          title(''),
+        ].flatten.join)
       end
-
     end
 
-    describe "different call styles" do
-
+    describe 'different call styles' do
       let(:count_a){ 13 }
       let(:count_b){ 17 }
-
-      before do
-        reference_io = stub_progress_io(StringIO)
+      let(:reference_output) do
+        stub_progress_io(reference_io = StringIO.new)
         count_a.times.with_progress('Test') do
-          count_b.times.with_progress {}
+          count_b.times.with_progress{}
         end
-        @reference_output = reference_io.string
+        reference_io.string
+      end
+      let(:io){ StringIO.new }
 
-        @io = stub_progress_io(StringIO)
+      before do
+        stub_progress_io(io)
       end
 
-      it "should output same when called without block" do
+      it 'outputs same when called without block' do
         Progress(count_a, 'Test')
         count_a.times do
           Progress.step do
@@ -330,10 +400,10 @@ describe Progress do
           end
         end
         Progress.stop
-        @io.string.should == @reference_output
+        expect(io.string).to eq(reference_output)
       end
 
-      it "should output same when called with block" do
+      it 'outputs same when called with block' do
         Progress(count_a, 'Test') do
           count_a.times do
             Progress.step do
@@ -345,18 +415,15 @@ describe Progress do
             end
           end
         end
-        @io.string.should == @reference_output
+        expect(io.string).to eq(reference_output)
       end
 
-      it "should output same when called using with_progress on list" do
+      it 'outputs 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 {}
+          count_b.times.to_a.with_progress{}
         end
-        @io.string.should == @reference_output
+        expect(io.string).to eq(reference_output)
       end
-
     end
-
   end
-
 end