ruby-progressbar 1.6.1 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ab0a31d7bb98cd80041a9c7a30d02d06f5ff2c0
-  data.tar.gz: cc94aa0ec99f5638339360ac366cf11e9bbc6b77
+  metadata.gz: 65d4119d92f6886b3336cb4a1f4aae7c0f41db32
+  data.tar.gz: 61cbb19a13d99c622042ae32cfb5e132658d25ff
 SHA512:
-  metadata.gz: 4e2e0bbc3a033fcab712a3dc2b636018c3206e6bbd0ac5998d53a1719e195c3d8ee895dfb98c075b4f5fdd939cd862a26269cb0f01b3aa6b8f59cd1825a8eebc
-  data.tar.gz: cffef174c3686916351cf8482f61602574a0eaf566fcf5f8d4045ba1fad127181766006bd9c8fdf884a83a832f835257ba462e57670f2ecb3595e707801546f9
+  metadata.gz: 8080a8cc6c2565958dc51ebbead22286f2ba38ebd3c2ab83d61f658989dceea0bea077d3894333790251450b197c9b86494a5801a6bcfd2d4f05d1344fa0d29f
+  data.tar.gz: e48ece20505cc7406467d4c1e3aa1d4761003eb27886b5a6459f4769c67869a8e24cf77163ba20b7a11256c18fdd97bedd6551ae86a2fb2b411c62c3f2b27d99

data/Rakefile

@@ -1,2 +1,2 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'

data/lib/ruby-progressbar.rb

@@ -1,6 +1,11 @@
-require 'ruby-progressbar/length_calculator'
-require 'ruby-progressbar/running_average_calculator'
-require 'ruby-progressbar/formatter'
+require 'ruby-progressbar/output'
+require 'ruby-progressbar/outputs/tty'
+require 'ruby-progressbar/outputs/non_tty'
+require 'ruby-progressbar/timer'
+require 'ruby-progressbar/progress'
+require 'ruby-progressbar/throttle'
+require 'ruby-progressbar/calculators/length'
+require 'ruby-progressbar/calculators/running_average'
 require 'ruby-progressbar/components'
 require 'ruby-progressbar/format'
 require 'ruby-progressbar/base'

data/lib/ruby-progressbar/base.rb

@@ -1,217 +1,161 @@
-class ProgressBar
-  class Base
-    include ProgressBar::LengthCalculator
-    include ProgressBar::Formatter
+require 'forwardable'
 
-    DEFAULT_OUTPUT_STREAM = $stdout
+class   ProgressBar
+class   Base
+  extend Forwardable
 
-    def initialize(options = {})
-      self.output       = options[:output] || DEFAULT_OUTPUT_STREAM
-      autostart         = options.fetch(:autostart, true)
+  def_delegators :output,
+                 :clear,
+                 :log,
+                 :refresh
 
-      super(options)
+  def_delegators :progressable,
+                 :progress,
+                 :total
 
-      @bar              = Components::Bar.new(options)
-      @rate             = Components::Rate.new(options)
-      @estimated_time   = Components::EstimatedTimer.new(options)
-      @elapsed_time     = Components::ElapsedTimer.new
-      @throttle         = Components::Throttle.new(options)
+  # rubocop:disable Metrics/AbcSize
+  def initialize(options = {})
+    self.autostart    = options.fetch(:autostart,  true)
+    self.autofinish   = options.fetch(:autofinish, true)
+    self.finished     = false
 
-      start :at => options[:starting_at] if autostart
-    end
-
-    ###
-    # Starting The Bar
-    #
-    def start(options = {})
-      clear
-
-      with_update do
-        with_progressables(:start, options)
-        with_timers(:start)
-      end
-    end
-
-    ###
-    # Updating The Bar's Progress
-    #
-    def decrement
-      update_progress(:decrement)
-    end
-
-    def increment
-      update_progress(:increment)
-    end
+    self.timer        = Timer.new(options)
+    self.progressable = Progress.new(options)
 
