ruby-progressbar 1.6.1 → 1.7.0

data/lib/ruby-progressbar/calculators/running_average.rb

@@ -0,0 +1,9 @@
+class   ProgressBar
+module  Calculators
+class   RunningAverage
+  def self.calculate(current_average, new_value_to_average, smoothing_factor)
+    new_value_to_average * (1.0 - smoothing_factor) + current_average * smoothing_factor
+  end
+end
+end
+end

data/lib/ruby-progressbar/components.rb

@@ -1,7 +1,5 @@
-require 'ruby-progressbar/components/timer'
-require 'ruby-progressbar/components/progressable'
 require 'ruby-progressbar/components/bar'
-require 'ruby-progressbar/components/estimated_timer'
-require 'ruby-progressbar/components/elapsed_timer'
-require 'ruby-progressbar/components/throttle'
+require 'ruby-progressbar/components/percentage'
 require 'ruby-progressbar/components/rate'
+require 'ruby-progressbar/components/time'
+require 'ruby-progressbar/components/title'

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

@@ -1,60 +1,96 @@
-class ProgressBar
-  module Components
-    class Bar
-      include Progressable
+###
+# UPA = Unknown Progress Animation
+#
+class   ProgressBar
+module  Components
+class   Bar
+  DEFAULT_PROGRESS_MARK  = '='
+  DEFAULT_REMAINDER_MARK = ' '
+  DEFAULT_UPA_STEPS      = ['=---', '-=--', '--=-', '---=']
 
-      DEFAULT_PROGRESS_MARK                    = '='
-      DEFAULT_REMAINDER_MARK                   = ' '
-      DEFAULT_UNKNOWN_PROGRESS_ANIMATION_STEPS = ['=---', '-=--', '--=-', '---=']
+  attr_accessor :progress_mark,
+                :remainder_mark,
+                :length,
+                :progress,
+                :upa_steps
 
-      attr_accessor :progress_mark
-      attr_accessor :remainder_mark
-      attr_accessor :length
-      attr_accessor :unknown_progress_animation_steps
+  def initialize(options = {})
+    self.upa_steps      = options[:unknown_progress_animation_steps] || DEFAULT_UPA_STEPS
+    self.progress_mark  = options[:progress_mark]  || DEFAULT_PROGRESS_MARK
+    self.remainder_mark = options[:remainder_mark] || DEFAULT_REMAINDER_MARK
+    self.progress       = options[:progress]
+    self.length         = options[:length]
+  end
 
-      def initialize(options = {})
-        super
+  def to_s(options = { :format => :standard })
+    if progress.unknown?
+      unknown_string
+    elsif options[:format] == :standard
+      "#{standard_complete_string}#{incomplete_string}"
+    elsif options[:format] == :integrated_percentage
+      "#{integrated_percentage_complete_string}#{incomplete_string}"
+    end
+  end
 
-        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
+  private
 
-      def to_s(options = {:format => :standard})
-        completed_string = send(:"#{options[:format]}_complete_string")
+  def integrated_percentage_complete_string
+    return standard_complete_string if completed_length < 5
 
-        "#{completed_string}#{empty_string}"
-      end
+    " #{progress.percentage_completed} ".to_s.center(completed_length, progress_mark)
+  end
 
-      def integrated_percentage_complete_string
-        return standard_complete_string if completed_length < 5
+  def standard_complete_string
+    progress_mark * completed_length
+  end
 
-        " #{percentage_completed} ".to_s.center(completed_length, progress_mark)
-      end
+  def incomplete_string
+    remainder_mark * (length - completed_length)
+  end
 
-      def standard_complete_string
-        progress_mark * completed_length
-      end
+  def bar(length)
+    self.length = length
 
-      def empty_string
-        incomplete_length = (length - completed_length)
+    standard_complete_string
+  end
+
+  def complete_bar(length)
+    self.length = length
 
-        if total.nil?
-          current_animation_step = progress % unknown_progress_animation_steps.size
-          animation_graphic      = unknown_progress_animation_steps[current_animation_step]
+    to_s
+  end
 
-          unknown_incomplete_string = animation_graphic * ((incomplete_length / unknown_progress_animation_steps.size) + 2)
+  def unknown_string
+    unknown_frame_string = unknown_progress_frame * ((length / upa_steps.size) + 2)
+
+    unknown_frame_string[0, length]
+  end
 
