scout-gear 1.1.0

data/lib/scout/log/progress/report.rb

@@ -0,0 +1,240 @@
+require 'yaml'
+module Log
+  class ProgressBar
+    def print(io, str)
+      return if Log.no_bar
+      STDERR.print str
+      Log.logfile.puts str unless Log.logfile.nil?
+      Log::LAST.replace "progress"
+    end
+
+    attr_accessor :history, :mean_max, :max_history
+    def thr_msg
+      if @history.nil?
+        @history ||= [[0, @start], [@ticks, Time.now] ]
+      elsif @last_ticks != @ticks
+        @history << [@ticks, Time.now]
+        max_history ||= begin
+                          max_history = case 
+                                        when @ticks > 20
+                                          count = @ticks - @last_count
+                                          count = 1 if count == 0
+                                          if @max
+                                            times = @max / count
+                                            num = times / 20
+                                            num = 2 if num < 2
+                                          else
+                                            num = 10
+                                          end
+                                          count * num
+                                        else
+                                          20
+                                        end
+                          max_history = 30 if max_history > 30
+                          max_history
+                        end
+        @history.shift if @history.length > max_history
+      end
+
+      @last_ticks = @ticks
+
+      @mean_max ||= 0
+      if @history.length > 3
+
+        sticks, stime = @history.first
+        ssticks, sstime = @history[-3]
+        lticks, ltime = @history.last
+
+
+        mean = @mean = (lticks - sticks).to_f / (ltime - stime)
+        short_mean = (lticks - ssticks).to_f / (ltime - sstime)
+
+        @mean_max = mean if mean > @mean_max
+      end
+
+      if short_mean
+        thr = short_mean
+      else
+        thr = begin
+                (@ticks || 1) / (Time.now - @start) 
+              rescue
+                1
+              end
+      end
+
+      thr = 0.0000001 if thr == 0
+      
+      if mean.nil? or mean.to_i > 2
+        str = "#{ Log.color :blue, thr.to_i.to_s } per sec."
+        #str << " #{ Log.color :yellow, mean.to_i.to_s } avg. #{Log.color :yellow, @mean_max.to_i.to_s} max." if @mean_max > 0
+      else
+        if 1.0/thr < 1
+          str = "#{ Log.color :blue, (1.0/thr).round(2).to_s } secs each"
+        elsif 1.0/thr < 2
+          str = "#{ Log.color :blue, (1.0/thr).round(1).to_s } secs each"
+        else
+          str = "#{ Log.color :blue, (1/thr).ceil.to_s } secs each"
+        end
+        #str << " #{ Log.color :yellow, (1/mean).ceil.to_s } avg. #{Log.color :yellow, (1/@mean_max).ceil.to_s} min." if @mean_max > 0
+      end
+
+      str
+    end
+
+
+    def eta_msg
+      percent = self.percent
+      time = Time.now
+
+      indicator = ""
+      10.times{|i|
+        if i < percent / 10 then
+          indicator << Log.color(:yellow, ".")
+        else
+          indicator << " "
+        end
+      }
+
+      indicator << " #{Log.color(:blue, percent.to_s << "%")}"
+
+      used = time - @start
+      if @mean_max and @mean_max > 0 and @mean > 0
+        eta =  (@max - @ticks) / @mean
+      else
+        eta =  (@max - @ticks) / (@ticks/used)
+      end
+
+      used = Misc.format_seconds(used) 
+      eta = [eta/3600, eta/60 % 60, eta % 60].map{|t| "%02i" % t }.join(':')
+
+      #indicator << " #{Log.color :yellow, used} used #{Log.color :yellow, eta} left - #{Log.color :yellow, ticks.to_s} of #{Log.color :yellow, @max.to_s} #{bytes ? 'bytes' : 'items'}"
+      indicator << " #{Log.color :yellow, eta} => #{Log.color :yellow, used} - #{Log.color :yellow, ticks.to_s} of #{Log.color :yellow, @max.to_s} #{bytes ? 'bytes' : 'items'}"
+
+      indicator
+    end
+
+    def report_msg
+      str = Log.color(:magenta, "·")
+      if @ticks == 0
+        if @max
+          return str << " " << Log.color(:magenta, "waiting on #{@max} #{bytes ? 'bytes' : 'items'}") <<  Log.color(:magenta, " · " << desc)
+        else
+          return str << " " << Log.color(:magenta, "waiting - PID: #{Process.pid}") <<  Log.color(:magenta, " · " << desc)
+        end
+      end
+      str << " " << thr_msg
+      if max
+        str << Log.color(:blue, " -- ") << eta_msg
+      else
+        str << Log.color(:blue, " -- ") << ticks.to_s << " #{bytes ? 'bytes' : 'items'}"
+      end
+      str <<  Log.color(:magenta, " · " << desc)
+      str
+    end
+
+    def load(info)
+      info.each do |key, value| 
+        case key.to_sym
+        when :start 
+          @start = value
+        when :last_time 
+          @last_time = value
+        when :last_count 
+          @last_count = value
+        when :last_percent 
+          @last_percent = value
+        when :desc 
+          @desc = value
+        when :ticks 
+          @ticks = value
+        when :max 
+          @max = value
+        when :mean 
+          @mean = value
+        end
+      end
+    end
+
+    def save
+      info = {:start => @start, :last_time => @last_time, :last_count => @last_count, :last_percent => @last_percent, :desc => @desc, :ticks => @ticks, :max => @max, :mean => @mean}
+      info.delete_if{|k,v| v.nil?}
+      File.write(file, info.to_yaml)
+    end
+
+    def report(io = STDERR)
+      if Log::LAST != "progress"
+        bars = BARS
+        if Log::LAST == "new_bar"
+          Log::LAST.replace "progress"
+          bar = bars.sort_by{|b| b.depth }.first
+          print(io, Log.color(:magenta ,bar.report_msg) << "\n") 
+        else
+          length = Log::ProgressBar.cleanup_bars
+          print(io, Log.color(:magenta, "···Progress\n"))
+          bars.sort_by{|b| b.depth }.reverse.each do |bar|
+            if SILENCED.include? bar
+              print(io, Log.color(:magenta, "·\n")) 
+            else
+              print(io, Log.color(:magenta ,bar.report_msg) << "\n") 
+            end
+          end
+        end
+      else
+        bars = BARS
+      end
+      bars << self unless BARS.include? self
+
+      print(io, Log.up_lines(bars.length) << Log.color(:magenta, "···Progress\n") << Log.down_lines(bars.length+1)) if Log::ProgressBar.offset == 0
+      print(io, Log.up_lines(@depth) << report_msg << "\n" << Log.down_lines(@depth - 1)) 
+      @last_time = Time.now
+      @last_count = ticks
+      @last_percent = percent if max and max > 0
+      Log::LAST.replace "progress"
+      save if file
+    end
+
+    def done(io = STDERR)
+      done_msg = Log.color(:magenta, "· ") << Log.color(:green, "done")
+      if @start
+        ellapsed = (Time.now - @start).to_i
+      else
+        ellapsed = 0
+      end
+      ellapsed = [ellapsed/3600, ellapsed/60 % 60, ellapsed % 60].map{|t| "%02i" % t }.join(':')
+      done_msg << " " << Log.color(:blue, (@ticks).to_s) << " #{bytes ? 'bytes' : 'items'} in " << Log.color(:green, ellapsed)
+      @last_count = 0
+      @last_time = @start
+      done_msg << " - " << thr_msg 
+      done_msg << Log.color(:magenta, " · " << desc)
+      print(io, Log.up_lines(@depth) << done_msg << Log.down_lines(@depth)) 
+
+      FileUtils.rm file if file and File.exists?(file)
+
+      @callback.call self if @callback
+    end
+
+    def error(io = STDERR)
+      done_msg = Log.color(:magenta, "· ") << Log.color(:red, "error")
+      if @start
+        ellapsed = (Time.now - @start).to_i
+      else
+        ellapsed = 0
+      end
+      ellapsed = [ellapsed/3600, ellapsed/60 % 60, ellapsed % 60].map{|t| "%02i" % t }.join(':')
+      done_msg << " " << Log.color(:blue, (@ticks).to_s) << " in " << Log.color(:green, ellapsed)
+      @last_count = 0
+      @last_time = @start
+      done_msg << " - " << thr_msg
+      done_msg << Log.color(:magenta, " · " << desc)      
+      print(io, Log.up_lines(@depth) << done_msg << Log.down_lines(@depth)) 
+
+      File.rm file if file and File.exist?(file)
+
+      begin
+        @callback.call self
+      rescue
+        Log.debug "Callback failed for filed progress bar: #{$!.message}"
+      end if @callback
+    end
+  end
+end