-    def progress=(new_progress)
-      update_progress(:progress=, new_progress)
-    end
-
-    def total=(new_total)
-      update_progress(:total=, new_total)
-    end
-
-    ###
-    # Stopping The Bar
-    #
-    def finish
-      with_update { with_progressables(:finish); with_timers(:stop) } unless finished?
-    end
+    options           = options.merge(:timer    => timer,
+                                      :progress => progressable)
 
-    def pause
-      with_update { with_timers(:pause) } unless paused?
-    end
+    self.title_comp   = Components::Title.new(options)
+    self.bar          = Components::Bar.new(options)
+    self.percentage   = Components::Percentage.new(options)
+    self.rate         = Components::Rate.new(options)
+    self.time         = Components::Time.new(options)
 
-    def stop
-      with_update { with_timers(:stop) } unless stopped?
-    end
+    self.output       = Output.detect(options.merge(:bar => self))
+    @format           = Format::String.new(output.resolve_format(options[:format]))
 
-    def resume
-      with_update { with_timers(:resume) } if stopped?
-    end
-
-    def reset
-      with_update do
-        @bar.reset
-        with_timers(:reset)
-      end
-    end
+    start :at => options[:starting_at] if autostart
+  end
+  # rubocop:enable Metrics/AbcSize
 
-    def stopped?
-      (@estimated_time.stopped? && @elapsed_time.stopped?) || finished?
-    end
+  def start(options = {})
+    clear
 
-    alias :paused? :stopped?
+    timer.start
+    update_progress(:start, options)
+  end
 
-    def finished?
-      @estimated_time.finished? && @bar.finished?
-    end
+  def finish
+    output.with_refresh do
+      self.finished = true
+      progressable.finish
+      timer.stop
+    end unless finished?
+  end
 
-    def started?
-      @estimated_time.started? && @elapsed_time.started? && @bar.started?
-    end
+  def pause
+    output.with_refresh { timer.pause } unless paused?
+  end
 
-    ###
-    # UI Updates
-    #
-    def progress_mark=(mark)
-      with_update { @bar.progress_mark = mark }
-    end
+  def stop
+    output.with_refresh { timer.stop } unless stopped?
+  end
 
-    def remainder_mark=(mark)
-      with_update { @bar.remainder_mark = mark }
-    end
+  def resume
+    output.with_refresh { timer.resume } if stopped?
+  end
 
-    def title=(title)
-      if output.tty?
-        with_update { super }
-      end
+  def reset
+    output.with_refresh do
+      self.finished = false
+      progressable.reset
+      timer.reset
     end
+  end
 
-    ###
-    # Output
-    #
-    def clear
-      self.last_update_length = 0
-
-      if output.tty?
-        output.print clear_string
-        output.print "\r"
-      else
-        output.print "\n"
-      end
-    end
+  def stopped?
+    timer.stopped? || finished?
+  end
 
-    def refresh
-      update
-    end
+  alias_method :paused?, :stopped?
 
-    def log(string)
-      clear
-      output.puts string
+  def finished?
+    finished || (autofinish && progressable.finished?)
+  end
 
-      update(:force => true) unless stopped?
-    end
+  def started?
+    timer.started?
+  end
 
-    def to_s(format_string = nil)
-      format_string ||= @format_string
+  def decrement
+    update_progress(:decrement)
+  end
 
-      format(format_string)
-    end
+  def increment
+    update_progress(:increment)
+  end
 
-    def inspect
-      "#<ProgressBar:#{progress}/#{total || 'unknown'}>"
-    end
+  def progress=(new_progress)
+    update_progress(:progress=, new_progress)
+  end
 
-  protected
+  def total=(new_total)
+    update_progress(:total=, new_total)
+  end
 
-    attr_accessor :output,
-                  :last_update_length
+  def progress_mark=(mark)
+    output.refresh_with_format_change { bar.progress_mark = mark }
+  end
 
