ruby-progressbar 1.2.0 → 1.3.0

data/README.md

@@ -12,6 +12,7 @@ Supported Rubies
 * MRI Ruby 1.8.7
 * MRI Ruby 1.9.2
 * MRI Ruby 1.9.3
+* MRI Ruby 2.0.0
 * JRuby (in 1.8 compat mode)
 * JRuby (in 1.9 compat mode)
 
@@ -98,6 +99,7 @@ The following are the list of options you can use:
 * `:total` - _(Defaults to `100`)_ The total number of the items that can be completed.
 * `:starting_at` - _(Defaults to `0`)_ The number of items that should be considered completed when the bar first starts.  This is also the default number that the bar will be set to if `#reset` is called.
 * `:progress_mark` - _(Defaults to `=`)_ The mark which indicates the amount of progress that has been made.
+* `:remainder_mark` - _(Defaults to ` `)_ The mark which indicates the remaining amount of progress to be made.
 * `:format` - _(Defaults to `%t: |%B|`)_ The format string which determines how the bar is displayed.  See [**Formatting**](#formatting) below.
 * `:length` - _(Defaults to full width if possible, otherwise `80`)_ The preferred width of the entire progress bar including any format options.
 * `:output` - _(Defaults to `STDOUT`)_ All output will be sent to this object.  Can be any object which responds to `.print`.
@@ -267,6 +269,7 @@ _Note: If the terminal width is less than 20 characters or ruby-progressbar is b
 The following items can be set at any time.  Changes cause an immediate bar refresh so no other action is needed:
 
 * `#progress_mark=`: Sets the string used to represent progress along the bar.
+* `#remainder_mark=`: Sets the string used to represent the empty part of the bar.
 * `#title=`: Sets the string used to represent the items the bar is tracking (or I guess whatever else you want it to be).
 * `#format(format_string)`: If you need to adjust the format that the bar uses when rendering itself, just pass in a string in the same format as describe [above](#formatting).
 
@@ -321,9 +324,35 @@ You can have an array of as many elements as you'd like and they will be used in
 
 Whatever element is chosen is repeated along the entire 'incomplete' portion of the bar.
 
-Road Map
---------------------------------
-We're planning on adding a bunch of really nice features to this gem over the next few weeks.  We want to keep the simple usage simple but allow for powerful features if they're needed.  Our `1.0` release is the first step in that direction.
+### Non-TTY Output
+
+Typically, when the progress bar is updated, the entire previous bar is 'overwritten' with the updated information.  Unfortunately when the bar is being output on a non-TTY enabled output stream (such as a file or pipe), that standard behavior of outputting the progress bar will not work.  This is mainly due to the fact that we can't easily go back and replace the content that the bar had previously written.
+
+To try to solve this, ruby-progressbar, when it determines that it is being used on a non-TTY device, will override any format which was set in the initializer to something which more closely resembles this:
+
+    Progress: |=============
+
+Notice that there are no dynamically updating segments like counters or ETA.  Dynamic segments are not compatible with non-TTY devices because, by their very nature, they must be updated on each refresh of the bar and as stated previously, that is not possible in non-TTY mode.
+
+Also notice that there is no end cap on the righthand side of the bar.  Again, we cannot output something which is past the point at which we next need to output text.  If we added an end cap, that would mean that any additional progress text would be placed _after_ the end cap.  Definitely not what we want.
+
+So how does it work?  First we output the title and the first end cap:
+
+    Progress: |
+
+Next, every time we increment the bar, we check whether the progress bar has grown.  If it has, we output _only the additional portion_ of the bar to the output.
+
+For example, given the previous title output, if we increment the bar once, we would get:
+
+    Progress: |=
+
+But in this case, only one `=` was output.  Not the entire `Progress: |=`.
+
+Once the bar gets to be completely finished though:
+
+    Progress: |====================================================================|
+
+The end cap can now be added (since there is no more progress to be displayed).
 
 Issues
 --------------------------------

data/lib/ruby-progressbar/base.rb

@@ -7,6 +7,7 @@ class ProgressBar
 
     def initialize(options = {})
       self.output       = options[:output] || DEFAULT_OUTPUT_STREAM
+      autostart         = options.fetch(:autostart, true)
 
       super(options)
 
@@ -15,7 +16,7 @@ class ProgressBar
       @elapsed_time     = Components::ElapsedTimer.new
       @throttle         = Components::Throttle.new(options)
 
-      start :at => options[:starting_at]
+      start :at => options[:starting_at] if autostart
     end
 
     ###
@@ -53,19 +54,19 @@ class ProgressBar
     # Stopping The Bar
     #
     def finish
-      with_update { with_progressables(:finish) }
+      with_update { with_progressables(:finish) } unless finished?
     end
 
     def pause
-      with_update { with_timers(:pause) }
+      with_update { with_timers(:pause) } unless paused?
     end
 
     def stop
-      with_update { with_timers(:stop) }
+      with_update { with_timers(:stop) } unless stopped?
     end
 
     def resume
-      with_update { with_timers(:resume) }
+      with_update { with_timers(:resume) } if stopped?
     end
 
     def reset
@@ -92,6 +93,10 @@ class ProgressBar
       with_update { @bar.progress_mark = mark }
     end
 
+    def remainder_mark=(mark)
+      with_update { @bar.remainder_mark = mark }
+    end
+
     def title=(title)
       with_update { super }
     end
@@ -100,9 +105,13 @@ class ProgressBar
     # Output
     #
     def clear
+      self.last_update_length = 0
+
       if output.tty?
         output.print clear_string
         output.print "\r"
+      else
+        output.print "\n"
       end
     end
 
@@ -128,12 +137,17 @@ class ProgressBar
     end
 
   private
-    attr_accessor   :output
+    attr_accessor   :output,
+                    :last_update_length
 
     def clear_string
       "#{" " * length}"
     end
 
+    def last_update_length
+      @last_update_length ||= 0
+    end
+
     def with_progressables(*args)
       @bar.send(*args)
       @estimated_time.send(*args)
@@ -150,23 +164,37 @@ class ProgressBar
     end
 
     def update(options = {})
-      if output.tty? || stopped?
-        with_timers(:stop) if finished?
+      with_timers(:stop) if finished?
 
-        @throttle.choke( stopped? || options[:force] ) do
-          if length_changed?
-            clear
-            reset_length
-          end
+      if length_changed?
+        clear
+        reset_length
+      end
 
-          output.print self.to_s + eol
-          output.flush
+      @throttle.choke( stopped? || options[:force] ) do
+        if output.tty?
+          formatted_string = self.to_s
+          output_string    = formatted_string
+        else
+          formatted_string = self.to_s(DEFAULT_NON_TTY_FORMAT_STRING)
+          formatted_string = formatted_string[0...-1] unless finished?
+
+          output_string    = formatted_string[last_update_length..-1]
         end
+
+        self.last_update_length = formatted_string.length
+
+        output.print output_string + eol
+        output.flush
       end
     end
 
     def eol
-      stopped? ? "\n" : "\r"
+      if output.tty?
+        stopped? ? "\n" : "\r"
+      else
+        stopped? ? "\n" : ""
+      end
     end
   end
 end

data/lib/ruby-progressbar/components/bar.rb

@@ -4,9 +4,11 @@ class ProgressBar
       include Progressable
 
       DEFAULT_PROGRESS_MARK                    = '='
+      DEFAULT_REMAINDER_MARK                   = ' '
       DEFAULT_UNKNOWN_PROGRESS_ANIMATION_STEPS = ['=---', '-=--', '--=-', '---=']
 
       attr_accessor :progress_mark
+      attr_accessor :remainder_mark
       attr_accessor :length
       attr_accessor :unknown_progress_animation_steps
 
@@ -15,6 +17,7 @@ class ProgressBar
 
         self.unknown_progress_animation_steps = options[:unknown_progress_animation_steps] || DEFAULT_UNKNOWN_PROGRESS_ANIMATION_STEPS
         self.progress_mark                    = options[:progress_mark]                    || DEFAULT_PROGRESS_MARK
+        self.remainder_mark                   = options[:remainder_mark]                   || DEFAULT_REMAINDER_MARK
       end
 
       def to_s(options = {:format => :standard})
@@ -44,7 +47,7 @@ class ProgressBar
 
           unknown_incomplete_string[0, incomplete_length]
         else
-          ' ' * incomplete_length
+          remainder_mark * incomplete_length
         end
       end
 

data/lib/ruby-progressbar/format/base.rb

@@ -10,6 +10,7 @@ class ProgressBar
 
       def process(environment)
         processed_string = @format_string.dup
+        ansi_sgr_codes   = %r{\e\[[\d;]+m}
 
         non_bar_molecules.each do |molecule|
           processed_string.gsub!("%#{molecule.key}", environment.send(molecule.method_name).to_s)
@@ -20,8 +21,9 @@ class ProgressBar
 
         processed_string.gsub! '%%', '%'
 
-        leftover_bar_length = environment.send(:length) - processed_string.length + placeholder_length
-        leftover_bar_length = leftover_bar_length < 0 ? 0 : leftover_bar_length
+        processed_string_length = processed_string.gsub(ansi_sgr_codes, '').length
+        leftover_bar_length     = environment.send(:length) - processed_string_length + placeholder_length
+        leftover_bar_length     = leftover_bar_length < 0 ? 0 : leftover_bar_length
 
         bar_molecules.each do |molecule|
           processed_string.gsub!("%#{molecule.key}", environment.send(molecule.method_name, leftover_bar_length).to_s)

data/lib/ruby-progressbar/formatter.rb

@@ -1,7 +1,8 @@
 class ProgressBar
   module Formatter
-    DEFAULT_FORMAT_STRING = '%t: |%B|'
-    DEFAULT_TITLE         = 'Progress'
+    DEFAULT_FORMAT_STRING         = '%t: |%B|'
+    DEFAULT_NON_TTY_FORMAT_STRING = '%t: |%b|'
+    DEFAULT_TITLE                 = 'Progress'
 
     def initialize(options)
       self.format_string = options[:format] || DEFAULT_FORMAT_STRING

data/lib/ruby-progressbar/version.rb

@@ -1,3 +1,3 @@
 class ProgressBar
-  VERSION = '1.2.0'
+  VERSION = '1.3.0'
 end

data/spec/lib/ruby-progressbar/base_spec.rb

@@ -2,86 +2,89 @@ require 'spec_helper'
 require 'stringio'
 
 describe ProgressBar::Base do
-  before do
-    @output = StringIO.new('', 'w+')
-    @output.stub(:tty?).and_return true
-
-    @non_tty_output = StringIO.new('', 'w+')
-    @non_tty_output.stub(:tty?).and_return false
+  let(:output) do
+    StringIO.new('', 'w+').tap do |io|
+      io.stub(:tty?).and_return true
+    end
+  end
 
-    @progressbar = ProgressBar::Base.new(:output => @output, :length => 80, :throttle_rate => 0.0)
-    @output.rewind
+  let(:non_tty_output) do
+    StringIO.new('', 'w+').tap do |io|
+      io.stub(:tty?).and_return false
+    end
   end
 
+  let(:progressbar) { ProgressBar::Base.new(:output => output, :length => 80, :throttle_rate => 0.0) }
+
   context 'when the terminal width is shorter than the string being output' do
     it 'can properly handle outputting the bar when the length changes on the fly to less than the minimum width' do
       IO.stub_chain(:console, :winsize).and_return [1, 30]
-      @progressbar = ProgressBar::Base.new(:output => @output, :title => 'a' * 25, :format => '%t%B', :throttle_rate => 0.0)
+      progressbar = ProgressBar::Base.new(:output => output, :title => 'a' * 25, :format => '%t%B', :throttle_rate => 0.0)
 
-      @progressbar.start
+      progressbar.start
 
       IO.stub_chain(:console, :winsize).and_return [1, 20]
-      @progressbar.increment
+      progressbar.increment
 
-      @output.rewind
-      @output.read.should match /\raaaaaaaaaaaaaaaaaaaaaaaaa     \r\s+\raaaaaaaaaaaaaaaaaaaaaaaaa\r\z/
+      output.rewind
+      output.read.should match /\raaaaaaaaaaaaaaaaaaaaaaaaa     \r\s+\raaaaaaaaaaaaaaaaaaaaaaaaa\r\z/
     end
 
     context 'and the bar length is calculated' do
       it 'returns the proper string' do
         IO.stub_chain(:console, :winsize).and_return [1, 20]
-        @progressbar = ProgressBar::Base.new(:output => @output, :title => ('*' * 21), :starting_at => 5, :total => 10)
+        progressbar = ProgressBar::Base.new(:output => output, :title => ('*' * 21), :starting_at => 5, :total => 10)
 
-        @progressbar.to_s('%t%w').should eql '*********************'
+        progressbar.to_s('%t%w').should eql '*********************'
       end
     end
 
     context 'and the incomplete bar length is calculated' do
       it 'returns the proper string' do
         IO.stub_chain(:console, :winsize).and_return [1, 20]
-        @progressbar = ProgressBar::Base.new(:output => @output, :title => ('*' * 21))
+        progressbar = ProgressBar::Base.new(:output => output, :title => ('*' * 21))
 
-        @progressbar.to_s('%t%i').should eql '*********************'
+        progressbar.to_s('%t%i').should eql '*********************'
       end
 
       it 'returns the proper string' do
         IO.stub_chain(:console, :winsize).and_return [1, 20]
-        @progressbar = ProgressBar::Base.new(:output => @output, :title => ('*' * 21), :starting_at => 5, :total => 10)
+        progressbar = ProgressBar::Base.new(:output => output, :title => ('*' * 21), :starting_at => 5, :total => 10)
 
-        @progressbar.to_s('%t%i').should eql '*********************'
+        progressbar.to_s('%t%i').should eql '*********************'
       end
     end
 
     context 'and the full bar length is calculated (but lacks the space to output the entire bar)' do
       it 'returns the proper string' do
         IO.stub_chain(:console, :winsize).and_return [1, 20]
-        @progressbar = ProgressBar::Base.new(:output => @output, :title => ('*' * 19), :starting_at => 5, :total => 10)
+        progressbar = ProgressBar::Base.new(:output => output, :title => ('*' * 19), :starting_at => 5, :total => 10)
 
-        @progressbar.to_s('%t%B').should eql '******************* '
+        progressbar.to_s('%t%B').should eql '******************* '
       end
 
       it 'returns the proper string' do
         IO.stub_chain(:console, :winsize).and_return [1, 20]
-        @progressbar = ProgressBar::Base.new(:output => @output, :title => ('*' * 19), :starting_at => 5, :total => 10)
+        progressbar = ProgressBar::Base.new(:output => output, :title => ('*' * 19), :starting_at => 5, :total => 10)
 
-        @progressbar.to_s('%t%w%i').should eql '******************* '
+        progressbar.to_s('%t%w%i').should eql '******************* '
       end
     end
   end
 
   context 'when a new bar is created' do
     context 'and no options are passed' do
-      before { @progressbar = ProgressBar::Base.new }
+      let(:progressbar) { ProgressBar::Base.new  }
 
       describe '#title' do
         it 'returns the default title' do
-          @progressbar.send(:title).to_s.should eql ProgressBar::Base::DEFAULT_TITLE
+          progressbar.send(:title).to_s.should eql ProgressBar::Base::DEFAULT_TITLE
         end
       end
 
       describe '#output' do
         it 'returns the default output stream' do
-          @progressbar.send(:output).should eql ProgressBar::Base::DEFAULT_OUTPUT_STREAM
+          progressbar.send(:output).should eql ProgressBar::Base::DEFAULT_OUTPUT_STREAM
         end
       end
 
@@ -91,8 +94,8 @@ describe ProgressBar::Base do
           after   { ENV['RUBY_PROGRESS_BAR_LENGTH'] = nil }
 
           it 'returns the length of the environment variable as an integer' do
-            @progressbar = ProgressBar::Base.new
-            @progressbar.send(:length).should eql 44
+            progressbar = ProgressBar::Base.new
+            progressbar.send(:length).should eql 44
           end
         end
 
@@ -101,22 +104,22 @@ describe ProgressBar::Base do
 
           context 'but the length option was passed in' do
             it 'returns the length specified in the option' do
-              @progressbar = ProgressBar::Base.new(:length => 88)
-              @progressbar.send(:length).should eql 88
+              progressbar = ProgressBar::Base.new(:length => 88)
+              progressbar.send(:length).should eql 88
             end
           end
 
           context 'and no length option was passed in' do
             it 'returns the width of the terminal if it is a Unix environment' do
-              @progressbar.stub(:terminal_width).and_return(99)
-              @progressbar.send(:reset_length)
-              @progressbar.send(:length).should eql 99
+              progressbar.stub(:terminal_width).and_return(99)
+              progressbar.send(:reset_length)
+              progressbar.send(:length).should eql 99
             end
 
             it 'returns 80 if it is not a Unix environment' do
-              @progressbar.stub(:unix?).and_return(false)
-              @progressbar.send(:reset_length)
-              @progressbar.send(:length).should eql 80
+              progressbar.stub(:unix?).and_return(false)
+              progressbar.send(:reset_length)
+              progressbar.send(:length).should eql 80
             end
           end
         end
@@ -124,23 +127,23 @@ describe ProgressBar::Base do
     end
 
     context 'and options are passed' do
-      before { @progressbar = ProgressBar::Base.new(:title => 'We All Float', :total => 12, :output => STDOUT, :progress_mark => 'x', :length => 88, :starting_at => 5) }
+      let(:progressbar) { ProgressBar::Base.new(:title => 'We All Float', :total => 12, :output => STDOUT, :progress_mark => 'x', :length => 88, :starting_at => 5)  }
 
       describe '#title' do
         it 'returns the overridden title' do
-          @progressbar.send(:title).to_s.should eql 'We All Float'
+          progressbar.send(:title).to_s.should eql 'We All Float'
         end
       end
 
       describe '#output' do
         it 'returns the overridden output stream' do
-          @progressbar.send(:output).should eql STDOUT
+          progressbar.send(:output).should eql STDOUT
         end
       end
 
       describe '#length' do
         it 'returns the overridden length' do
-          @progressbar.send(:length).should eql 88
+          progressbar.send(:length).should eql 88
         end
       end
     end
@@ -148,170 +151,267 @@ describe ProgressBar::Base do
     context 'if the bar was started 4 minutes ago' do
       before do
         Timecop.travel(-240) do
-          @progressbar.start
+          progressbar.start
         end
       end
 
       context 'and within 2 minutes it was halfway done' do
         before do
           Timecop.travel(-120) do
-            50.times { @progressbar.increment }
+            50.times { progressbar.increment }
           end
         end
 
         describe '#finish' do
           before do
             Timecop.travel(-120) do
-              @progressbar.finish
+              progressbar.finish
             end
           end
 
           it 'completes the bar' do
-            @output.rewind
-            @output.read.should match /Progress: \|#{'=' * 68}\|\n/
+            output.rewind
+            output.read.should match /Progress: \|#{'=' * 68}\|\n/
           end
 
           it 'shows the elapsed time instead of the estimated time since the bar is completed' do
-            @progressbar.to_s('%e').should eql 'Time: 00:02:00'
+            progressbar.to_s('%e').should eql 'Time: 00:02:00'
           end
 
           it 'calculates the elapsed time to 00:02:00' do
-            @progressbar.to_s('%a').should eql 'Time: 00:02:00'
+            progressbar.to_s('%a').should eql 'Time: 00:02:00'
           end
         end
       end
     end
 
+    context 'which includes ANSI SGR codes in the format string' do
+      it 'properly calculates the length of the bar by removing the long version of the ANSI codes from the calculated length' do
+        @color_code     = "\e[0m\e[32m\e[7m\e[1m"
+        @reset_code     = "\e[0m"
+        @progress_mark  = "#{@color_code} #{@reset_code}"
+        progressbar    = ProgressBar::Base.new(:format        => "#{@color_code}Processing... %b%i#{@reset_code}#{@color_code} %p%%#{@reset_code}",
+                                                :progress_mark => @progress_mark,
+                                                :output        => output,
+                                                :length        => 24,
+                                                :starting_at   => 3,
+                                                :total         => 6,
+                                                :throttle_rate => 0.0)
+
+        progressbar.increment
+        progressbar.increment
+
+        output.rewind
+        output.read.should include "#{@color_code}Processing... #{@progress_mark * 3}#{' ' * 3}#{@reset_code}#{@color_code} 50%#{@reset_code}\r#{@color_code}Processing... #{@progress_mark * 3}#{' ' * 3}#{@reset_code}#{@color_code} 66%#{@reset_code}\r#{@color_code}Processing... #{@progress_mark * 4}#{' ' * 2}#{@reset_code}#{@color_code} 83%#{@reset_code}\r"
+      end
+
+      it 'properly calculates the length of the bar by removing the short version of the ANSI codes from the calculated length' do
+        @color_code     = "\e[0;32;7;1m"
+        @reset_code     = "\e[0m"
+        @progress_mark  = "#{@color_code} #{@reset_code}"
+        progressbar    = ProgressBar::Base.new(:format        => "#{@color_code}Processing... %b%i#{@reset_code}#{@color_code} %p%%#{@reset_code}",
+                                                :progress_mark => @progress_mark,
+                                                :output        => output,
+                                                :length        => 24,
+                                                :starting_at   => 3,
+                                                :total         => 6,
+                                                :throttle_rate => 0.0)
+
+        progressbar.increment
+        progressbar.increment
+
+        output.rewind
+        output.read.should include "#{@color_code}Processing... #{@progress_mark * 3}#{' ' * 3}#{@reset_code}#{@color_code} 50%#{@reset_code}\r#{@color_code}Processing... #{@progress_mark * 3}#{' ' * 3}#{@reset_code}#{@color_code} 66%#{@reset_code}\r#{@color_code}Processing... #{@progress_mark * 4}#{' ' * 2}#{@reset_code}#{@color_code} 83%#{@reset_code}\r"
+      end
+    end
+
     context 'for a TTY enabled device' do
       it 'can log messages' do
-        @progressbar = ProgressBar::Base.new(:output => @output, :length => 20, :starting_at => 3, :total => 6, :throttle_rate => 0.0)
-        @progressbar.increment
-        @progressbar.log 'We All Float'
-        @progressbar.increment
+        progressbar = ProgressBar::Base.new(:output => output, :length => 20, :starting_at => 3, :total => 6, :throttle_rate => 0.0)
+        progressbar.increment
+        progressbar.log 'We All Float'
+        progressbar.increment
 
-        @output.rewind
-        @output.read.should include "Progress: |====    |\rProgress: |=====   |\r                    \rWe All Float\nProgress: |=====   |\rProgress: |======  |\r"
+        output.rewind
+        output.read.should include "Progress: |====    |\rProgress: |=====   |\r                    \rWe All Float\nProgress: |=====   |\rProgress: |======  |\r"
       end
     end
 
     context 'for a non-TTY enabled device' do
       it 'can log messages' do
-        @progressbar = ProgressBar::Base.new(:output => @non_tty_output, :length => 20, :starting_at => 4, :total => 6, :throttle_rate => 0.0)
-        @progressbar.increment
-        @progressbar.log 'We All Float'
-        @progressbar.increment
-        @progressbar.finish
+        progressbar = ProgressBar::Base.new(:output => non_tty_output, :length => 20, :starting_at => 4, :total => 6, :throttle_rate => 0.0)
+        progressbar.increment
+        progressbar.log 'We All Float'
+        progressbar.increment
+        progressbar.finish
+
+        non_tty_output.rewind
+        non_tty_output.read.should include "We All Float\nProgress: |========|\n"
+      end
+
+      it 'can output the bar properly so that it does not spam the screen' do
+        progressbar = ProgressBar::Base.new(:output => non_tty_output, :length => 20, :starting_at => 0, :total => 6, :throttle_rate => 0.0)
+
+        6.times { progressbar.increment }
+
+        non_tty_output.rewind
+        non_tty_output.read.should eql "\n\nProgress: |========|\n"
+      end
+
+      it 'can output the bar properly if finished in the middle of its progress' do
+        progressbar = ProgressBar::Base.new(:output => non_tty_output, :length => 20, :starting_at => 0, :total => 6, :throttle_rate => 0.0)
+
+        3.times { progressbar.increment }
+
+        progressbar.finish
+
+        non_tty_output.rewind
+        non_tty_output.read.should eql "\n\nProgress: |========|\n"
+      end
+
+      it 'can output the bar properly if stopped in the middle of its progress' do
+        progressbar = ProgressBar::Base.new(:output => non_tty_output, :length => 20, :starting_at => 0, :total => 6, :throttle_rate => 0.0)
+
+        3.times { progressbar.increment }
 
-        @non_tty_output.rewind
-        @non_tty_output.read.should include "We All Float\nProgress: |========|\n"
+        progressbar.stop
+
+        non_tty_output.rewind
+        non_tty_output.read.should eql "\n\nProgress: |====\n"
       end
     end
   end
 
   context 'when a bar is about to be completed' do
-    before do
-      @progressbar = ProgressBar::Base.new(:starting_at => 99, :total => 100, :output => @output, :length => 80)
-    end
+    let(:progressbar) { ProgressBar::Base.new(:starting_at => 5, :total => 6, :output => output, :length => 20) }
 
     context 'and it is incremented' do
-      before { @progressbar.increment }
+      before { progressbar.increment }
 
       it 'registers as being "finished"' do
-        @progressbar.should be_finished
+        progressbar.should be_finished
       end
 
       it 'prints a new line' do
-        @output.rewind
-        @output.read.end_with?("\n").should be_true
+        output.rewind
+        output.read.end_with?("\n").should be_true
+      end
+
+      it 'does not continue to print bars if finish is subsequently called' do
+        progressbar.finish
+
+        output.rewind
+        output.read.should end_with "                    \rProgress: |======  |\rProgress: |========|\n"
       end
     end
   end
 
   context 'when a bar has an unknown amount to completion' do
-    before do
-      @progressbar = ProgressBar::Base.new(:total => nil, :output => @output, :length => 80, :unknown_progress_animation_steps => ['=--', '-=-', '--='])
-    end
+    let(:progressbar) { ProgressBar::Base.new(:total => nil, :output => output, :length => 80, :unknown_progress_animation_steps => ['=--', '-=-', '--=']) }
 
     it 'is represented correctly' do
-      @progressbar.to_s('%i').should eql '=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=-'
+      progressbar.to_s('%i').should eql '=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=-'
     end
 
     it 'is represented after being incremented once' do
-      @progressbar.increment
-      @progressbar.to_s('%i').should eql '-=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--='
+      progressbar.increment
+      progressbar.to_s('%i').should eql '-=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--='
     end
 
     it 'is represented after being incremented twice' do
-      @progressbar.increment
-      @progressbar.increment
-      @progressbar.to_s('%i').should eql '--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--'
+      progressbar.increment
+      progressbar.increment
+      progressbar.to_s('%i').should eql '--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--'
     end
 
     it 'displays the proper ETA' do
-      @progressbar.to_s('%i%e').should eql '=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=-- ETA: ??:??:??'
+      progressbar.to_s('%i%e').should eql '=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=--=-- ETA: ??:??:??'
     end
   end
 
   context 'when a bar is started' do
-    before do
-      @progressbar = ProgressBar::Base.new(:starting_at => 0, :total => 100, :output => @output, :length => 80, :throttle_rate  => 0.0)
-    end
+    let(:progressbar) { ProgressBar::Base.new(:starting_at => 0, :total => 100, :output => output, :length => 80, :throttle_rate  => 0.0) }
 
     context 'and it is incremented any number of times' do
-      before { 10.times { @progressbar.increment } }
+      before { 10.times { progressbar.increment } }
 
       describe '#progress_mark=' do
         it 'changes the mark used to represent progress and updates the output' do
-          @progressbar.progress_mark = 'x'
+          progressbar.progress_mark = 'x'
+
+          output.rewind
+          output.read.should match /\rProgress: \|xxxxxx#{' ' * 62}\|\r\z/
+        end
+      end
+
+      describe '#remainder_mark=' do
+        it 'changes the mark used to represent the remaining part of the bar and updates the output' do
+          progressbar.remainder_mark = 'x'
 
-          @output.rewind
-          @output.read.should match /\rProgress: \|xxxxxx#{' ' * 62}\|\r\z/
+          output.rewind
+          output.read.should match /\rProgress: \|======#{'x' * 62}\|\r\z/
         end
       end
 
       describe '#title=' do
         it 'changes the title used to represent the items being progressed and updates the output' do
-          @progressbar.title = 'Items'
+          progressbar.title = 'Items'
 
-          @output.rewind
-          @output.read.should match /\rItems: \|=======#{' ' * 64}\|\r\z/
+          output.rewind
+          output.read.should match /\rItems: \|=======#{' ' * 64}\|\r\z/
         end
       end
 
       describe '#reset' do
-        before { @progressbar.reset }
+        before { progressbar.reset }
 
         it 'resets the bar back to the starting value' do
-          @output.rewind
-          @output.read.should match /\rProgress: \|#{' ' * 68}\|\r\z/
+          output.rewind
+          output.read.should match /\rProgress: \|#{' ' * 68}\|\r\z/
         end
       end
 
       describe '#stop' do
-        before { @progressbar.stop }
+        before { progressbar.stop }
 
         it 'forcibly halts the bar wherever it is and cancels it' do
-          @output.rewind
-          @output.read.should match /\rProgress: \|======#{' ' * 62}\|\n\z/
+          output.rewind
+          output.read.should match /\rProgress: \|======#{' ' * 62}\|\n\z/
+        end
+
+        it 'does not output the bar multiple times if the bar is already stopped' do
+          output.rewind
+          progressbar.stop
+          output.rewind
+
+          output.read.should_not start_with "Progress: |======#{' ' * 62}|"
+        end
+      end
+
+      describe '#resume' do
+        it 'does not output the bar multiple times' do
+          output.rewind
+          progressbar.resume
+          output.rewind
+
+          output.read.should_not start_with "Progress: |======#{' ' * 62}|"
         end
       end
     end
   end
 
   context 'when a bar is started from 10/100' do
-    before do
-      @progressbar = ProgressBar::Base.new(:starting_at => 10, :total => 100, :output => @output, :length => 112)
-    end
+    let(:progressbar) { ProgressBar::Base.new(:starting_at => 10, :total => 100, :output => output, :length => 112) }
 
     context 'and it is incremented any number of times' do
-      before { 10.times { @progressbar.increment } }
+      before { 10.times { progressbar.increment } }
 
       describe '#reset' do
-        before { @progressbar.reset }
+        before { progressbar.reset }
 
         it 'resets the bar back to the starting value' do
-          @output.rewind
-          @output.read.should match /\rProgress: \|==========#{' ' * 90}\|\r\z/
+          output.rewind
+          output.read.should match /\rProgress: \|==========#{' ' * 90}\|\r\z/
         end
       end
     end
@@ -319,246 +419,248 @@ describe ProgressBar::Base do
 
   describe '#clear' do
     it 'clears the current terminal line and/or bar text' do
-      @progressbar.clear
+      progressbar.clear
 
-      @output.rewind
-      @output.read.should match /^#{@progressbar.send(:clear_string)}/
+      output.rewind
+      output.read.should match /^#{progressbar.send(:clear_string)}/
     end
   end
 
   describe '#start' do
     it 'clears the current terminal line' do
-      @progressbar.start
+      progressbar.start
 
-      @output.rewind
-      @output.read.should match /^#{@progressbar.send(:clear_string)}/
+      output.rewind
+      output.read.should match /^#{progressbar.send(:clear_string)}/
     end
 
     it 'prints the bar for the first time' do
-      @progressbar.start
+      progressbar.start
 
-      @output.rewind
-      @output.read.should match /Progress: \|                                                                    \|\r\z/
+      output.rewind
+      output.read.should match /Progress: \|                                                                    \|\r\z/
     end
 
     it 'prints correctly if passed a position to start at' do
-      @progressbar.start(:at => 20)
+      progressbar.start(:at => 20)
 
-      @output.rewind
-      @output.read.should match /Progress: \|=============                                                       \|\r\z/
+      output.rewind
+      output.read.should match /Progress: \|=============                                                       \|\r\z/
     end
   end
 
   context 'when the bar has not been completed' do
-    before { @progressbar = ProgressBar::Base.new(:length => 112, :starting_at => 0, :total => 50, :output => @output, :throttle_rate => 0.0) }
+    let(:progressbar) { ProgressBar::Base.new(:length => 112, :starting_at => 0, :total => 50, :output => output, :throttle_rate => 0.0)  }
 
     describe '#increment' do
-      before { @progressbar.increment }
+      before { progressbar.increment }
 
       it 'displays the bar with the correct formatting' do
-        @output.rewind
-        @output.read.should match /Progress: \|==                                                                                                  \|\r\z/
+        output.rewind
+        output.read.should match /Progress: \|==                                                                                                  \|\r\z/
       end
     end
   end
 
   context 'when a new bar is created with a specific format' do
     context '#format' do
-      before { @progressbar = ProgressBar::Base.new(:format => '%B %p%%') }
+      let(:progressbar) { ProgressBar::Base.new(:format => '%B %p%%') }
 
       context 'if called with no arguments' do
-        before { @progressbar.format }
+        before { progressbar.format }
 
         it 'resets the format back to the default' do
-          @progressbar.to_s.should match /^Progress: \|\s+\|\z/
+          progressbar.to_s.should match /^Progress: \|\s+\|\z/
         end
       end
 
       context 'if called with a specific format string' do
-        before { @progressbar.format '%t' }
+        before { progressbar.format '%t' }
 
         it 'sets it as the new format for the bar' do
-          @progressbar.to_s.should match /^Progress\z/
+          progressbar.to_s.should match /^Progress\z/
         end
       end
     end
 
     context '#to_s' do
       it 'displays the title when passed the "%t" format flag' do
-        @progressbar.to_s('%t').should match /^Progress\z/
+        progressbar.to_s('%t').should match /^Progress\z/
       end
 
       it 'displays the title when passed the "%T" format flag' do
-        @progressbar.to_s('%T').should match /^Progress\z/
+        progressbar.to_s('%T').should match /^Progress\z/
       end
 
       it 'displays the bar when passed the "%B" format flag (including empty space)' do
-        @progressbar = ProgressBar::Base.new(:length => 100, :starting_at => 20)
-        @progressbar.to_s('%B').should match /^#{'=' * 20}#{' ' * 80}\z/
+        progressbar = ProgressBar::Base.new(:length => 100, :starting_at => 20)
+        progressbar.to_s('%B').should match /^#{'=' * 20}#{' ' * 80}\z/
       end
 
       it 'displays the bar when passed the combined "%b%i" format flags' do
-        @progressbar = ProgressBar::Base.new(:length => 100, :starting_at => 20)
-        @progressbar.to_s('%b%i').should match /^#{'=' * 20}#{' ' * 80}\z/
+        progressbar = ProgressBar::Base.new(:length => 100, :starting_at => 20)
+        progressbar.to_s('%b%i').should match /^#{'=' * 20}#{' ' * 80}\z/
       end
 
       it 'displays the bar when passed the "%b" format flag (excluding empty space)' do
-        @progressbar = ProgressBar::Base.new(:length => 100, :starting_at => 20)
-        @progressbar.to_s('%b').should match /^#{'=' * 20}\z/
+        progressbar = ProgressBar::Base.new(:length => 100, :starting_at => 20)
+        progressbar.to_s('%b').should match /^#{'=' * 20}\z/
       end
 
       it 'displays the incomplete space when passed the "%i" format flag' do
-        @progressbar = ProgressBar::Base.new(:length => 100, :starting_at => 20)
-        @progressbar.to_s('%i').should match /^#{' ' * 80}\z/
+        progressbar = ProgressBar::Base.new(:length => 100, :starting_at => 20)
+        progressbar.to_s('%i').should match /^#{' ' * 80}\z/
       end
 
       it 'displays the bar when passed the "%w" format flag' do
-        @progressbar = ProgressBar::Base.new(:output => @output, :length => 100, :starting_at => 0)
+        progressbar = ProgressBar::Base.new(:output => output, :length => 100, :starting_at => 0)
 
-        @progressbar.to_s('%w').should match /^\z/
-        4.times { @progressbar.increment }
-        @progressbar.to_s('%w').should match /^====\z/
-        @progressbar.increment
-        @progressbar.to_s('%w').should match /^= 5 =\z/
-        5.times { @progressbar.increment }
-        @progressbar.to_s('%w').should match /^=== 10 ===\z/
-        @progressbar.decrement
-        @progressbar.to_s('%w').should match /^=== 9 ===\z/
-        91.times { @progressbar.increment }
-        @progressbar.to_s('%w').should match /^#{'=' * 47} 100 #{'=' * 48}\z/
+        progressbar.to_s('%w').should match /^\z/
+        4.times { progressbar.increment }
+        progressbar.to_s('%w').should match /^====\z/
+        progressbar.increment
+        progressbar.to_s('%w').should match /^= 5 =\z/
+        5.times { progressbar.increment }
+        progressbar.to_s('%w').should match /^=== 10 ===\z/
+        progressbar.decrement
+        progressbar.to_s('%w').should match /^=== 9 ===\z/
+        91.times { progressbar.increment }
+        progressbar.to_s('%w').should match /^#{'=' * 47} 100 #{'=' * 48}\z/
       end
 
       it 'calculates the remaining negative space properly with an integrated percentage bar of 0 percent' do
-        @progressbar = ProgressBar::Base.new(:output => @output, :length => 100, :total => 200, :starting_at => 0)
+        progressbar = ProgressBar::Base.new(:output => output, :length => 100, :total => 200, :starting_at => 0)
 
-        @progressbar.to_s('%w%i').should match /^\s{100}\z/
-        9.times { @progressbar.increment }
-        @progressbar.to_s('%w%i').should match /^====\s{96}\z/
-        @progressbar.increment
-        @progressbar.to_s('%w%i').should match /^= 5 =\s{95}\z/
+        progressbar.to_s('%w%i').should match /^\s{100}\z/
+        9.times { progressbar.increment }
+        progressbar.to_s('%w%i').should match /^====\s{96}\z/
+        progressbar.increment
+        progressbar.to_s('%w%i').should match /^= 5 =\s{95}\z/
       end
 
       it 'displays the current capacity when passed the "%c" format flag' do
-        @progressbar = ProgressBar::Base.new(:output => @output, :starting_at => 0)
+        progressbar = ProgressBar::Base.new(:output => output, :starting_at => 0)
 
-        @progressbar.to_s('%c').should match /^0\z/
-        @progressbar.increment
-        @progressbar.to_s('%c').should match /^1\z/
-        @progressbar.decrement
-        @progressbar.to_s('%c').should match /^0\z/
+        progressbar.to_s('%c').should match /^0\z/
+        progressbar.increment
+        progressbar.to_s('%c').should match /^1\z/
+        progressbar.decrement
+        progressbar.to_s('%c').should match /^0\z/
       end
 
       it 'displays the total capacity when passed the "%C" format flag' do
-        @progressbar = ProgressBar::Base.new(:total => 100)
+        progressbar = ProgressBar::Base.new(:total => 100)
 
-        @progressbar.to_s('%C').should match /^100\z/
+        progressbar.to_s('%C').should match /^100\z/
       end
 
       it 'displays the percentage complete when passed the "%p" format flag' do
-        @progressbar = ProgressBar::Base.new(:starting_at => 33, :total => 200)
+        progressbar = ProgressBar::Base.new(:starting_at => 33, :total => 200)
 
-        @progressbar.to_s('%p').should match /^16\z/
+        progressbar.to_s('%p').should match /^16\z/
       end
 
       it 'displays the percentage complete when passed the "%P" format flag' do
-        @progressbar = ProgressBar::Base.new(:starting_at => 33, :total => 200)
+        progressbar = ProgressBar::Base.new(:starting_at => 33, :total => 200)
 
-        @progressbar.to_s('%P').should match /^16.50\z/
+        progressbar.to_s('%P').should match /^16.50\z/
       end
 
       it 'displays only up to 2 decimal places when using the "%P" flag' do
-        @progressbar = ProgressBar::Base.new(:starting_at => 66, :total => 99)
+        progressbar = ProgressBar::Base.new(:starting_at => 66, :total => 99)
 
-        @progressbar.to_s('%P').should match /^66.66\z/
+        progressbar.to_s('%P').should match /^66.66\z/
       end
 
       it 'displays a literal percent sign when using the "%%" flag' do
-        @progressbar = ProgressBar::Base.new(:starting_at => 66, :total => 99)
+        progressbar = ProgressBar::Base.new(:starting_at => 66, :total => 99)
 
-        @progressbar.to_s('%%').should match /^%\z/
+        progressbar.to_s('%%').should match /^%\z/
       end
 
       it 'displays a literal percent sign when using the "%%" flag' do
-        @progressbar = ProgressBar::Base.new(:starting_at => 66, :total => 99)
+        progressbar = ProgressBar::Base.new(:starting_at => 66, :total => 99)
 
-        @progressbar.to_s('%%').should match /^%\z/
+        progressbar.to_s('%%').should match /^%\z/
       end
 
       # Autostarting for now.  This will be applicable later.
       # context "when called before #start" do
         # it "displays unknown time elapsed when using the %a flag" do
-          # @progressbar.to_s('%a').should match /^Time: --:--:--\z/
+          # progressbar.to_s('%a').should match /^Time: --:--:--\z/
         # end
       # end
 
       context 'when called after #start' do
         before do
           Timecop.travel(-3723) do
-            @progressbar.start
+            progressbar.start
           end
         end
 
         context 'and the bar is reset' do
-          before { @progressbar.reset }
+          before { progressbar.reset }
 
           it 'displays "??:??:??" until finished when passed the %e flag' do
-            @progressbar.to_s('%a').should match /^Time: --:--:--\z/
+            progressbar.to_s('%a').should match /^Time: --:--:--\z/
           end
         end
 
         it 'displays the time elapsed when using the "%a" flag' do
-          @progressbar.to_s('%a').should match /^Time: 01:02:03\z/
+          progressbar.to_s('%a').should match /^Time: 01:02:03\z/
         end
       end
 
       context 'when called before #start' do
         it 'displays unknown time until finished when passed the "%e" flag' do
-          @progressbar = ProgressBar::Base.new
-          @progressbar.to_s('%e').should match /^ ETA: \?\?:\?\?:\?\?\z/
+          progressbar = ProgressBar::Base.new
+          progressbar.to_s('%e').should match /^ ETA: \?\?:\?\?:\?\?\z/
         end
       end
 
       context 'when called after #start' do
-        before do
+        let(:progressbar) do
           Timecop.travel(-3723) do
-            @progressbar = ProgressBar::Base.new(:starting_at => 0, :output => @output, :smoothing => 0.0)
-            @progressbar.start
-            @progressbar.progress = 50
+            progressbar = ProgressBar::Base.new(:starting_at => 0, :output => output, :smoothing => 0.0)
+            progressbar.start
+            progressbar.progress = 50
+            progressbar
           end
         end
 
         context 'and the bar is reset' do
-          before { @progressbar.reset }
+          before { progressbar.reset }
 
           it 'displays "??:??:??" until finished when passed the "%e" flag' do
-            @progressbar.to_s('%e').should match /^ ETA: \?\?:\?\?:\?\?\z/
+            progressbar.to_s('%e').should match /^ ETA: \?\?:\?\?:\?\?\z/
           end
         end
 
         it 'displays the estimated time remaining when using the "%e" flag' do
-          @progressbar.to_s('%e').should match /^ ETA: 01:02:02\z/
+          progressbar.to_s('%e').should match /^ ETA: 01:02:02\z/
         end
       end
 
       context 'when it could take 100 hours or longer to finish' do
-        before do
+        let(:progressbar) do
           Timecop.travel(-120000) do
-            @progressbar = ProgressBar::Base.new(:starting_at => 0, :total => 100, :output => @output, :smoothing => 0.0)
-            @progressbar.start
-            @progressbar.progress = 25
+            progressbar = ProgressBar::Base.new(:starting_at => 0, :total => 100, :output => output, :smoothing => 0.0)
+            progressbar.start
+            progressbar.progress = 25
+            progressbar
           end
         end
 
         it 'displays "> 4 Days" until finished when passed the "%E" flag' do
-          @progressbar.to_s('%E').should match /^ ETA: > 4 Days\z/
+          progressbar.to_s('%E').should match /^ ETA: > 4 Days\z/
         end
 
         it 'displays "??:??:??" until finished when passed the "%e" flag' do
-          @progressbar.to_s('%e').should match /^ ETA: \?\?:\?\?:\?\?\z/
+          progressbar.to_s('%e').should match /^ ETA: \?\?:\?\?:\?\?\z/
         end
 
         it 'displays the exact estimated time until finished when passed the "%f" flag' do
-          @progressbar.to_s('%f').should match /^ ETA: 100:00:00\z/
+          progressbar.to_s('%f').should match /^ ETA: 100:00:00\z/
         end
       end
     end