stella 0.5.4 → 0.5.5

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

@@ -1,23 +0,0 @@
-require 'hitimes'
-require 'thread'
-
-module Hitimes
-  class MutexedStats < Stats
-    def initialize
-      @mutex = Mutex.new
-    end
-
-    # call-seq:
-    #   mutex_stat.update( val ) -> nil
-    # 
-    # Update the running stats with the new value in a threadsafe manner.
-    #
-    def update( value )
-      @mutex.synchronize do
-        super( value )
-      end
-    end
-  end
-end
-
-

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

@@ -1,54 +0,0 @@
-#--
-# Copyright (c) 2008 Jeremy Hinegardner
-# All rights reserved.  See LICENSE and/or COPYING for details.
-#++
-#
-module Hitimes
-  #
-  # Access to various paths inside the project programatically
-  #
-  module Paths
-    #   
-    # :call-seq:
-    #    Hitimes::Paths.root_dir -> String
-    #
-    # Returns The full expanded path of the parent directory of +lib+
-    # going up the path from the current file.  A trailing File::SEPARATOR 
-    # is guaranteed.
-    #   
-    def self.root_dir
-      unless @root_dir
-        path_parts = ::File.expand_path(__FILE__).split(::File::SEPARATOR)
-        lib_index  = path_parts.rindex("lib")
-        @root_dir = path_parts[0...lib_index].join(::File::SEPARATOR) + ::File::SEPARATOR
-      end 
-      return @root_dir
-    end 
-
-    # 
-    # :call-seq:
-    #   Hitimes::Paths.lib_path( *args ) -> String
-    #
-    # Returns The full expanded path of the +lib+ directory below
-    # _root_dir_.  All parameters passed in are joined onto the 
-    # result. A trailing File::SEPARATOR is guaranteed if 
-    # _args_ are *not* present.
-    #   
-    def self.lib_path(*args)
-      self.sub_path("lib", *args)
-    end 
-
-    #
-    # :call-seq:
-    #   Hitimes::Paths.sub_path( sub, *args ) -> String
-    #
-    # Returns the full expanded path of the +sub+ directory below _root_dir.  All
-    # _arg_ parameters passed in are joined onto the result.  A trailing
-    # File::SEPARATOR is guaranteed if _args_ are *not* present.
-    #
-    def self.sub_path(sub,*args)
-      sp = ::File.join(root_dir, sub) + File::SEPARATOR
-      sp = ::File.join(sp, *args) if args
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-module Hitimes
-  class Stats
-    # A list of the available stats
-    STATS = %w[ count max mean min rate stddev sum ]
-
-    # 
-    # call-seq:
-    #   stat.to_hash   -> Hash
-    #   stat.to_hash( %w[ count max mean ]) -> Hash
-    #
-    # return a hash of the stats.  By default this returns a hash of all stats
-    # but passing in an array of items will limit the stats returned to only
-    # those in the Array. 
-    #
-    # If passed in an empty array or nil to to_hash then STATS is assumed to be
-    # the list of stats to return in the hash.
-    #
-    def to_hash( *args )
-      h = {}
-      args = [ args ].flatten
-      args = STATS if args.empty?
-      args.each do |meth|
-        h[meth] = self.send( meth )
-      end
-      return h
-    end
-
-  end
-end

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

@@ -1,223 +0,0 @@
-#--
-# 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

@@ -1,42 +0,0 @@
-#--
-# 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

@@ -1,24 +0,0 @@
-#--
-# 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

@@ -1,115 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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