stella 0.5.3 → 0.5.4

data/vendor/hitimes-0.4.0/lib/hitimes/timer.rb

@@ -0,0 +1,223 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'hitimes'
+require 'hitimes_ext'
+
+module Hitimes
+  #
+  # A Timer combines together an Interval and a Stats object to provide
+  # aggregate information about timings.  
+  #
+  # A Timer has many of the same methods as an Interval and would be used in
+  # preference to an Interval in those situations where you want to track
+  # statistics about the item you are monitoring.
+  #
+  class Timer
+
+    # holds all the statistics
+    attr_reader :stats
+
+    class << self
+
+      # 
+      # :call-seq:
+      #   Timer.now -> Timer
+      #
+      # Return a newly allocated Timer that has already been started
+      #
+      def now
+        t = Timer.new
+        t.start
+        return t
+      end
+
+      # 
+      # :call-seq:
+      #   Timer.measure { ... } -> Float
+      #
+      # Return the number of seconds that a block of code took to
+      # execute.
+      #
+      def measure( &block )
+        Interval.measure { yield }
+      end
+    end
+
+    #
+    # :call-seq:
+    #   Timer.new -> Timer
+    #
+    def initialize
+      @stats = Stats.new
+      @current_interval = nil
+    end
+
+    #
+    # :call-seq:
+    #   timer.current_interval -> Interval
+    #
+    # Return the current interval, if one doesn't exist create one.
+    #
+    def current_interval
+      @current_interval ||= Interval.new
+    end
+
+    #
+    # :call-seq:
+    #   timer.running? -> true or false
+    #
+    # return whether or not the timer is currently running.  
+    #
+    def running?
+      current_interval.running?
+    end
+
+    # 
+    # :call-seq:
+    #   timer.start -> nil
+    #
+    # Start the current timer, if the current timer is already started, then
+    # this is a noop.  
+    #
+    def start
+      current_interval.start unless running?
+      nil
+    end
+
+    #
+    # :call-seq:
+    #   timer.stop -> Float or nil
+    #
+    # Stop the current timer.  This updates the stats and removes the current
+    # interval. If the timer is not running then this is a noop.  If the
+    # timer was stopped then the duration of the last Interval is returned.  If
+    # the timer was already stopped then false is returned.
+    # 
+    def stop
+      if running? then
+        d = current_interval.stop
+        @current_interval = nil
+        stats.update( d )
+        return d
+      end
+      return false
+    end
+
+    #
+    # :call-seq:
+    #   timer.measure {  ... } -> Float
+    #
+    # Measure the execution of a block and add those stats to the running stats.
+    #
+    def measure( &block )
+      t = 0.0
+      begin
+        start
+        yield
+      ensure
+        t = stop
+      end
+      return t
+    end
+
+    #
+    # :call-seq:
+    #   timer.split -> Flaot
+    #
+    # Split the current timer.  Essentially, mark a split time. This means
+    # stop the current interval and create a new interval, but make sure
+    # that the new interval lines up exactly, timewise, behind the previous
+    # interval.
+    #
+    # If the timer is running, then split returns the duration of the previous
+    # interval, i.e. the split-time.  If the timer is not running, nothing
+    # happens and false is returned.
+    #
+    def split  
+      if running? then 
+        next_interval = current_interval.split
+        d = current_interval.duration
+        stats.update( d )
+        @current_interval = next_interval 
+        return d
+      end 
+      return false
+    end
+
+    # 
+    # :call-seq:
+    #   timer.sum -> Float
+    #   timer.duration -> Float 
+    #
+    # The total time the timer has been measuring.  
+    #
+    def sum
+      stats.sum
+    end
+    alias duration sum
+
+    #
+    # :call-seq:
+    #   timer.mean -> Float
+    #
+    # The mean value of all the the stopped intervals.  The current interval, if
+    # it is still running, is not included.
+    #
+    def mean
+      stats.mean
+    end
+
+    #
+    # :call-seq:
+    #   timer.rate -> Float
+    #
+    # Return the rate of the states, which is the count / duration
+    #
+    def rate
+      stats.rate
+    end
+
+    #
+    # :call-seq:
+    #   timer.stddev -> Float
+    #
+    # The standard deviation of all the intervals
+    #
+    def stddev
+      stats.stddev
+    end
+
+    #
+    # :call-seq:
+    #   timer.count -> Integer
+    #
+    # The count of intervals in this timer
+    #
+    def count
+      stats.count
+    end
+
+    #
+    # :call-seq:
+    #   timer.max -> Float
+    #
+    # The maximum duration of all the intervals this Timer has seen
+    # 
+    def max
+      stats.max
+    end
+
+    #
+    # :call-seq:
+    #   timer.min -> Float
+    #
+    # The minimum duration of all the intervals this Timer has seen
+    #
+    def min
+      stats.min
+    end
+  end
+end

