hitimes 1.1.1-x86-mingw32 → 1.2.2-x86-mingw32

data/ext/hitimes/java/src/hitimes/HitimesStats.java

@@ -0,0 +1,112 @@
+package hitimes;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+
+import org.jruby.RubyNumeric;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.ObjectAllocator;
+
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyClass;
+
+@JRubyClass( name = "Hitimes::Stats" )
+public class HitimesStats extends RubyObject {
+
+    private double min   = 0.0;
+    private double max   = 0.0;
+    private double sum   = 0.0;
+    private double sumsq = 0.0;
+    private long   count = 0;
+
+    public static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new HitimesStats( runtime, klass );
+        }
+    };
+
+    public HitimesStats( Ruby runtime, RubyClass klass ) {
+        super( runtime, klass );
+    }
+
+    @JRubyMethod( name = "update", required = 1, argTypes = RubyNumeric.class )
+    public IRubyObject update( IRubyObject val ) {
+        double v = RubyNumeric.num2dbl( val );
+
+        if ( 0 == this.count ) {
+            this.min = this.max = v;
+        } else {
+            this.min = ( v < this.min ) ? v : this.min;
+            this.max = ( v > this.max ) ? v : this.max;
+        }
+
+        this.count += 1;
+        this.sum   += v;
+        this.sumsq += (v * v);
+
+        return val;
+    }
+
+    @JRubyMethod( name = "mean" )
+    public IRubyObject mean() {
+        double mean = 0.0;
+
+        if ( this.count > 0 ) {
+            mean = this.sum / this.count;
+        }
+
+        return getRuntime().newFloat( mean );
+    }
+
+
+    @JRubyMethod( name = "rate" )
+    public IRubyObject rate() {
+        double rate = 0.0;
+
+        if ( this.sum > 0.0 ) {
+            rate = this.count / this.sum ;
+        }
+
+        return getRuntime().newFloat( rate );
+    }
+
+    @JRubyMethod( name = "stddev" )
+    public IRubyObject stddev() {
+        double stddev = 0.0;
+
+        if ( this.count > 1 ) {
+            double sq_sum = this.sum * this.sum;
+            stddev = Math.sqrt( ( this.sumsq - ( sq_sum / this.count ) ) / ( this.count - 1 ) );
+        }
+        return getRuntime().newFloat( stddev );
+    }
+
+
+    @JRubyMethod( name = "min" )
+    public IRubyObject min() {
+        return getRuntime().newFloat( this.min );
+    }
+
+    @JRubyMethod( name = "max" )
+    public IRubyObject max() {
+        return getRuntime().newFloat( this.max );
+    }
+
+    @JRubyMethod( name = "sum" )
+    public IRubyObject sum() {
+        return getRuntime().newFloat( this.sum );
+    }
+
+    @JRubyMethod( name = "sumsq" )
+    public IRubyObject sumsq() {
+        return getRuntime().newFloat( this.sumsq );
+    }
+
+    @JRubyMethod( name = "count" )
+    public IRubyObject count() {
+        return getRuntime().newFixnum( this.count );
+    }
+}
+
+

data/lib/hitimes.rb

@@ -15,16 +15,26 @@ module Hitimes
   # Base class of all errors in Hitimes
   #
   class Error < ::StandardError; end
+
+  # Hitimes.measure { } -> Float
+  #
+  # Times the execution of the block, returning the number of seconds it took
+  def self.measure(&block)
+    Hitimes::Interval.measure(&block)
+  end
 end
 require 'hitimes/paths'
 require 'hitimes/version'
 
-if RUBY_PLATFORM == "java" then
+# Load the binary extension, try loading one for the specific version of ruby
+# and if that fails, then fall back to one in the top of the library.
+# this is the method recommended by rake-compiler
+begin
+  # this will be for windows
+  require "hitimes/#{RUBY_VERSION.sub(/\.\d$/,'')}/hitimes"
+rescue LoadError
+  # everyone else.
   require 'hitimes/hitimes'
-else
-  # use a version subdirectory for extensions, initially to support windows, but
-  # why make a special case.  It doesn't hurt anyone to have an extra subdir.
-  require "hitimes/#{RUBY_VERSION.sub(/\.\d$/,'')}/hitimes_ext"
 end
 
 require 'hitimes/stats'

data/lib/hitimes/version.rb

