ruby-progressbar 0.11.0 → 1.0.0rc1

data/lib/progress_bar/components.rb

@@ -0,0 +1,5 @@
+require 'progress_bar/components/timer'
+require 'progress_bar/components/progressable'
+require 'progress_bar/components/bar'
+require 'progress_bar/components/estimated_timer'
+require 'progress_bar/components/elapsed_timer'

data/lib/progress_bar/components/bar.rb

@@ -0,0 +1,44 @@
+class ProgressBar
+  module Components
+    class Bar
+      include Progressable
+
+      DEFAULT_PROGRESS_MARK = '='
+
+      attr_accessor :progress_mark
+      attr_accessor :length
+
+      def initialize(options = {})
+        super
+
+        self.progress_mark   = options[:progress_mark] || DEFAULT_PROGRESS_MARK
+      end
+
+      def to_s(options = {:format => :standard})
+        completed_string = send(:"#{options[:format]}_complete_string")
+        empty_string     = ' ' * (length - completed_string.length)
+
+        "#{completed_string}#{empty_string}"
+      end
+
+      def integrated_percentage_complete_string
+        return standard_complete_string if completed_length < 5
+
+        " #{percentage_completed} ".to_s.center(completed_length, progress_mark)
+      end
+
+      def standard_complete_string
+        progress_mark * completed_length
+      end
+
+      def empty_string
+        ' ' * (length - completed_length)
+      end
+
+    private
+      def completed_length
+        length * percentage_completed / 100
+      end
+    end
+  end
+end

data/lib/progress_bar/components/elapsed_timer.rb

@@ -0,0 +1,20 @@
+class ProgressBar
+  module Components
+    class ElapsedTimer
+      include Timer
+
+      def to_s
+        "Time: #{elapsed_time}"
+      end
+
+    private
+      def elapsed_time
+        return '--:--:--' unless started?
+
+        hours, minutes, seconds = divide_seconds(elapsed_seconds)
+
+        sprintf TIME_FORMAT, hours, minutes, seconds
+      end
+    end
+  end
+end

data/lib/progress_bar/components/estimated_timer.rb

@@ -0,0 +1,88 @@
+class ProgressBar
+  module Components
+    class EstimatedTimer
+      include Timer
+      include Progressable
+
+      VALID_OOB_TIME_FORMATS = [:unknown, :friendly, nil]
+
+      def initialize(options = {})
+        super
+      end
+
+      def start(options = {})
+        as(Timer).start
+        as(Progressable).start(options)
+      end
+
+      def reset
+        as(Timer).reset
+        as(Progressable).reset
+      end
+
+      def out_of_bounds_time_format=(format)
+        raise "Invalid Out Of Bounds time format.  Valid formats are #{VALID_OOB_TIME_FORMATS.inspect}" unless VALID_OOB_TIME_FORMATS.include? format
+
+        @out_of_bounds_time_format = format
+      end
+
+      def to_s
+        " ETA: #{estimated_time}"
+      end
+
+    private
+      def estimated_time
+        return '??:??:??' if progress_made.zero?
+
+        hours, minutes, seconds = divide_seconds(estimated_seconds_remaining)
+
+        if hours > 99 && @out_of_bounds_time_format
+          out_of_bounds_time
+        else
+          sprintf TIME_FORMAT, hours, minutes, seconds
+        end
+      end
+
+      def average_seconds_per_each
+        return 0 if self.running_average.zero?
+
+        elapsed_seconds.to_f / self.running_average
+      end
+
+      def estimated_seconds_remaining
+        ((average_seconds_per_each * self.total) - elapsed_seconds.to_f).floor
+      end
+
+      def out_of_bounds_time
+        case @out_of_bounds_time_format
+        when :unknown
+          '??:??:??'
+        when :friendly
+          '> 4 Days'
+        end
+      end
+
+      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
+
+      class As
+        private *instance_methods.select { |m| m !~ /(^__|^\W|^binding$)/ }
+
+        def initialize(subject, ancestor)
+          @subject = subject
+          @ancestor = ancestor
+        end
+
+        def method_missing(sym, *args, &blk)
+          @ancestor.instance_method(sym).bind(@subject).call(*args,&blk)
+        end
+      end
+    end
+  end
+end

data/lib/progress_bar/components/progressable.rb