data/lib/scout/log/progress/util.rb

@@ -0,0 +1,100 @@
+require_relative '../../exceptions'
+module Log
+  class ProgressBar
+    BAR_MUTEX = Mutex.new
+    BARS = []
+    REMOVE = []
+    SILENCED = []
+
+    def self.add_offset(value = 1)
+      value = 1 if TrueClass === value
+      @@offset = offset + value.to_i
+      @@offset = 0 if @@offset < 0
+      @@offset
+    end
+
+    def self.remove_offset(value = 1)
+      value = 1 if TrueClass === value
+      @@offset = offset - value.to_i
+      @@offset = 0 if @@offset < 0
+      @@offset
+    end
+
+
+    def self.offset
+      @@offset ||= 0
+      @@offset = 0 if @@offset < 0
+      @@offset
+    end
+
+    def self.new_bar(max, options = {})
+      cleanup_bars
+      BAR_MUTEX.synchronize do
+        Log::LAST.replace "new_bar" if Log::LAST == "progress"
+        options = IndiferentHash.add_defaults options, :depth => BARS.length + Log::ProgressBar.offset
+        BARS << (bar = ProgressBar.new(max, options))
+        bar
+      end
+    end
+
+    def self.cleanup_bars
+      BAR_MUTEX.synchronize do
+        REMOVE.each do |bar|
+          index = BARS.index bar
+          if index
+            BARS.delete_at index
+            BARS.each_with_index do |bar,i|
+              bar.depth = i
+            end
+          end
+          index = SILENCED.index bar
+          if index
+            SILENCED.delete_at index
+            SILENCED.each_with_index do |bar,i|
+              bar.depth = i
+            end
+          end
+        end
+        REMOVE.clear
+        BARS.length
+      end
+    end
+
+    def self.remove_bar(bar, error = false)
+      BAR_MUTEX.synchronize do
+        return if REMOVE.include? bar
+      end
+      if error
+        bar.error if bar.respond_to? :error
+      else
+        bar.done if bar.respond_to? :done
+      end
+      BAR_MUTEX.synchronize do
+        REMOVE << bar
+      end
+      Log::LAST.replace "remove_bar" if Log::LAST == "progress"
+    end
+
+    def remove(error = false)
+      Log::ProgressBar.remove_bar self, error
+    end
+
+    def self.with_bar(max, options = {})
+      bar = new_bar(max, options)
+      res = nil
+      begin
+        error = false
+        keep = false
+        yield bar
+      rescue KeepBar
+        keep = true
+      rescue
+        error = true
+        raise $!
+      ensure
+        remove_bar(bar, error) if bar
+      end
+    end
+  end
+end
+

