progress-logger 1.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,24 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## RubyMine
+.idea
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Kornelis Sietsma
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,45 @@
+= progress-logger
+
+This is a very simple gem to make it easier to log the state of long slow processing jobs.
+I tend to do this sort of thing over and over and over:
+    count = 0
+    @collection.each do |record|
+      count += 1
+      if count % 1000000 == 0
+        puts "Processed #{count} rows"
+      end
+      # do stuff
+    end
+with variations for timed reporting, calculating processing rate, and so on.
+ProgressLogger really doesn't do much - it just tries to handle the interval checking, leaving what you do every
+million records (or whatever) entirely up to you.  The example above can be run as:
+
+    p = ProgressLogger.new(:count => 1000000) do |state|
+      puts "Processed #{state.count} rows"
+    end
+    @collection.each do |record|
+      p.trigger
+      # do stuff
+    end
+
+You can do lots of other stuff too - see the ProgressLogger rdocs for more, but an example to whet your appetite:
+    p = ProgressLogger.new(:count => 1000000, :minutes => 30, :max => @collection.size) do |state|
+      @logger.info("Processed #{state.count} rows - #{state.long_eta/(60*60)} hours to go!")
+      @cache.flush()
+    end
+
+More examples are in the ProgressLogger docs - or take a look at the specs!
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Kornelis Sietsma. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "progress-logger"
+    gem.summary = %Q{Simple gem for regular progress logging in a long-running loop}
+    gem.description = %Q{Simple gem for regular progress logging in a long-running loop, log every N actions, or based on a time interval}
+    gem.email = "korny@sietsma.com"
+    gem.homepage = "http://github.com/kornysietsma/progress-logger"
+    gem.authors = ["Kornelis Sietsma"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "delorean", ">= 0.2.0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "progress-logger #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/progress-logger.rb

@@ -0,0 +1,210 @@
+# ProgressLogger is a simple tool for regular progress logging in a long-running loop
+#
+# Author:: Kornelis Sietsma (mailto: korny@sietsma.com)
+# Copyright:: Copyright (c) 2010 Kornelis Sietsma. See LICENSE for details.
+
+# The ProgressLogger class is the workhorse of this gem - it is used to wrap your logging code (or whatever you are doing)
+# you construct it with a set of criteria for when it should log, and a block to do the actual logging (or other activity):
+# <tt>
+#    p = ProgressLogger.new(:step => 100000) do |state|
+#       puts "processed #{state.count} rows"
+#    end
+# </tt>
+# and then every time "p.trigger()" is called:
+# * p.count is incremented
+# * if p.count is a multiple of 100000 the block is called, with a 'state' object as a parameter
+#
+# You can do pretty well anything you want in the passed block - log something, flush a database, update a gui, whatever.
+#
+# See the ProgressLogger::State class for what you can get from the state object
+#
+# == Examples
+#
+# ==== Log every 5 minutes:
+# <tt>
+#    p = ProgressLogger.new(:minutes => 5) do |state|
+#       puts "processed #{state.count} rows"
+#    end
+# </tt>
+#
+# ==== Log every hour, or after a million triggers, with a detailed message and some extra work
+# <tt>
+#    max = @collection.size
+#    p = ProgressLogger.new(:hours => 1, :step => 1000000, :max => max) do |state|
+#       @logger.info "processed #{state.count} rows"
+#       @logger.info "  Current processing rate of #{state.short_rate} rows/sec implies ending in #{state.short_eta/(3600)} hours"
+#       @logger.info "  Long-term processing rate of #{state.long_rate} rows/sec implies ending in #{state.long_eta/(3600)} hours"
+#       @logger.debug "flushing cache"
+#       @cache.flush
+#    end
+#    @collection.find().each do |row|
+#      p.trigger
+#      process(row)
+#    end
+#    @logger.info "done - processed #{p.count} rows in total"
+# </tt>
+#
+# ==== Passing the ProgressLogger around
+#
+# <tt>
+#    parent_count = 0
+#    plogger = ProgressLogger.new(:minutes => 5) do |state|
+#       puts "processed #{parent_count} parents, #{state.count} children"
+#    end
+#    @parents.each do |parent|
+#      parent_count += 1
+#      process_children(parent, plogger)
+#    end
+#  end
+#  def process_children(parent, plogger)
+#    parent.children.each do |child|
+#      plogger.trigger
+#      ... do stuff
+#    end
+#  end
+# </tt>
+
+class ProgressLogger
+
+  # Internal state passed to the ProgressLogger block whenever the criteria are met.
+  # count is the current count of triggers processed
+  # now is the Time.now value when this action was triggered (useful if you are handling state slowly)
+  class State
+    attr_reader :count, :now
+    # the number of triggers processed since the last action
+    def count_delta
+      @count - @last_count
+    end
+    # the amount of time passed since the first trigger (or since ProgressLogger.start was called)
+    def time_total
+      @now - @start_time
+    end
+    # the amount of time passed since the last action
+    def time_delta
+      @now - @last_report
+    end
+    # the processing rate, in triggers-per-second, using the count since the last action for a short-term speed
+    # * will return nil if this is called on the very first call to trigger, as no time will have elapsed!
+    def short_rate
+      return nil if @now == @last_report
+      (@count - @last_count) / (1.0 * (@now - @last_report))
+    end
+    # the processing rate, in triggers-per-second, using the count since the first action for a long-term speed
+    # * will return nil if this is called on the very first call to trigger, as no time will have elapsed!
+    def long_rate
+      return nil if @now == @start_time
+      (@count - @start_count) / (1.0 * (@now - @start_time))
+    end
+    # the estimated time to complete, based on the short-term speed (short_rate)
+    # * raises ArgumentError if you don't have a :max parameter in the main ProgressLogger constructor
+    # * will return nil if this is called on the very first call to trigger, as no time will have elapsed!
+    def short_eta
+      raise ArgumentError.new("Can't calculate ETA when no max specified") if @max.nil?
+      rate = short_rate
+      return nil if rate.nil?
+      return (@max - @count) / rate
+    end
+    # the estimated time to complete, based on the long-term speed (long_rate)
+    # * raises ArgumentError if you don't have a :max parameter in the main ProgressLogger constructor
+    # * will return nil if this is called on the very first call to trigger, as no time will have elapsed!
+    def long_eta
+      raise ArgumentError.new("Can't calculate ETA when no max specified") if @max.nil?
+      rate = long_rate
+      return nil if rate.nil?
+      return (@max - @count) / rate
+    end
+    private
+    def initialize(count, start_count, now, start_time, last_report, last_count, max = nil) #:notnew:
+      @count = count
+      @start_count = start_count
+      @now = now
+      @start_time = start_time
+      @last_report = last_report
+      @last_count = last_count
+      @max = max
+    end
+  end
+  # count of triggers processed so far
+  attr_reader :count
+
+  # create a ProgressLogger with specified criteria
+  # you *must* specify either a :step or one of :seconds, :minutes, and/or :hours
+  # parameters:
+  # * :step - the passed block is called after this many calls to trigger()
+  # * :seconds, :minutes, :hours - the passed block is called after this number of seconds/minutes/hours
+  # * * you can specify more than one of these, they'll just get added together
+  # * :max - this is an expected maximum number of triggers - it's used to calculate eta values for the ProgressLogger::State object
+  # * block - you must pass a block, it is called (with a state parameter) when the above criteria are met
+
+  def initialize(params = {}, &block)
+    unless params[:step] || params[:seconds] || params[:minutes] || params[:hours]
+      raise ArgumentError.new("You must specify a :step, :seconds, :minutes or :hours interval criterion to ProgressLogger")
+    end
+    unless block_given?
+      raise ArgumentError.new("You must pass a block to ProgressLogger")
+    end
+    @stepsize = params[:step]
+    raise ArgumentError.new("Step size must be greater than 0") if @stepsize && @stepsize <= 0
+    @max = params[:max]
+    raise ArgumentError.new("Max count must be greater than 0") if @max && @max <= 0
+
+    @count_based = params[:step]
+    @time_based = params[:seconds] || params[:minutes] || params[:hours]
+    if @time_based
+      @seconds = params[:seconds] || 0
+      @seconds += params[:minutes] * 60 if params[:minutes]
+      @seconds += params[:hours] * 60 * 60 if params[:hours]
+      raise ArgumentError.new("You must specify a total time greater than 0") if @seconds <= 0
+    end
+
+    @count = 0
+    @block = block
+    @started = false  # don't start yet - allow for startup time in loops; can start manually with start() below
+  end
+
+  # manually start timers
+  # normally timers are initialized on the first call to trigger() - this is because quite often, a processing loop
+  # like the following has a big startup time as cursors are allocated etc:
+  # <tt>
+  #   p = ProgressLogger.new ...
+  #   @db.find({:widget => true).each do  # this takes 5 minutes to cache cursors!
+  #     p.trigger
+  # </tt>
+  # If the timers were initialized when ProgressLogger.new was called, they'd be messed up by the loop start time.
+  # If for some reason you want the timers to be manually started earlier, you can explicitly call start,
+  # optionally passing it your own special version of Time.now
+  def start(now = Time.now)
+    @started = true
+    @start_time = now
+    @last_report = now
+    @last_timecheck = now  # last time interval, so count-based reports don't stop time-based reports
+    @start_count = @last_count = @count
+  end
+
+  # trigger whatever regular event you are watching - if the criteria are met, this will call your block of code
+  def trigger
+    start unless @started  # note - will set start and last counts to 0, which may be slightly inaccurate!
+    @count += 1
+    now = Time.now
+    if @time_based
+      time_delta = now - @last_timecheck
+      its_time = (time_delta > @seconds)
+    else
+      its_time = false
+    end
+    its_enough = @count_based && (@count % @stepsize == 0)
+    if its_time || its_enough
+      run_block now
+      @last_report = now
+      @last_count = @count
+      @last_timecheck = now if its_time
+    end
+  end
+
+  private
+
+  def run_block(now)
+    @block.call(State.new(@count, @start_count, now, @start_time, @last_report, @last_count, @max))
+  end
+
+end

data/progress-logger.gemspec

@@ -0,0 +1,58 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{progress-logger}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Kornelis Sietsma"]
+  s.date = %q{2010-10-27}
+  s.description = %q{Simple gem for regular progress logging in a long-running loop, log every N actions, or based on a time interval}
+  s.email = %q{korny@sietsma.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/progress-logger.rb",
+     "progress-logger.gemspec",
+     "spec/progress-logger_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/kornysietsma/progress-logger}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Simple gem for regular progress logging in a long-running loop}
+  s.test_files = [
+    "spec/progress-logger_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_development_dependency(%q<delorean>, [">= 0.2.0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_dependency(%q<delorean>, [">= 0.2.0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    s.add_dependency(%q<delorean>, [">= 0.2.0"])
+  end
+end
+

data/spec/progress-logger_spec.rb

@@ -0,0 +1,270 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe ProgressLogger do
+  before :each do
+    @event_count = 0  # count used all over the place to check number of block calls made
+  end
+  context "when handling invalid parameters" do
+    it "should throw an exception if not passed any step criteria" do
+      lambda {
+        ProgressLogger.new
+      }.should raise_error ArgumentError
+    end
+    it "should throw an exception if not passed a block" do
+      lambda {
+        ProgressLogger.new(:step => 1)
+      }.should raise_error ArgumentError
+    end
+    it "should throw an exception if step size is zero or less" do
+      lambda {
+        ProgressLogger.new(:step => 0) {}
+      }.should raise_error ArgumentError
+      lambda {
+        ProgressLogger.new(:step => -1) {}
+      }.should raise_error ArgumentError
+    end
+    it "should throw an exception if step time is zero or less" do
+      lambda {
+        ProgressLogger.new(:seconds => 0) {}
+      }.should raise_error ArgumentError
+      lambda {
+        ProgressLogger.new(:minutes => 0) {}
+      }.should raise_error ArgumentError
+      lambda {
+        ProgressLogger.new(:hours => 0) {}
+      }.should raise_error ArgumentError
+    end
+    it "should throw an exception if total step time is negative" do
+      ProgressLogger.new(:seconds => 61, :minutes => -1) {}  # weird, but ok
+      lambda {
+        ProgressLogger.new(:seconds => 60, :minutes => -1) {}
+      }.should raise_error ArgumentError
+    end
+    it "should throw an exception if max count is zero or less" do
+      lambda {
+        ProgressLogger.new(:step => 1, :max => 0) {}
+      }.should raise_error ArgumentError
+      lambda {
+        ProgressLogger.new(:step => 1, :max => -1) {}
+      }.should raise_error ArgumentError
+    end
+    it "should not allow calculating an ETA without a max count specified" do
+      p = ProgressLogger.new(:step => 1) do |state|
+        puts state.short_eta
+      end
+      lambda {
+        p.trigger
+      }.should raise_error ArgumentError
+      p2 = ProgressLogger.new(:step => 1) do |state|
+        puts state.long_eta
+      end
+      lambda {
+        p2.trigger
+      }.should raise_error ArgumentError
+
+    end
+  end
+
+  context "with numeric step size" do
+    it "should call the passed block every time when called with size of one" do
+      p = ProgressLogger.new(:step => 1) do
+        @event_count += 1
+      end
+      p.trigger
+      @event_count.should == 1
+      p.trigger
+      @event_count.should == 2
+    end
+    it "should call the passed block every second times shen called with a size of 2" do
+      p = ProgressLogger.new(:step => 2) do
+        @event_count += 1
+      end
+      p.trigger
+      @event_count.should == 0
+      p.trigger
+      @event_count.should == 1
+      p.trigger
+      @event_count.should == 1
+      p.trigger
+      @event_count.should == 2
+    end
+    it "should let you find the loop count at any time, even when not triggered" do
+      p = ProgressLogger.new(:step => 10000) do
+        @event_count += 1
+      end
+      p.count.should == 0
+      p.trigger
+      @event_count.should == 0  # no trigger yet
+      p.count.should == 1
+    end
+  end
+  context "with time-based step size" do
+    it "should trigger the body once after the specified number of seconds" do
+      p = ProgressLogger.new(:seconds => 10) do
+        @event_count += 1
+      end
+      p.trigger
+      @event_count.should == 0
+      Delorean.jump 10
+      p.trigger
+      @event_count.should == 1
+    end
+    it "should start time counting from the first trigger unless start has been called" do
+      p = ProgressLogger.new(:seconds => 10) do
+        @event_count += 1
+      end
+      Delorean.jump 10
+      p.trigger
+      @event_count.should == 0
+      Delorean.jump 10
+      p.trigger
+      @event_count.should == 1
+    end
+    it "should start counting interval when start is called manually" do
+      p = ProgressLogger.new(:seconds => 10) do
+        @event_count += 1
+      end
+      p.start
+      Delorean.jump 10
+      p.trigger
+      @event_count.should == 1
+    end
+    it "should trigger the body only once even if multiple time intervals have passed" do
+      p = ProgressLogger.new(:seconds => 10) do
+        @event_count += 1
+      end
+      p.trigger
+      Delorean.jump 1000
+      p.trigger
+      @event_count.should == 1
+    end
+    it "should trigger based on interval since last trigger, not total elapsed time (as it's easier)" do
+      p = ProgressLogger.new(:seconds => 10) do
+        @event_count += 1
+      end
+      p.trigger
+      Delorean.jump 1000
+      p.trigger
+      @event_count.should == 1
+      Delorean.jump 10
+      p.trigger
+      @event_count.should == 2
+    end
+    after :each do
+      Delorean.back_to_the_present
+    end
+  end
+  context "with both time and steps" do
+    it "should not let count based intervals interfere with time based" do
+      p = ProgressLogger.new(:step => 2, :seconds => 10) do
+        @event_count += 1
+      end
+      p.trigger
+      Delorean.jump 5
+      p.trigger  # fires an event due to step
+      Delorean.jump 5
+      p.trigger  # should fire an event due to time, even though it's only 5 seconds since last event
+      @event_count.should == 2
+    end
+    it "should not fire two events if step and time events coincide" do
+      p = ProgressLogger.new(:step => 1, :seconds => 10) do
+        @event_count += 1
+      end
+      p.trigger
+      @event_count.should == 1
+      Delorean.jump 10
+      p.trigger  # fires an event due to both criteria
+      @event_count.should == 2
+    end
+  end
+  context "passing context to the included block" do
+    before :each do
+      @states = []
+      @p = ProgressLogger.new(:step => 10) do |state|
+        @states << state
+      end
+    end
+    it "should include the count of triggers called" do
+      20.times {@p.trigger}
+      @states.size.should == 2
+      @states.collect {|s| s.count}.should == [10,20]
+    end
+    it "should include the count change since the last trigger" do
+      20.times {@p.trigger}
+      @states.size.should == 2
+      @states.collect {|s| s.count_delta}.should == [10,10]
+    end
+    it "should include the time since the start time" do
+      @p.start  # set initial time
+      20.times do
+        Delorean.jump 1
+        @p.trigger
+      end
+      @states.size.should == 2
+      @states[0].time_total.should be_close(10, 0.1)
+      @states[1].time_total.should be_close(20, 0.1)
+    end
+    it "should include the time since the first trigger if no start specified" do
+      20.times do
+        Delorean.jump 1
+        @p.trigger
+      end
+      @states.size.should == 2
+      @states[0].time_total.should be_close(9, 0.1)
+      @states[1].time_total.should be_close(19, 0.1)
+    end
+    it "should include the delta time since the previous trigger" do
+      @p.start  # set initial time
+      20.times do
+        Delorean.jump 1
+        @p.trigger
+      end
+      @states.size.should == 2
+      @states[0].time_delta.should be_close(10, 0.1)
+      @states[1].time_delta.should be_close(10, 0.1)
+    end
+  end
+  context "when dealing with rates and ETAs" do
+    before :each do
+      @states = []
+      @p = ProgressLogger.new(:step => 10, :max => 100) do |state|
+        @states << state
+      end
+      # we can reuse the same scenario for all our tests:
+      @p.trigger  # the first trigger is quick, but
+      Delorean.jump 100 # the first interval is a big one - slow startup speed!
+      19.times do
+        Delorean.jump 1
+        @p.trigger
+      end
+    end
+    it "should include the processing rate based on overall processing" do
+      @states.size.should == 2
+      # after 10 triggers we've taken 109 seconds - pretty slow
+      @states[0].long_rate.should be_close((10.0/109), 0.001)
+      # after 20 triggers it's picked up, but not a lot:
+      @states[1].long_rate.should be_close((20.0/119), 0.001)
+    end
+    it "should include the processing rate based on single-step processing" do
+      @states.size.should == 2
+      # after 10 triggers we've taken 109 seconds - pretty slow
+      @states[0].short_rate.should be_close((10.0/109), 0.001)
+      # after 20 triggers we can ignore the slow start time = now chugging along at 1 per second
+      @states[1].short_rate.should be_close(1, 0.01)
+    end
+    it "should calculate an ETA based on overall processing" do
+      @states.size.should == 2
+      # after 10 triggers we've taken 109 seconds - pretty slow - should take us 1090 seconds for the lot
+      @states[0].long_eta.should be_close(1090 - 109, 0.1)
+      # after 20 triggers it's picked up, we've taken 119 seconds - should take us (119/20)*80 seconds to finish
+      @states[1].long_eta.should be_close((119.0/20)*80, 0.1)
+    end
+    it "should calculate an ETA based on single-step processing" do
+      @states.size.should == 2
+      # after 10 triggers we've taken 109 seconds - same as the long-term situation - should take us 1090 seconds for the lot
+      @states[0].short_eta.should be_close(1090 - 109, 0.1)
+      # after 20 triggers it's picked up, we're now averaging 1 per second - should take us 80 seconds to finish
+      @states[1].short_eta.should be_close(80, 0.1)
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'progress-logger'
+require 'spec'
+require 'spec/autorun'
+require 'delorean'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: progress-logger
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Kornelis Sietsma
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-27 00:00:00 +11:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: delorean
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :development
+  version_requirements: *id002
+description: Simple gem for regular progress logging in a long-running loop, log every N actions, or based on a time interval
+email: korny@sietsma.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/progress-logger.rb
+- progress-logger.gemspec
+- spec/progress-logger_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/kornysietsma/progress-logger
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple gem for regular progress logging in a long-running loop
+test_files: 
+- spec/progress-logger_spec.rb
+- spec/spec_helper.rb