hitimes 1.0.3-x86-mswin32-60 → 1.2.2-x86-mswin32-60

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,18 +15,31 @@ 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'
 
-# support for fat binaries on windows
-if RUBY_PLATFORM =~ /(mswin|mingw)/i
-  require "hitimes/#{RUBY_VERSION.sub(/\.\d$/,'')}/hitimes_ext"
-else
-  require 'hitimes/hitimes_ext'
+# 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'
 end
+
 require 'hitimes/stats'
 require 'hitimes/mutexed_stats'
+
 require 'hitimes/metric'
 require 'hitimes/value_metric'
 require 'hitimes/timed_metric'

data/lib/hitimes/metric.rb

@@ -1,3 +1,9 @@
+
+#--
+# Copyright (c) 2008, 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
 module Hitimes
   #
   # Metric hold the common meta information for all derived metric classes

data/lib/hitimes/mutexed_stats.rb

@@ -1,4 +1,8 @@
-require 'hitimes'
+#--
+# Copyright (c) 2008, 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
 require 'thread'
 
 module Hitimes

data/lib/hitimes/stats.rb

@@ -1,4 +1,8 @@
-require 'hitimes'
+#--
+# Copyright (c) 2008, 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
 require 'stringio'
 module Hitimes
   class Stats

data/lib/hitimes/timed_metric.rb

@@ -3,7 +3,6 @@
 # All rights reserved.  See LICENSE and/or COPYING for details.
 #++
 
-require 'hitimes'
 require 'forwardable'
 module Hitimes
   #
@@ -171,7 +170,7 @@ module Hitimes
 
     # forward appropriate calls directly to the stats object
     extend Forwardable
-    def_delegators :@stats, :count, :sum, :max, :mean, :min, :rate, :stddev, :sum, :sumsq
+    def_delegators :@stats, :count, :max, :mean, :min, :rate, :stddev, :sum, :sumsq
     alias :duration :sum
   end
 end

data/lib/hitimes/timed_value_metric.rb

@@ -3,8 +3,6 @@
 # All rights reserved.  See LICENSE and/or COPYING for details.
 #++
 
-require 'hitimes'
-
 module Hitimes
   #
   # A TimedValueMetric holds the metrics on how long it takes to do a batch of something.

data/lib/hitimes/value_metric.rb

@@ -4,7 +4,6 @@
 #++
 
 require 'forwardable'
-require 'hitimes'
 module Hitimes
   #
   # A ValueMetric holds the data from measuring a single value over a period of
@@ -67,6 +66,6 @@ module Hitimes
 
     # forward appropriate calls directly to the stats object
     extend Forwardable
-    def_delegators :@stats, :count, :sum, :max, :mean, :min, :stddev, :sum, :sumsq
- end
+    def_delegators :@stats, :count, :max, :mean, :min, :stddev, :sum, :sumsq
+  end
 end

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   = 0
-
-    # Build number
-    BUILD   = 3
-
-    #
-    # :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/hitimes_ext'
+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.01)
+    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