@@ -4,54 +4,5 @@
 #++
 
 module Hitimes
-  #
-  # module containing all the version information about Hitimes
-  #
-  module Version
-
-    # Major version number
-    MAJOR   = 1
-
-    # Minor version number
-    MINOR   = 1
-
-    # Build number
-    BUILD   = 1
-
-    #
-    # :call-seq:
-    #   Version.to_a -> [ MAJOR, MINOR, BUILD ]
-    #
-    # Return the version as an array of Integers
-    #
-    def self.to_a
-      [MAJOR, MINOR, BUILD]
-    end
-
-    #
-    # :call-seq:
-    #   Version.to_s -> "MAJOR.MINOR.BUILD"
-    #
-    # Return the version as a String with dotted notation
-    #
-    def self.to_s
-      to_a.join(".")
-    end
-
-    #
-    # :call-seq:
-    #   Version.to_hash -> { :major => ..., :minor => ..., :build => ... }
-    #
-    # Return the version as a Hash
-    #
-    def self.to_hash
-      { :major => MAJOR, :minor => MINOR, :build => BUILD }
-    end
-
-    # The Version in MAJOR.MINOR.BUILD dotted notation
-    STRING = Version.to_s
-  end
-
-  # The Version in MAJOR.MINOR.BUILD dotted notation
-  VERSION = Version.to_s
+  VERSION = "1.2.2"
 end

data/spec/hitimes_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Hitimes do
+  it "can time a block of code" do
+    d = Hitimes.measure do
+      sleep 0.2
+    end
+    d.must_be_close_to(0.2, 0.002)
+  end
+
+  it "raises an error if measure is called with no block" do
+    lambda{ Hitimes.measure }.must_raise( Hitimes::Error )
+  end
+end

data/spec/interval_spec.rb

@@ -1,53 +1,56 @@
-require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
-
-require 'hitimes'
+require "spec_helper"
 
 describe Hitimes::Interval do
-  it "has a 0 duration when newly created" do
-    i = Hitimes::Interval.new   
-    i.duration == 0.0
+  it "raises an error if duration is called on a non-started interval" do
+    i = Hitimes::Interval.new
+    lambda{ i.duration }.must_raise( Hitimes::Error, /\AAttempt to report a duration on an interval that has not started\Z/ )
+  end
+
+  it "raises an error if stop is called on a non-started interval" do
+    i = Hitimes::Interval.new
+    lambda { i.stop }.must_raise( Hitimes::Error, /\AAttempt to stop an interval that has not started\Z/ )
   end
 
   it "knows if it has been started" do
     i = Hitimes::Interval.new
-    i.should_not be_started
+    i.started?.must_equal false
 
     i.start
-    i.should be_started
+    i.started?.must_equal true
   end
 
   it "knows if it has been stopped" do
     i = Hitimes::Interval.new
     i.start
-    i.should_not be_stopped
+    i.stopped?.must_equal false
     i.stop
-    i.should be_stopped
+    i.stopped?.must_equal true
   end
 
   it "knows if it is currently running" do
     i = Hitimes::Interval.new
-    i.should_not be_running
+    i.running?.must_equal false
     i.start
-    i.should be_running
+    i.running?.must_equal true
     i.stop
-    i.should_not be_running
+    i.running?.must_equal false
   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.02)
+    d.must_be_close_to(0.2, 0.002)
   end
 
   it "raises an error if measure is called with no block" do
-    lambda{ Hitimes::Interval.measure }.should raise_error( Hitimes::Error )
+    lambda{ Hitimes::Interval.measure }.must_raise( Hitimes::Error, /\ANo block given to Interval.measure\Z/ )
   end
 
   it "creates an interval via #now" do
     i = Hitimes::Interval.now
-    i.should be_started
-    i.should_not be_stopped
+    i.started?.must_equal true
+    i.stopped?.must_equal false
   end
 
   it "calling duration multiple times returns successivly grater durations" do
@@ -55,33 +58,33 @@ describe Hitimes::Interval do
     i.start
     y = i.duration
     z = i.duration
-    z.should > y
+    z.must_be :>, y
   end
 
   it "calling start multiple times on has no effect after the first call" do
     i = Hitimes::Interval.new
-    i.start.should == true
+    i.start.must_equal true
     x = i.start_instant