data/vendor/hitimes-0.4.0/lib/hitimes/version.rb

@@ -0,0 +1,42 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details
+#++
+
+module Hitimes
+  #
+  # module containing all the version information about Hitimes
+  #
+  module Version
+
+    MAJOR   = 0
+    MINOR   = 4
+    BUILD   = 0
+
+    # 
+    # :call-seq:
+    #   Version.to_a -> [ MAJOR, MINOR, BUILD ]
+    #
+    # Return the version as an array of Integers
+    #
+    def to_a 
+      [MAJOR, MINOR, BUILD]
+    end
+
+    #
+    # :call-seq:
+    #   Version.to_s -> MAJOR.MINOR.BUILD
+    #
+    # Return the version as a String with dotted notation
+    #
+    def to_s
+      to_a.join(".")
+    end
+
+    module_function :to_a
+    module_function :to_s
+
+    STRING = Version.to_s
+  end
+  VERSION = Version.to_s
+end

data/vendor/hitimes-0.4.0/lib/hitimes.rb

@@ -0,0 +1,24 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+#
+# The top level module containing the contents of the hitimes library
+#
+# use the library with:
+#
+#   require 'hitimes'
+#
+module Hitimes
+  #
+  # Base class of all errors in Hitimes
+  #
+  class Error < ::StandardError; end
+end
+require 'hitimes/paths'
+require 'hitimes/version'
+require 'hitimes/stats'
+require 'hitimes/mutexed_stats'
+require 'hitimes/timer'
+

data/vendor/hitimes-0.4.0/spec/interval_spec.rb

@@ -0,0 +1,115 @@
+require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
+
+require 'hitimes_ext'
+
+describe Hitimes::Interval do
+  it "has a 0 duration when newly created" do
+    i = Hitimes::Interval.new   
+    i.duration == 0.0
+  end
+
+  it "knows if it has been started" do
+    i = Hitimes::Interval.new
+    i.should_not be_started
+
+    i.start
+    i.should be_started
+  end
+
+  it "knows if it has been stopped" do
+    i = Hitimes::Interval.new
+    i.start
+    i.should_not be_stopped
+    i.stop
+    i.should be_stopped
+  end
+
+  it "knows if it is currently running" do
+    i = Hitimes::Interval.new
+    i.should_not be_running
+    i.start
+    i.should be_running
+    i.stop
+    i.should_not be_running
+  end
+
+  it "can time a block of code" do
+    d = Hitimes::Interval.measure do
+      sleep 0.2
+    end
+    d.should be_close(0.2, 0.01)
+  end
+
+  it "raises an error if measure is called with no block" do
+    lambda{ Hitimes::Interval.measure }.should raise_error( Hitimes::Error )
+  end
+
+  it "creates an interval via #now" do
+    i = Hitimes::Interval.now
+    i.should be_started
+    i.should_not be_stopped
+  end
+
+  it "calling duration multiple times returns successivly grater durations" do
+    i = Hitimes::Interval.new
+    i.start
+    y = i.duration
+    z = i.duration
+    z.should > y
+  end
+
+  it "calling start multiple times on has no effect after the first call" do
+    i = Hitimes::Interval.new
+    i.start.should == true
+    x = i.start_instant
+    i.start_instant.should > 0
+    i.start.should == false
+    x.should == i.start_instant
+  end
+
+  it "returns the duration on the first call to stop" do
+    i = Hitimes::Interval.now
+    d = i.stop
+    d.should be_instance_of( Float )
+  end
+
+  it "calling stop multiple times on has no effect after the first call" do
+    i = Hitimes::Interval.new
+    i.start.should == true
+    i.stop
+
+    x = i.stop_instant
+    i.stop_instant.should > 0
+    i.stop.should == false
+    x.should == i.stop_instant
+
+  end
+
+  it "only calculates duration once after stop is called" do
+    i = Hitimes::Interval.new
+    i.start
+    i.stop
+    x = i.duration
+    y = i.duration
+    x.object_id.should == y.object_id
+  end
+
+  describe "#split" do
+
+    it "creates a new Interval object" do
+      i = Hitimes::Interval.new
+      i.start
+      i2 = i.split
+      i.object_id.should_not == i2.object_id
+    end
+
+    it "with the stop instant equivialent to the previous Interval's start instant" do
+      i = Hitimes::Interval.new
+      i.start
+      i2 = i.split
+      i.stop_instant.should == i2.start_instant
+    end
+  end
+
+end
+