-  private
+  def remainder_mark=(mark)
+    output.refresh_with_format_change { bar.remainder_mark = mark }
+  end
 
-    def clear_string
-      "#{" " * length}"
-    end
+  def title
+    title_comp.title
+  end
 
-    def last_update_length
-      @last_update_length ||= 0
-    end
+  def title=(title)
+    output.refresh_with_format_change { title_comp.title = title }
+  end
 
-    def with_progressables(*args)
-      @bar.send(*args)
-      @estimated_time.send(*args)
-      @rate.send(*args)
-    end
+  def to_s(new_format = nil)
+    self.format = new_format if new_format
 
-    def with_timers(*args)
-      @estimated_time.send(*args)
-      @elapsed_time.send(*args)
-      @rate.send(*args)
-    end
+    Format::Formatter.process(@format, output.length, self)
+  end
 
-    def update_progress(*args)
-      with_update do
-        with_progressables(*args)
-        with_timers(:stop) if finished?
-      end
-    end
+  def inspect
+    "#<ProgressBar:#{progress}/#{total || 'unknown'}>"
+  end
 
-    def with_update
-      yield
-      update
+  def format=(other)
+    output.refresh_with_format_change do
+      @format = Format::String.new(other || output.default_format)
     end
+  end
 
-    def update(options = {})
-      if length_changed?
-        clear
-        reset_length
-      end
-
-      @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
+  alias_method :format, :format=
 
-        output.print output_string + eol
-        output.flush
-      end
-    end
+  protected
 
-    def eol
-      if output.tty?
-        stopped? ? "\n" : "\r"
-      else
-        stopped? ? "\n" : ""
-      end
+  attr_accessor :output,
+                :timer,
+                :progressable,
+                :title_comp,
+                :bar,
+                :percentage,
+                :rate,
+                :time,
+                :autostart,
+                :autofinish,
+                :finished
+
+  def update_progress(*args)
+    output.with_refresh do
+      progressable.send(*args)
+      timer.stop if finished?
     end
   end
 end
+end

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

@@ -0,0 +1,75 @@
+class   ProgressBar
+module  Calculators
+class   Length
+  attr_accessor :length_override,
+                :current_length
+
+  def initialize(options)
+    self.length_override = options[:length]
+    self.current_length  = nil
+  end
+
+  def length
+    current_length || reset_length
+  end
+
+  def length_changed?
+    previous_length     = current_length
+    self.current_length = calculate_length
+
+    previous_length != current_length
+  end
+
+  def calculate_length
+    length_override || terminal_width || 80
+  end
+
+  def reset_length
+    self.current_length = calculate_length
+  end
+
+  def length_override=(other)
+    @length_override ||= ENV['RUBY_PROGRESS_BAR_LENGTH'] || other
+    @length_override = @length_override.to_i if @length_override
+  end
+
+  private
+
+  # This code was copied and modified from Rake, available under MIT-LICENSE
+  # Copyright (c) 2003, 2004 Jim Weirich
+  def terminal_width
+    return 80 unless unix?
+
+    result = dynamic_width
+    (result < 20) ? 80 : result
+  rescue
+    80
+  end
+
+  begin
+    require 'io/console'
+
+    def dynamic_width
+      _rows, columns = IO.console.winsize
+      columns
+    end
+  rescue LoadError
+    def dynamic_width
+      dynamic_width_stty.nonzero? || dynamic_width_tput
+    end
+
+    def dynamic_width_stty
+      `stty size 2>/dev/null`.split[1].to_i
+    end
+
+    def dynamic_width_tput
+      `tput cols 2>/dev/null`.to_i
+    end
+  end
+
+  def unix?
+    RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
+  end
+end
+end
+end

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

@@ -0,0 +1,9 @@
+require 'rspectacular'
+require 'ruby-progressbar/calculators/length'
+
+class     ProgressBar
+module    Calculators
+describe  Length do
+end
+end
+end