ruby-progressbar 1.6.1 → 1.7.0

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

@@ -1,40 +1,58 @@
-class ProgressBar
-  module Format
-    class Molecule
-      MOLECULES = {
-        :t => :title,
-        :T => :title,
-        :c => :progress,
-        :C => :total,
-        :p => :percentage,
-        :P => :percentage_with_precision,
-        :j => :justified_percentage,
-        :J => :justified_percentage_with_precision,
-        :a => :elapsed_time,
-        :e => :estimated_time_with_unknown_oob,
-        :E => :estimated_time_with_friendly_oob,
-        :f => :estimated_time_with_no_oob,
-        :B => :complete_bar,
-        :b => :bar,
-        :w => :bar_with_percentage,
-        :i => :incomplete_space,
-        :r => :rate_of_change,
-        :R => :rate_of_change_with_precision,
-      }
-
-      BAR_MOLECULES     = %w{w B b i}
-
-      attr_reader   :key
-      attr_reader   :method_name
-
-      def initialize(letter)
-        @key         = letter
-        @method_name = MOLECULES.fetch(@key.to_sym)
-      end
-
-      def bar_molecule?
-        BAR_MOLECULES.include? @key
-      end
+class   ProgressBar
+module  Format
+class   Molecule
+  MOLECULES = {
+    :t => [:title_comp,   :title],
+    :T => [:title_comp,   :title],
+    :c => [:progressable, :progress],
+    :C => [:progressable, :total],
+    :p => [:percentage,   :percentage],
+    :P => [:percentage,   :percentage_with_precision],
+    :j => [:percentage,   :justified_percentage],
+    :J => [:percentage,   :justified_percentage_with_precision],
+    :a => [:time,         :elapsed_with_label],
+    :e => [:time,         :estimated_with_unknown_oob],
+    :E => [:time,         :estimated_with_friendly_oob],
+    :f => [:time,         :estimated_with_no_oob],
+    :B => [:bar,          :complete_bar],
+    :b => [:bar,          :bar],
+    :w => [:bar,          :bar_with_percentage],
+    :i => [:bar,          :incomplete_space],
+    :r => [:rate,         :rate_of_change],
+    :R => [:rate,         :rate_of_change_with_precision],
+  }
+
+  BAR_MOLECULES = %w{w B b i}
+
+  attr_accessor :key,
+                :method_name
+
+  def initialize(letter)
+    self.key         = letter
+    self.method_name = MOLECULES.fetch(key.to_sym)
+  end
+
+  def bar_molecule?
+    BAR_MOLECULES.include? key
+  end
+
+  def non_bar_molecule?
+    !bar_molecule?
+  end
+
+  def full_key
+    "%#{key}"
+  end
+
+  def lookup_value(environment, length = 0)
+    component = environment.send(method_name[0])
+
+    if bar_molecule?
+      component.send(method_name[1], length).to_s
+    else
+      component.send(method_name[1]).to_s
     end
   end
 end
+end
+end

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