-    i.start_instant.should > 0
-    i.start.should == false
-    x.should == i.start_instant
+    i.start_instant.must_be :>, 0
+    i.start.must_equal false
+    x.must_equal 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 )
+    d.must_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.start.must_equal true
     i.stop
 
     x = i.stop_instant
-    i.stop_instant.should > 0
-    i.stop.should == false
-    x.should == i.stop_instant
+    i.stop_instant.must_be :>, 0
+    i.stop.must_equal false
+    x.must_equal i.stop_instant
 
   end
 
@@ -90,26 +93,26 @@ describe Hitimes::Interval do
     i.start
     x = i.stop
     y = i.duration
-    i.stop.should == false
+    i.stop.must_equal false
 
     z = i.duration
 
-    x.should == y
-    x.should == z
+    x.must_equal y
+    x.must_equal z
 
-    y.should == z
+    y.must_equal z
   end
 
   it "can return how much time has elapsed from the start without stopping the interval" do
     i = Hitimes::Interval.new
     i.start
     x = i.duration_so_far
-    i.should be_running
+    i.running?.must_equal true
     y = i.duration_so_far
     i.stop
-    x.should < y
-    x.should < i.duration
-    y.should < i.duration
+    x.must_be :<, y
+    x.must_be :<, i.duration
+    y.must_be :<, i.duration
   end
 
   describe "#split" do
@@ -118,14 +121,14 @@ describe Hitimes::Interval do
       i = Hitimes::Interval.new
       i.start
       i2 = i.split
-      i.object_id.should_not == i2.object_id
+      i.object_id.wont_equal 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
+      i.stop_instant.must_equal i2.start_instant
     end
   end
 

data/spec/metric_spec.rb

@@ -1,6 +1,4 @@
-require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
-
-require 'hitimes/metric'
+require "spec_helper"
 
 describe Hitimes::Metric do
   before( :each ) do
@@ -8,22 +6,22 @@ describe Hitimes::Metric do
   end
 
   it 'has a name' do
-    @metric.name.should == "testing"
+    @metric.name.must_equal "testing"
   end
 
   it "has associated data from initialization" do
     m = Hitimes::Metric.new( "more-data", 'foo' => 'bar', 'this' => 'that' )
-    m.additional_data['foo'].should == 'bar'
-    m.additional_data['this'].should == 'that'
+    m.additional_data['foo'].must_equal 'bar'
+    m.additional_data['this'].must_equal 'that'
     
     m = Hitimes::Metric.new( "more-data", { 'foo' => 'bar', 'this' => 'that' } )
-    m.additional_data['foo'].should == 'bar'
-    m.additional_data['this'].should == 'that'
+    m.additional_data['foo'].must_equal 'bar'
+    m.additional_data['this'].must_equal 'that'
   end
 
   it "initially has no sampling times" do
-    @metric.sampling_start_time.should == nil
-    @metric.sampling_stop_time.should == nil
+    @metric.sampling_start_time.must_be_nil
+    @metric.sampling_stop_time.must_be_nil
   end
 end
 

data/spec/mutex_stats_spec.rb

@@ -1,7 +1,4 @@
-require File.expand_path( File.join( File.dirname( __FILE__ ), "spec_helper.rb" ) )
-
-require 'hitimes'
-require 'hitimes/mutexed_stats'
+require 'spec_helper'
 
 describe Hitimes::MutexedStats do
   before( :each ) do
@@ -19,16 +16,21 @@ describe Hitimes::MutexedStats do
     return stats
   end
 
-  it "is unsafe normally" do
-    pending "not for MRI -- not interruptable in this C extension" do
+  if (not defined? RUBY_ENGINE) or (RUBY_ENGINE == "ruby") then
+    it "Hitimes::Stats is threadsafe" do
+      stats = run_with_scissors( ::Hitimes::Stats.new, @threads, @iters )
+      stats.count.must_equal @final_value
+    end
+  else
+    it "Hitimes::Stats is not threadsafe" do
       stats = run_with_scissors( ::Hitimes::Stats.new, @threads, @iters )
-      stats.count.should_not == @final_value
+      stats.count.wont_equal @final_value
     end
   end
 
   it "has a threadsafe update" do
     stats = run_with_scissors( ::Hitimes::MutexedStats.new, @threads, @iters )
-    stats.count.should == @final_value
+    stats.count.must_equal @final_value
   end
 
 end