data/vendor/hitimes-0.4.0/spec/mutex_stats_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
+
+require 'hitimes_ext'
+require 'hitimes/mutexed_stats'
+
+describe Hitimes::MutexedStats do
+  before( :each ) do
+    @threads = 5
+    @iters   = 10_000
+    @final_value = @threads * @iters
+  end
+
+  def run_with_scissors( stats, threads, iters )
+    spool = []
+    threads.times do |t|
+      spool << Thread.new { iters.times{ stats.update( 1 ) } }
+    end
+    spool.each { |t| t.join }
+    return stats
+  end
+
+  it "is unsafe normally" do
+    pending "not for MRI -- not interruptable in this C extension" do
+      stats = run_with_scissors( ::Hitimes::Stats.new, @threads, @iters )
+      stats.count.should_not == @final_value
+    end
+  end
+
+  it "has a threadsafe update" do
+    stats = run_with_scissors( ::Hitimes::MutexedStats.new, @threads, @iters )
+    stats.count.should == @final_value
+  end
+
+end

data/vendor/hitimes-0.4.0/spec/paths_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
+
+require 'hitimes/paths'
+
+describe Hitimes::Paths do
+  it "can access the root dir of the project" do
+    Hitimes::Paths.root_dir.should == File.expand_path( File.join( File.dirname( __FILE__ ), ".." ) ) + ::File::SEPARATOR
+  end
+
+  it "can access the lib path of the project" do
+    Hitimes::Paths.lib_path.should == File.expand_path( File.join( File.dirname( __FILE__ ), "..", "lib" ) ) + ::File::SEPARATOR
+  end
+                                                
+end

data/vendor/hitimes-0.4.0/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'spec'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","ext"))
+$: << File.expand_path(File.join(File.dirname(__FILE__),"..","lib"))
+

data/vendor/hitimes-0.4.0/spec/stats_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
+
+require 'hitimes_ext'
+
+describe Hitimes::Stats do
+  before( :each ) do
+    @stats = Hitimes::Stats.new
+    @full_stats = Hitimes::Stats.new
+    
+    [ 1, 2, 3].each { |i| @full_stats.update( i ) }
+  end
+
+  it "is initialized with 0 values" do
+    @stats.count.should == 0
+    @stats.min.should == 0.0
+    @stats.max.should == 0.0
+    @stats.sum.should == 0.0
+    @stats.rate.should == 0.0
+  end
+
+  it "calculates the mean correctly" do
+    @full_stats.mean.should == 2.0
+  end
+
+  it "calculates the rate correctly" do
+    @full_stats.rate.should == 0.5
+  end
+
+  it "tracks the maximum value" do
+    @full_stats.max.should == 3.0
+  end
+
+  it "tracks the minimum value" do
+    @full_stats.min.should == 1.0
+  end
+
+  it "tracks the count" do
+    @full_stats.count.should == 3
+  end
+  
+  it "tracks the sum" do
+    @full_stats.sum.should == 6.0
+  end
+
+  it "calculates the standard deviation" do
+    @full_stats.stddev.should == 1.0
+  end 
+
+  describe "#to_hash " do
+    it "converts to a Hash" do
+      h = @full_stats.to_hash
+      h.size.should == ::Hitimes::Stats::STATS.size
+      h.keys.sort.should == ::Hitimes::Stats::STATS
+    end
+
+    it "converts to a limited Hash if given arguments" do
+      h = @full_stats.to_hash( "min", "max", "mean" )
+      h.size.should == 3
+      h.keys.sort.should == %w[ max mean min  ]
+
+      h = @full_stats.to_hash( %w[ count rate ] )
+      h.size.should == 2
+      h.keys.sort.should == %w[ count rate ]
+    end
+
+    it "raises NoMethodError if an invalid stat is used" do
+      lambda { @full_stats.to_hash( "wibble" ) }.should raise_error( NoMethodError )
+    end
+
+  end
+
+end

data/vendor/hitimes-0.4.0/spec/timer_spec.rb