@@ -0,0 +1,92 @@
+class ProgressBar
+  module Components
+    module Progressable
+      DEFAULT_TOTAL              = 100
+      DEFAULT_BEGINNING_POSITION = 0
+      DEFAULT_SMOOTHING          = 0.1
+
+      attr_reader               :total
+      attr_reader               :progress
+      attr_accessor             :starting_position
+      attr_accessor             :running_average
+      attr_accessor             :smoothing
+
+      def initialize(options = {})
+        self.total           = options[: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] || self.progress
+      end
+
+      def started?
+        !!self.starting_position
+      end
+
+      def increment
+        self.progress += 1 unless progress == total
+      end
+
+      def decrement
+        self.progress -= 1 unless progress == 0
+      end
+
+      def reset
+        start :at => self.starting_position
+      end
+
+      def progress=(new_progress)
+        validate_progress(new_progress)
+
+        @progress = new_progress
+
+        update_running_average
+      end
+
+      def total=(new_total)
+        validate_total(new_total)
+        @total = new_total
+      end
+
+      def finish
+        self.progress = self.total
+      end
+
+      def percentage_completed
+        # progress / total * 100
+        #
+        # Doing this way so we can avoid converting each
+        # number to a float and then back to an integer.
+        #
+        self.progress * 100 / total
+      end
+
+      def percentage_completed_with_precision
+        format('%5.2f', (progress.to_f * 100.0 / total * 100.0).floor / 100.0)
+      end
+
+    private
+      def validate_total(new_total)
+        (progress.nil? || new_total >= progress) || raise("You can't set the item's total value to be less than the current progress.")
+      end
+
+      def validate_progress(new_progress)
+        (total.nil? || new_progress <= total) || raise("You can't set the item's current value to be greater than the total.")
+      end
+
+      def progress_made
+        started? ? self.progress - self.starting_position : 0
+      end
+
+      def update_running_average
+        self.running_average = RunningAverageCalculator.calculate(self.running_average, self.progress, self.smoothing)
+      end
+    end
+  end
+end

data/lib/progress_bar/components/timer.rb

@@ -0,0 +1,64 @@
+require 'progress_bar/time'
+
+class ProgressBar
+  module Components
+    module Timer
+      TIME_FORMAT = '%02d:%02d:%02d'
+
+      def start
+        @started_at = stopped? ? now - (@stopped_at - @started_at) : now
+        @stopped_at = nil
+      end
+
+      def stop
+        @stopped_at = now
+      end
+
+      def pause
+        stop
+      end
+
+      def resume
+        start
+      end
+
+      def started?
+        !!@started_at
+      end
+
+      def stopped?
+        !!@stopped_at
+      end
+
+      def reset
+        @started_at = nil
+        @stopped_at = nil
+      end
+
+    private
+      def now
+        ProgressBar::Time.now
+      end
+
+      def elapsed_seconds
+        ((@stopped_at || now) - @started_at).floor
+      end
+
+      def elapsed_time
+        return '--:--:--' unless started?
+
+        hours, seconds = elapsed_seconds.divmod(3600)
+        minutes, seconds = seconds.divmod(60)
+
+        sprintf TIME_FORMAT, hours, minutes, seconds
+      end
+
+      def divide_seconds(seconds)
+        hours, seconds = seconds.divmod(3600)
+        minutes, seconds = seconds.divmod(60)
+
+        [hours, minutes, seconds]
+      end
+    end
+  end
+end

data/lib/progress_bar/depreciable.rb