@@ -0,0 +1,36 @@
+class   ProgressBar
+module  Format
+class   String < ::String
+  MOLECULE_PATTERN = /%[a-zA-Z]/
+  ANSI_SGR_PATTERN = /\e\[[\d;]+m/
+
+  def displayable_length
+    gsub(ANSI_SGR_PATTERN, '').length
+  end
+
+  def bar_molecule_placeholder_length
+    @bar_molecule_placeholder_length ||= bar_molecules.size * 2
+  end
+
+  def non_bar_molecules
+    @non_bar_molecules ||= molecules.select(&:non_bar_molecule?)
+  end
+
+  def bar_molecules
+    @bar_molecules ||= molecules.select(&:bar_molecule?)
+  end
+
+  def molecules
+    @molecules ||= begin
+                      molecules = []
+
+                      scan(MOLECULE_PATTERN) do |match|
+                        molecules << Molecule.new(match[1, 1])
+                      end
+
+                      molecules
+                    end
+  end
+end
+end
+end

data/lib/ruby-progressbar/output.rb

@@ -0,0 +1,61 @@
+class   ProgressBar
+class   Output
+  DEFAULT_OUTPUT_STREAM = $stdout
+
+  attr_accessor :stream
+
+  def initialize(options = {})
+    self.bar               = options[:bar]
+    self.stream            = options[:output] || DEFAULT_OUTPUT_STREAM
+    self.length_calculator = Calculators::Length.new(options)
+    self.throttle          = Throttle.new(options)
+  end
+
+  def self.detect(options = {})
+    if (options[:output] || DEFAULT_OUTPUT_STREAM).tty?
+      Outputs::Tty.new(options)
+    else
+      Outputs::NonTty.new(options)
+    end
+  end
+
+  def log(string)
+    clear
+    stream.puts string
+
+    refresh(:force => true) unless bar.stopped?
+  end
+
+  def clear_string
+    ' ' * length_calculator.length
+  end
+
+  def length
+    length_calculator.length
+  end
+
+  def with_refresh
+    yield
+    refresh
+  end
+
+  def refresh(options = {})
+    throttle.choke(:force_update_if => (bar.stopped? || options[:force])) do
+      clear if length_calculator.length_changed?
+
+      print_and_flush
+    end
+  end
+
+  def print_and_flush
+    stream.print bar_update_string + eol
+    stream.flush
+  end
+
+  protected
+
+  attr_accessor :length_calculator,
+                :throttle,
+                :bar
+end
+end

data/lib/ruby-progressbar/outputs/non_tty.rb

@@ -0,0 +1,47 @@
+require 'ruby-progressbar/output'
+
+class   ProgressBar
+module  Outputs
+class   NonTty < Output
+  DEFAULT_FORMAT_STRING = '%t: |%b|'
+
+  def clear
+    self.last_update_length = 0
+
+    stream.print "\n"
+  end
+
+  def last_update_length
+    @last_update_length ||= 0
+  end
+
+  def bar_update_string
+    formatted_string        = bar.to_s
+    formatted_string        = formatted_string[0...-1] unless bar.finished?
+
+    output_string           = formatted_string[last_update_length..-1]
+    self.last_update_length = formatted_string.length
+
+    output_string
+  end
+
+  def default_format
+    DEFAULT_FORMAT_STRING
+  end
+
+  def resolve_format(*)
+    default_format
+  end
+
+  def refresh_with_format_change(*); end
+
+  def eol
+    bar.stopped? ? "\n" : ''
+  end
+
+  protected
+
+  attr_accessor :last_update_length
+end
+end
+end

data/lib/ruby-progressbar/outputs/tty.rb

@@ -0,0 +1,32 @@
+require 'ruby-progressbar/output'
+
+class   ProgressBar
+module  Outputs
+class   Tty < Output
+  DEFAULT_FORMAT_STRING = '%t: |%B|'
+
+  alias_method :refresh_with_format_change, :with_refresh
+
+  def clear
+    stream.print clear_string
+    stream.print "\r"
+  end
+
+  def bar_update_string
+    bar.to_s
+  end
+
+  def default_format
+    DEFAULT_FORMAT_STRING
+  end
+
+  def resolve_format(other_format)
+    other_format || default_format
+  end
+
+  def eol
+    bar.stopped? ? "\n" : "\r"
+  end
+end
+end
+end

data/lib/ruby-progressbar/progress.rb

@@ -0,0 +1,110 @@
+require 'ruby-progressbar/errors/invalid_progress_error'
+
+class   ProgressBar
+class   Progress
+  DEFAULT_TOTAL              = 100
+  DEFAULT_BEGINNING_POSITION = 0
+  DEFAULT_SMOOTHING          = 0.1
+
+  attr_accessor             :total,
+                            :progress,
+                            :starting_position,
+                            :running_average,
+                            :smoothing
+
+  def initialize(options = {})
+    self.total     = options.fetch(:total, DEFAULT_TOTAL)
+    self.smoothing = options[:smoothing] || DEFAULT_SMOOTHING
+
+    start :at => DEFAULT_BEGINNING_POSITION
+  end
+
+  def start(options = {})
+    self.running_average   = 0
+    self.progress          = \
+    self.starting_position = options[:at] || progress
+  end
+
+  def finish
+    self.progress = total
+  end
+
+  def finished?
+    @progress == @total
+  end
+
+  def increment
+    warn "WARNING: Your progress bar is currently at #{progress} out of #{total} " \
+         'and cannot be incremented. In v2.0.0 this will become a ' \
+         'ProgressBar::InvalidProgressError.' if progress == total
+
+    self.progress += 1 unless progress == total
+  end
+
+  def decrement
+    warn "WARNING: Your progress bar is currently at #{progress} out of #{total} " \
+         'and cannot be decremented. In v2.0.0 this will become a ' \
+         'ProgressBar::InvalidProgressError.' if progress == 0
+
+    self.progress -= 1 unless progress == 0
+  end
+
+  def reset
+    start :at => starting_position
+  end
+
+  def progress=(new_progress)
+    fail ProgressBar::InvalidProgressError,
+         "You can't set the item's current value to be greater than the total." \
+    if total &&
+       new_progress > total
+
+    @progress = new_progress
+
+    self.running_average = Calculators::RunningAverage.calculate(running_average,
+                                                                 absolute,
+                                                                 smoothing)
+  end
+
+  def total=(new_total)
+    fail ProgressBar::InvalidProgressError,
+         "You can't set the item's total value to less than the current progress." \
+    unless progress.nil?  ||
+           new_total.nil? ||
+           new_total >= progress
+
+    @total = new_total
+  end
+
+  def percentage_completed
+    return 0   if total.nil?
+    return 100 if total.zero?
+
+    # progress / total * 100
+    #
+    # Doing this way so we can avoid converting each
+    # number to a float and then back to an integer.
+    #
+    (progress * 100 / total).to_i
+  end
+
+  def none?
+    progress.zero?
+  end
+
+  def unknown?
+    progress.nil? || total.nil?
+  end
+
+  def percentage_completed_with_precision
+    return 100.0  if total == 0
+    return 0.0    if total.nil?
+
+    format('%5.2f', (progress.to_f * 100.0 / total * 100.0).floor / 100.0)
+  end
+
+  def absolute
+    progress - starting_position
+  end
+end
+end

data/lib/ruby-progressbar/throttle.rb

@@ -0,0 +1,25 @@
+class   ProgressBar
+class   Throttle
+  attr_accessor :rate,
+                :started_at,
+                :stopped_at,
+                :timer
+
+  def initialize(options = {})
+    self.rate       = options[:throttle_rate] || 0.01
+    self.started_at = nil
+    self.stopped_at = nil
+    self.timer      = options.fetch(:throttle_timer, Timer.new)
+  end
+
+  def choke(options = {})
+    return unless !timer.started?                        ||
+                  options.fetch(:force_update_if, false) ||
+                  timer.elapsed_seconds >= rate
+
+    timer.restart
+
+    yield
+  end
+end
+end

data/lib/ruby-progressbar/time.rb

@@ -1,22 +1,25 @@
-class ProgressBar
-  class Time
-    def self.now(time = ::Time)
-      @@time = time
+class   ProgressBar
+class   Time
+  def self.now(time = ::Time)
+    @time = time
 
-      @@time.send unmocked_time_method
-    end
+    @time.send unmocked_time_method
+  end
 
-  private
-    def self.unmocked_time_method
-      time_mocking_library_methods.find { |method| @@time.respond_to? method }
-    end
+  def self.unmocked_time_method
+    @unmocked_time_method ||= begin
+                                time_mocking_library_methods.find do |method|
+                                  @time.respond_to? method
+                                end
+                              end
+  end
 
-    def self.time_mocking_library_methods
-      [
-        :now_without_mock_time,       # Timecop
-        :now_without_delorean,        # Delorean
-        :now                          # Actual
-      ]
-    end
+  def self.time_mocking_library_methods
+    [
+      :now_without_mock_time,       # Timecop
+      :now_without_delorean,        # Delorean
+      :now                          # Actual
+    ]
   end
 end
+end