@@ -0,0 +1,105 @@
+require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
+
+require 'hitimes/timer'
+
+describe Hitimes::Timer do
+
+  it "knows if it is running or not" do
+    t = Hitimes::Timer.new
+    t.should_not be_running
+    t.start
+    t.should be_running
+    t.stop
+    t.should_not be_running
+  end
+
+  it "#split returns the last duration and the timer is still running" do
+    t = Hitimes::Timer.now
+    d = t.split
+    t.should be_running
+    d.should > 0
+    t.count.should == 1
+    t.duration.should == d
+  end
+
+  it "#stop returns false if called more than once in a row" do
+    t = Hitimes::Timer.new
+    t.start
+    t.stop.should > 0
+    t.stop.should == false
+  end
+
+  it "does not count a currently running interval as an interval in calculations" do
+    t = Hitimes::Timer.new
+    t.start
+    t.count.should == 0
+    t.split
+    t.count.should == 1
+  end
+
+  it "#split called on a stopped timer does nothing" do
+    t = Hitimes::Timer.new
+    t.start
+    t.stop
+    t.split.should == false
+  end
+
+  it "calculates the mean of the durations" do
+    t = Hitimes::Timer.new
+    2.times { t.start ; sleep 0.05 ; t.stop }
+    t.mean.should > 0.04
+  end
+
+  it "calculates the rate of the counts " do
+    t = Hitimes::Timer.new
+    5.times { t.start ; sleep 0.05 ; t.stop }
+    t.rate.should > 19.0
+  end
+
+
+  it "calculates the stddev of the durations" do
+    t = Hitimes::Timer.new
+    2.times { t.start ; sleep 0.05 ; t.stop }
+    t.stddev.should > 0.0
+  end
+
+  it "returns 0.0 for stddev if there is no data" do
+    t = Hitimes::Timer.new
+    t.stddev.should == 0.0
+  end
+
+  it "retuns 0.0 for mean if there is no data" do
+    Hitimes::Timer.new.mean.should == 0.0
+  end
+
+  it "keeps track of the min value" do
+    t = Hitimes::Timer.new
+    2.times { t.start ; sleep 0.05 ; t.stop }
+    t.min.should > 0
+  end
+
+  it "keeps track of the max value" do
+    t = Hitimes::Timer.new
+    2.times { t.start ; sleep 0.05 ; t.stop }
+    t.max.should > 0
+  end
+
+  it "can create an already running timer" do
+    t = Hitimes::Timer.now
+    t.should be_running
+  end
+
+  it "can measure a block of code's execution time" do
+    dur = Hitimes::Timer.measure { sleep 0.05 }
+    dur.should > 0.025
+  end
+
+  it "can measuer a block of code from an instance" do
+    t = Hitimes::Timer.new
+    3.times { t.measure { sleep 0.05 } }
+    t.duration.should > 0.14
+    t.count.should == 3
+  end
+
+end
+

data/vendor/hitimes-0.4.0/spec/version_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper" ) )
+
+describe "Hitimes::Version" do
+    it "should have a major numbers that is >= 0" do
+        Hitimes::Version::MAJOR.should >= 0
+    end 
+
+    it "should have a minor number that is >= 0" do
+        Hitimes::Version::MINOR.should >= 0
+    end 
+
+    it "should have a tiny number that is >= 0" do
+        Hitimes::Version::BUILD.should >= 0
+    end 
+
+    it "should have an array representation" do
+        Hitimes::Version.to_a.should have(3).items
+    end 
+
+    it "should have a string representation" do
+        Hitimes::Version.to_s.should match(/\d+\.\d+\.\d+/)
+    end 
+
+    it "should be accessable as a constant" do
+        Hitimes::VERSION.should match(/\d+\.\d+\.\d+/)
+    end 
+end

data/vendor/hitimes-0.4.0/tasks/announce.rake

@@ -0,0 +1,39 @@
+require 'tasks/config'
+#-------------------------------------------------------------------------------
+# announcement methods
+#-------------------------------------------------------------------------------
+
+proj_config = Configuration.for('project')
+namespace :announce do
+  desc "create email for ruby-talk"
+  task :email do
+    info = Utils.announcement
+
+    File.open("email.txt", "w") do |mail|
+      mail.puts "From: #{proj_config.author} <#{proj_config.email}>"
+      mail.puts "To: ruby-talk@ruby-lang.org"
+      mail.puts "Date: #{Time.now.rfc2822}"
+      mail.puts "Subject: [ANN] #{info[:subject]}"
+      mail.puts
+      mail.puts info[:title]
+      mail.puts 
+      mail.puts "  gem install #{Hitimes::GEM_SPEC.name}"
+      mail.puts
+      mail.puts info[:urls]
+      mail.puts 
+      mail.puts info[:description]
+      mail.puts 
+      mail.puts "{{ Release notes for Version #{Hitimes::VERSION} }}"
+      mail.puts 
+      mail.puts info[:release_notes]
+      mail.puts
+    end 
+    puts "Created the following as email.txt:"
+    puts "-" * 72
+    puts File.read("email.txt")
+    puts "-" * 72
+  end 
+
+  CLOBBER << "email.txt"
+end
+