-          unknown_incomplete_string[0, incomplete_length]
-        else
-          remainder_mark * incomplete_length
-        end
-      end
+  def incomplete_space(length)
+    self.length = length
 
-    private
-      def completed_length
-        (length * percentage_completed / 100).floor
-      end
+    if progress.unknown?
+      unknown_string
+    else
+      incomplete_string
     end
   end
+
+  def bar_with_percentage(length)
+    self.length = length
+
+    integrated_percentage_complete_string
+  end
+
+  def completed_length
+    (length * progress.percentage_completed / 100).floor
+  end
+
+  def unknown_progress_frame
+    current_animation_step = progress.progress % upa_steps.size
+
+    upa_steps[current_animation_step]
+  end
+end
+end
 end

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

@@ -0,0 +1,29 @@
+class   ProgressBar
+module  Components
+class   Percentage
+  attr_accessor :progress
+
+  def initialize(options = {})
+    self.progress = options[:progress]
+  end
+
+  private
+
+  def percentage
+    progress.percentage_completed
+  end
+
+  def justified_percentage
+    progress.percentage_completed.to_s.rjust(3)
+  end
+
+  def percentage_with_precision
+    progress.percentage_completed_with_precision
+  end
+
+  def justified_percentage_with_precision
+    progress.percentage_completed_with_precision.to_s.rjust(6)
+  end
+end
+end
+end

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

@@ -1,71 +1,43 @@
-class ProgressBar
-  module Components
-    class Rate
-      include Timer
-      include Progressable
-
-      attr_accessor :rate_scale
-
-      def initialize(options = {})
-        self.rate_scale = options[:rate_scale]
-        @started_at     = nil
-        @stopped_at     = nil
-
-        super
-      end
-
-      def start(options = {})
-        as(Timer).start
-        as(Progressable).start(options)
-      end
-
-      def reset
-        as(Timer).reset
-        as(Progressable).reset
-      end
-
-      def to_s(format_string = "%i")
-        elapsed = elapsed_whole_seconds.to_f
-        return 0 unless elapsed > 0
-
-        base_rate   = (progress_made / elapsed)
-
-        if rate_scale
-          scaled_rate = rate_scale.call(base_rate)
-        else
-          scaled_rate = base_rate
-        end
+class   ProgressBar
+module  Components
+class   Rate
+  attr_accessor :rate_scale,
+                :started_at,
+                :stopped_at,
+                :timer,
+                :progress
+
+  def initialize(options = {})
+    self.rate_scale = options[:rate_scale] || lambda { |x| x }
+    self.started_at = nil
+    self.stopped_at = nil
+    self.timer      = options[:timer]
+    self.progress   = options[:progress]
+  end
 
-        format_string % scaled_rate
-      end
+  private
 
-    private
+  def rate_of_change(format_string = '%i')
+    return 0 unless elapsed_seconds > 0
 
-      def as(ancestor, &blk)
-        @__as ||= {}
-        unless r = @__as[ancestor]
-          r = (@__as[ancestor] = As.new(self, ancestor))
-        end
-        r.instance_eval(&blk) if block_given?
-        r
-      end
+    format_string % scaled_rate
+  end
 
-      class As
-        private(*instance_methods.select { |m| m !~ /(^__|^\W|^binding$)/ })
+  def rate_of_change_with_precision
+    rate_of_change('%.2f')
+  end
 
-        def initialize(subject, ancestor)
-          @subject = subject
-          @ancestor = ancestor
-        end
+  def scaled_rate
+    rate_scale.call(base_rate)
+  end
 
-        def start(*args, &blk)
-          @ancestor.instance_method(:start).bind(@subject).call(*args,&blk)
-        end
+  def base_rate
+    progress.absolute / elapsed_seconds
+  end
 
-        def method_missing(sym, *args, &blk)
-          @ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
-        end
-      end
-    end
+  def elapsed_seconds
+    timer.elapsed_whole_seconds.to_f
   end
 end
+end
+end

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