data/lib/scout/log/progress.rb

@@ -0,0 +1,102 @@
+require_relative 'progress/util'
+require_relative 'progress/report'
+module Log
+
+  def self.no_bar=(value)
+    @@no_bar = value
+  end
+
+  def self.no_bar
+    @@no_bar = false unless defined?(@@no_bar)
+    @@no_bar || ENV["RBBT_NO_PROGRESS"] == "true"
+  end
+
+  class ProgressBar
+
+    class << self
+      attr_accessor :default_file
+    end
+
+    attr_accessor :max, :ticks, :frequency, :depth, :desc, :file, :bytes, :process, :callback
+
+    def initialize(max = nil, options = {})
+      depth, num_reports, desc, io, severity, file, bytes, frequency, process, callback = 
+        IndiferentHash.process_options options, :depth, :num_reports, :desc, :io, :severity, :file, :bytes, :frequency, :process, :callback,
+        :depth => 0, :num_reports => 100, :io => STDERR, :severity => Log.severity, :frequency => 2
+
+      @max = max
+      @ticks = 0
+      @frequency = frequency
+      @last_time = nil
+      @last_count = nil
+      @last_percent = nil
+      @depth = depth
+      @desc = desc.nil? ? "" : desc.gsub(/\n/,' ')
+      @file = file
+      @bytes = bytes
+      @process = process
+      @callback = callback
+    end
+
+    def percent
+      return 0 if @ticks == 0
+      return 100 if @max == 0
+      (@ticks * 100) / @max
+    end
+
+    def file
+      @file || ProgressBar.default_file
+    end
+
+    def init
+      @ticks, @bytes = 0
+      @last_time = @last_count = @last_percent = nil
+      @history, @mean_max, @max_history = nil
+      @start = @last_time = Time.now
+      @last_count = 0
+      report
+    end
+
+    def tick(step = 1)
+      return if Log.no_bar
+      @ticks += step
+
+      time = Time.now
+      if @last_time.nil?
+        @last_time = time
+        @last_count = @ticks
+        @start = time
+        return
+      end
+
+      diff = time - @last_time
+      report and return if diff >= @frequency
+      return unless max and max > 0
+
+      percent = self.percent
+      if @last_percent.nil?
+        @last_percent = percent
+        return
+      end
+      report && return if percent > @last_percent and diff > 0.3
+    end
+
+    def pos(pos)
+      step = pos - (@ticks || 0)
+      tick(step)
+    end
+
+    def process(elem)
+      case res = @process.call(elem)
+      when FalseClass
+        nil
+      when TrueClass
+        tick
+      when Integer
+        pos(res)
+      when Float
+        pos(res * max)
+      end
+    end
+  end
+end