@@ -0,0 +1,121 @@
+class ProgressBar
+  module Depreciable
+    DEPRECATION_DATE = "June 30th, 2013"
+
+    def backwards_compatible_args_to_options_conversion(args)
+      options = {}
+
+      if args.size > 1
+        puts "DEPRECATION WARNING: Creating progress bars using ProgressBar.new(title, total, output_io) has been deprecated and will be removed on or after #{DEPRECATION_DATE}.  Please use ProgressBar.create(:title => title, :total => total, :output => output_io) instead. The full list of options can be found here: https://github.com/jfelchner/ruby-progressbar."
+        options[:title]  = args[0]
+        options[:total]  = args[1]
+        options[:output] = args[2]
+      else
+        options = args[0]
+      end
+
+      options
+    end
+
+    def inc(value = nil)
+      if value.nil?
+        method_deprecation_message 'inc', 'increment'
+
+        increment
+      else
+        method_removal_message 'inc', 'Rather than passing a step increment to the new #increment method, you can simply do `my_progress_bar.progress += step`.'
+
+        progress = progress + value.to_i
+      end
+    end
+
+    def set(new_value)
+      method_deprecation_message 'set', 'progress='
+
+      progress = new_value
+    end
+
+    def halt
+      method_deprecation_message 'halt', 'stop'
+
+      stop
+    end
+
+    def bar_mark=(mark)
+      method_deprecation_message 'bar_mark=', 'progress_mark='
+
+      progress_mark = mark
+    end
+
+    def title_width
+      method_removal_message 'title_width', 'The formatter is now smart enough to handle any title you use.  Set the format for the bar as described here: https://github.com/jfelchner/ruby-progressbar'
+    end
+
+    def title_width=(value)
+      method_removal_message 'title_width=', 'The formatter is now smart enough to handle any title you use.  Set the format for the bar as described here: https://github.com/jfelchner/ruby-progressbar'
+    end
+
+    def start_time
+      method_deprecation_message 'start_time'
+
+      @elapsed_time.instance_variable_get(:@started_at)
+    end
+
+    def start_time=(value)
+      method_removal_message 'start_time=', 'It is no longer appropriate to set the start time of the bar. Using #start, #stop, #pause and #resume all work as expected.'
+    end
+
+    def format=(value)
+      method_removal_message 'format=', 'The formatter has been completely rewriten for v1.0.  Please use `#format(format_string)`.  See https://github.com/jfelchner/ruby-progressbar for all the formatting options.'
+    end
+
+    def format_arguments=(value)
+      method_removal_message 'format_arguments=', 'The formatter has been completely rewriten for v1.0.  Please use `#format(format_string)`.  See https://github.com/jfelchner/ruby-progressbar for all the formatting options.'
+    end
+
+    def current
+      method_deprecation_message 'current', 'progress'
+
+      @bar.progress
+    end
+
+    def smoothing
+      method_removal_message 'smoothing'
+    end
+
+    def smoothing=(value)
+      method_removal_message 'smoothing=', 'This value can only be set via the options hash when creating a new progress bar like so: ProgressBar.create(:smoothing => 0.2)'
+    end
+
+    def file_transfer_mode
+      method_removal_message 'file_transfer_mode', 'We will be implementing a much better file transfer progress bar in the upcoming version however it has been removed for v1.0.  If you still require this functionality, you should remain at v0.11.0'
+    end
+
+  private
+
+    def method_deprecation_message(old_item, new_item = '')
+      message_has_not_been_shown?(old_item) do
+        replacement_message = new_item.empty? ? 'There will be no replacement.' : "Please use ##{new_item} instead."
+        puts "DEPRECATION WARNING: ##{old_item} will be removed on or after #{DEPRECATION_DATE}. #{replacement_message}"
+      end
+    end
+
+    def method_removal_message(old_item, message = '')
+      message_has_not_been_shown?(old_item) do
+        puts "REMOVAL WARNING: ##{old_item} has been removed. There is no replacement. #{message}"
+      end
+    end
+
+    def safe_string(item)
+      item.gsub('=', '_setter')
+    end
+
+    def message_has_not_been_shown?(item)
+      unless instance_variable_get(:"@#{safe_string item}_deprecation_warning")
+        instance_variable_set(:"@#{safe_string item}_deprecation_warning", true)
+
+        yield
+      end
+    end
+  end
+end

data/lib/progress_bar/format.rb

@@ -0,0 +1,2 @@
+require 'progress_bar/format/molecule'
+require 'progress_bar/format/base'

data/lib/progress_bar/format/base.rb

@@ -0,0 +1,30 @@
+class ProgressBar
+  module Format
+    class Base
+      attr_reader :molecules
+
+      def initialize(format_string)
+        @molecules = parse(format_string)
+      end
+
+      def non_bar_molecules
+        molecules.select { |molecule| !molecule.bar_molecule? }
+      end
+
+      def bar_molecules
+        molecules.select { |molecule| molecule.bar_molecule? }
+      end
+
+    private
+      def parse(format_string)
+        molecules        = []
+
+        format_string.scan(/%[a-zA-Z]/) do |match|
+          molecules << Molecule.new(match[1])
+        end
+
+        molecules
+      end
+    end
+  end
+end