@@ -0,0 +1,103 @@
+###
+# OOB = 'Out of Bounds'
+#
+class   ProgressBar
+module  Components
+class   Time
+  TIME_FORMAT            = '%02d:%02d:%02d'
+  OOB_TIME_FORMATS       = [:unknown, :friendly, nil]
+  OOB_LIMIT_IN_HOURS     = 99
+  OOB_UNKNOWN_TIME_TEXT  = '??:??:??'
+  OOB_FRIENDLY_TIME_TEXT = '> 4 Days'
+  NO_TIME_ELAPSED_TEXT   = '--:--:--'
+  ESTIMATED_LABEL        = ' ETA'
+  ELAPSED_LABEL          = 'Time'
+
+  def initialize(options = {})
+    self.out_of_bounds_time_format = options[:out_of_bounds_time_format]
+    self.timer                     = options[:timer]
+    self.progress                  = options[:progress]
+  end
+
+  def estimated_with_label
+    "#{ESTIMATED_LABEL}: #{estimated}"
+  end
+
+  def elapsed_with_label
+    "#{ELAPSED_LABEL}: #{elapsed}"
+  end
+
+  protected
+
+  def estimated_with_no_oob
+    self.out_of_bounds_time_format = nil
+
+    estimated_with_elapsed_fallback
+  end
+
+  def estimated_with_unknown_oob
+    self.out_of_bounds_time_format = :unknown
+
+    estimated_with_elapsed_fallback
+  end
+
+  def estimated_with_friendly_oob
+    self.out_of_bounds_time_format = :friendly
+
+    estimated_with_elapsed_fallback
+  end
+
+  attr_accessor :out_of_bounds_time_format,
+                :timer,
+                :progress
+
+  def out_of_bounds_time_format=(format)
+    unless OOB_TIME_FORMATS.include? format
+      fail 'Invalid Out Of Bounds time format.  Valid formats are ' +
+        OOB_TIME_FORMATS.inspect
+    end
+
+    @out_of_bounds_time_format = format
+  end
+
+  private
+
+  def estimated
+    return OOB_UNKNOWN_TIME_TEXT if progress.unknown? || progress.none? || timer.stopped?
+
+    hours, minutes, seconds = timer.divide_seconds(estimated_seconds_remaining)
+
+    if hours > OOB_LIMIT_IN_HOURS && out_of_bounds_time_format
+      out_of_bounds_time
+    else
+      TIME_FORMAT % [hours, minutes, seconds]
+    end
+  end
+
+  def elapsed
+    return NO_TIME_ELAPSED_TEXT unless timer.started?
+
+    hours, minutes, seconds = timer.divide_seconds(timer.elapsed_whole_seconds)
+
+    TIME_FORMAT % [hours, minutes, seconds]
+  end
+
+  def estimated_with_elapsed_fallback
+    progress.finished? ? elapsed_with_label : estimated_with_label
+  end
+
+  def estimated_seconds_remaining
+    (timer.elapsed_seconds * (progress.total / progress.running_average - 1)).round
+  end
+
+  def out_of_bounds_time
+    case out_of_bounds_time_format
+    when :unknown
+      OOB_UNKNOWN_TIME_TEXT
+    when :friendly
+      OOB_FRIENDLY_TIME_TEXT
+    end
+  end
+end
+end
+end

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

@@ -0,0 +1,13 @@
+class   ProgressBar
+module  Components
+class   Title
+  DEFAULT_TITLE = 'Progress'
+
+  attr_accessor :title
+
+  def initialize(options = {})
+    self.title = options[:title] || DEFAULT_TITLE
+  end
+end
+end
+end

data/lib/ruby-progressbar/format.rb

@@ -1,2 +1,3 @@
 require 'ruby-progressbar/format/molecule'
-require 'ruby-progressbar/format/base'
+require 'ruby-progressbar/format/formatter'
+require 'ruby-progressbar/format/string'

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

@@ -0,0 +1,27 @@
+class   ProgressBar
+module  Format
+class   Formatter
+  def self.process(format_string, max_length, bar)
+    processed_string = format_string.dup
+
+    format_string.non_bar_molecules.each do |molecule|
+      processed_string.gsub!(molecule.full_key, molecule.lookup_value(bar, nil))
+    end
+
+    processed_string.gsub!(/%%/, '%')
+
+    bar_length         = max_length -
+                         processed_string.displayable_length +
+                         format_string.bar_molecule_placeholder_length
+    bar_length         = bar_length < 0 ? 0 : bar_length
+
+    format_string.bar_molecules.each do |molecule|
+      processed_string.gsub!(molecule.full_key,
+                             molecule.lookup_value(bar, bar_length))
+    end
+
+    processed_string
+  end
+end
+end
+end