hitimes 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 736be6cc3cde6ee7776bbf9a7323cd87a1ec377f
-  data.tar.gz: 5e66a98e60f51d7a1651dd8112e4e660f0aa15f8
+  metadata.gz: 656918024e2e0b7c84864f63ec2fb51a0f0af28a
+  data.tar.gz: ac489662afdf40c26d0e6dec7ceb499c72757ed3
 SHA512:
-  metadata.gz: aece4200d9b9186b1b9eb9bf2be09925dd7bbb535a7c3464e23d4dcd01c0a20de393aa75323c5f38f6ed77fe2109d83fee6f389b38810b21adc48e66318c6143
-  data.tar.gz: 9143293beee4a4d4b904f751a28617b69e280abe8d7446868a75e4d329c4c3458aecba417dab89cbf4e3f9a3fb21d9a8156057a980b20dacb0bc09ef8c2ad615
+  metadata.gz: b826ec301a437778827083ec4da19a1f1cfaa404bf215d67a95059799e84348bd87991d65cbe593f47b9d3b12be47ed7082fedd498e54c97fc7f38eaa8eb65cf
+  data.tar.gz: 5f7b5af970ff2a0eb6748f19b4ecefd1fecea6042ccbeae8cc4678e2f099920ca8067bf1841636c2218060dca8bc32eeffe34001b84b0b9361a6bf374eb8345a

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - "1.8.7"
+  - "1.9.2"
+  - "1.9.3"
+  - "2.0.0"
+  - "2.1.0"
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx
+install: rake develop

data/HISTORY.md

@@ -1,5 +1,10 @@
 # Hitimes Changelog
 
+## Version 1.2.2 2014-07-09
+
+* fix compilation issue with clock_gettime in libc (reported by eradman and virtualfunction)
+* Switch to minispec for tests
+
 ## Version 1.2.1 2013-03-12
 
 * Update dependencies

data/Manifest.txt

@@ -1,3 +1,4 @@
+.travis.yml
 CONTRIBUTING.md
 HISTORY.md
 LICENSE

data/Rakefile

@@ -7,13 +7,14 @@ This.email    = "jeremy@copiousfreetime.org"
 This.homepage = "http://github.com/copiousfreetime/#{ This.name }"
 
 This.ruby_gemspec do |spec|
-  spec.add_development_dependency( 'rake'         , '~> 10.0.3')
-  spec.add_development_dependency( 'rspec'        , '~> 2.13.0' )
-  spec.add_development_dependency( 'rdoc'         , '~> 4.0'   )
+  spec.add_development_dependency( 'rake'         , '~> 10.0')
+  spec.add_development_dependency( 'minitest'     , '~> 5.3' )
+  spec.add_development_dependency( 'rdoc'         , '~> 4.1'  )
   spec.add_development_dependency( 'json'         , '~> 1.7.7' )
-  spec.add_development_dependency( 'rake-compiler', '~> 0.8.3' )
+  spec.add_development_dependency( 'rake-compiler', '~> 0.9' )
 
   spec.extensions.concat This.extension_conf_files
+  spec.license = "ISC"
 end
 
 This.java_gemspec( This.ruby_gemspec ) do |spec|

data/ext/hitimes/c/extconf.rb

@@ -9,6 +9,13 @@ elsif RbConfig::CONFIG['host_os'] =~ /win32/ or RbConfig::CONFIG['host_os'] =~ /
 else
   if have_library("rt", "clock_gettime") then
     $CFLAGS += " -DUSE_INSTANT_CLOCK_GETTIME=1"
+  elsif have_library("c", "clock_gettime") then
+    $CFLAGS += " -DUSE_INSTANT_CLOCK_GETTIME=1"
+  else
+    raise NotImplementedError, <<-_
+Unable to find the function 'clock_gettime' in either libc or librt.
+Please file an issue at https://github.com/copiousfreetime/hitimes.
+_
   end
 end
 

data/lib/hitimes/version.rb

@@ -4,5 +4,5 @@
 #++
 
 module Hitimes
-  VERSION = "1.2.1"
+  VERSION = "1.2.2"
 end

data/spec/hitimes_spec.rb

@@ -5,10 +5,10 @@ describe Hitimes do
     d = Hitimes.measure do
       sleep 0.2
     end
-    d.should be_within(0.02).of(0.2)
+    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 }.should raise_error( Hitimes::Error, /\ANo block given to Interval.measure\Z/ )
+    lambda{ Hitimes.measure }.must_raise( Hitimes::Error )
   end
 end

data/spec/interval_spec.rb

@@ -3,54 +3,54 @@ require "spec_helper"
 describe Hitimes::Interval do
   it "raises an error if duration is called on a non-started interval" do
     i = Hitimes::Interval.new
-    lambda{ i.duration }.should raise_error( Hitimes::Error, /\AAttempt to report a duration on an interval that has not started\Z/ )
+    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 }.should raise_error( Hitimes::Error, /\AAttempt to stop an interval that has not started\Z/ )
+    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_within(0.02).of(0.2)
+    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, /\ANo block given to Interval.measure\Z/ )
+    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
@@ -58,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 be == true
+    i.start.must_equal true
     x = i.start_instant
-    i.start_instant.should be > 0
-    i.start.should be == 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 be == true
+    i.start.must_equal true
     i.stop
 
     x = i.stop_instant
-    i.stop_instant.should be > 0
-    i.stop.should be == false
-    x.should == i.stop_instant
+    i.stop_instant.must_be :>, 0
+    i.stop.must_equal false
+    x.must_equal i.stop_instant
 
   end
 
@@ -93,26 +93,26 @@ describe Hitimes::Interval do
     i.start
     x = i.stop
     y = i.duration
-    i.stop.should be == false
+    i.stop.must_equal false
 
     z = i.duration
 
-    x.should be == y
-    x.should be == z
+    x.must_equal y
+    x.must_equal z
 
-    y.should be == 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 be < y
-    x.should be < i.duration
-    y.should be < i.duration
+    x.must_be :<, y
+    x.must_be :<, i.duration
+    y.must_be :<, i.duration
   end
 
   describe "#split" do
@@ -121,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

@@ -6,22 +6,22 @@ describe Hitimes::Metric do
   end
 
   it 'has a name' do
-    @metric.name.should be == "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 be == 'bar'
-    m.additional_data['this'].should be == '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 be == 'bar'
-    m.additional_data['this'].should be == '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 be == nil
-    @metric.sampling_stop_time.should be == nil
+    @metric.sampling_start_time.must_be_nil
+    @metric.sampling_stop_time.must_be_nil
   end
 end
 

data/spec/mutex_stats_spec.rb

@@ -19,18 +19,18 @@ describe Hitimes::MutexedStats 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.should== @final_value
+      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

data/spec/paths_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 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
+    Hitimes::Paths.root_dir.must_equal 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
+    Hitimes::Paths.lib_path.must_equal File.expand_path( File.join( File.dirname( __FILE__ ), "..", "lib" ) ) + ::File::SEPARATOR
   end
 end

data/spec/spec_helper.rb

@@ -4,6 +4,8 @@ if RUBY_VERSION >= '1.9.2' then
   SimpleCov.start if ENV['COVERAGE']
 end
 
-require 'rspec/autorun'
+gem 'minitest'
 require 'hitimes'
+require 'minitest/autorun'
+require 'minitest/pride'
 

data/spec/stats_spec.rb

@@ -10,64 +10,64 @@ describe Hitimes::Stats do
   end
 
   it "is initialized with 0 values" do
-    @stats.count.should be == 0
-    @stats.min.should be == 0.0
-    @stats.max.should be == 0.0
-    @stats.sum.should be == 0.0
-    @stats.rate.should be == 0.0
+    @stats.count.must_equal 0
+    @stats.min.must_equal 0.0
+    @stats.max.must_equal 0.0
+    @stats.sum.must_equal 0.0
+    @stats.rate.must_equal 0.0
   end
 
   it "calculates the mean correctly" do
-    @full_stats.mean.should be == 2.0
+    @full_stats.mean.must_equal 2.0
   end
 
   it "calculates the rate correctly" do
-    @full_stats.rate.should be == 0.5
+    @full_stats.rate.must_equal 0.5
   end
 
   it "tracks the maximum value" do
-    @full_stats.max.should be == 3.0
+    @full_stats.max.must_equal 3.0
   end
 
   it "tracks the minimum value" do
-    @full_stats.min.should be == 1.0
+    @full_stats.min.must_equal 1.0
   end
 
   it "tracks the count" do
-    @full_stats.count.should be == 3
+    @full_stats.count.must_equal 3
   end
   
   it "tracks the sum" do
-    @full_stats.sum.should be == 6.0
+    @full_stats.sum.must_equal 6.0
   end
 
   it "calculates the standard deviation" do
-    @full_stats.stddev.should be == 1.0
+    @full_stats.stddev.must_equal 1.0
   end 
 
   it "calculates the sum of squares " do
-    @full_stats.sumsq.should be == 14.0
+    @full_stats.sumsq.must_equal 14.0
   end 
 
   describe "#to_hash " do
     it "converts to a Hash" do
       h = @full_stats.to_hash
-      h.size.should be == ::Hitimes::Stats::STATS.size
-      h.keys.sort.should be == ::Hitimes::Stats::STATS
+      h.size.must_equal ::Hitimes::Stats::STATS.size
+      h.keys.sort.must_equal ::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 be == 3
-      h.keys.sort.should be == %w[ max mean min  ]
+      h.size.must_equal 3
+      h.keys.sort.must_equal %w[ max mean min  ]
 
       h = @full_stats.to_hash( %w[ count rate ] )
-      h.size.should be == 2
-      h.keys.sort.should be == %w[ count rate ]
+      h.size.must_equal 2
+      h.keys.sort.must_equal %w[ count rate ]
     end
 
     it "raises NoMethodError if an invalid stat is used" do
-      lambda { @full_stats.to_hash( "wibble" ) }.should raise_error( NoMethodError )
+      lambda { @full_stats.to_hash( "wibble" ) }.must_raise( NoMethodError )
     end
   end
 
@@ -75,24 +75,24 @@ describe Hitimes::Stats do
     it "converts to a json string" do
       j = @full_stats.to_json
       h = JSON.parse( j )
-      h.size.should be == ::Hitimes::Stats::STATS.size
-      h.keys.sort.should be == ::Hitimes::Stats::STATS
+      h.size.must_equal ::Hitimes::Stats::STATS.size
+      h.keys.sort.must_equal ::Hitimes::Stats::STATS
     end
 
     it "converts to a limited Hash if given arguments" do
       j = @full_stats.to_json( "min", "max", "mean" )
       h = JSON.parse( j )
-      h.size.should be == 3
-      h.keys.sort.should be == %w[ max mean min  ]
+      h.size.must_equal 3
+      h.keys.sort.must_equal %w[ max mean min  ]
 
       j = @full_stats.to_json( %w[ count rate ] )
       h = JSON.parse( j )
-      h.size.should be == 2
-      h.keys.sort.should be == %w[ count rate ]
+      h.size.must_equal 2
+      h.keys.sort.must_equal %w[ count rate ]
     end
 
     it "raises NoMethodError if an invalid stat is used" do
-      lambda { @full_stats.to_json( "wibble" ) }.should raise_error( NoMethodError )
+      lambda { @full_stats.to_json( "wibble" ) }.must_raise( NoMethodError )
     end
   end
 end

data/spec/timed_metric_spec.rb

@@ -6,90 +6,90 @@ describe Hitimes::TimedMetric do
   end
 
   it "knows if it is running or not" do
-    @tm.should_not be_running
+    @tm.running?.must_equal false
     @tm.start
-    @tm.should be_running
+    @tm.running?.must_equal true
     @tm.stop
-    @tm.should_not be_running
+    @tm.running?.must_equal false
   end
 
   it "#split returns the last duration and the timer is still running" do
     @tm.start
     d = @tm.split
-    @tm.should be_running
-    d.should be > 0
-    @tm.count.should be == 1
-    @tm.duration.should be == d
+    @tm.running?.must_equal true
+    d.must_be :>, 0
+    @tm.count.must_equal 1
+    @tm.duration.must_equal d
   end
 
   it "#stop returns false if called more than once in a row" do
     @tm.start
-    @tm.stop.should be > 0
-    @tm.stop.should be == false
+    @tm.stop.must_be :>, 0
+    @tm.stop.must_equal false
   end
 
   it "does not count a currently running interval as an interval in calculations" do
     @tm.start
-    @tm.count.should be == 0
+    @tm.count.must_equal 0
     @tm.split
-    @tm.count.should be == 1
+    @tm.count.must_equal 1
   end
 
   it "#split called on a stopped timer does nothing" do
     @tm.start
     @tm.stop
-    @tm.split.should be == false
+    @tm.split.must_equal false
   end
 
   it "calculates the mean of the durations" do
     2.times { @tm.start ; sleep 0.05 ; @tm.stop }
-    @tm.mean.should be_within(0.01).of(0.05)
+    @tm.mean.must_be_close_to(0.05, 0.002)
   end
 
   it "calculates the rate of the counts " do
     5.times { @tm.start ; sleep 0.05 ; @tm.stop }
-    @tm.rate.should be_within(1.0).of(20.00)
+    @tm.rate.must_be_close_to(20.00, 0.5)
   end
 
 
   it "calculates the stddev of the durations" do
     3.times { |x| @tm.start ; sleep(0.05 * x) ; @tm.stop }
-    @tm.stddev.should be_within(0.002).of( 0.05)
+    @tm.stddev.must_be_close_to(0.05)
   end
 
   it "returns 0.0 for stddev if there is no data" do
-    @tm.stddev.should be == 0.0
+    @tm.stddev.must_equal 0.0
   end
 
   it "keeps track of the min value" do
     2.times { @tm.start ; sleep 0.05 ; @tm.stop }
-    @tm.min.should be_within( 0.002 ).of(0.05)
+    @tm.min.must_be_close_to(0.05, 0.01)
   end
 
   it "keeps track of the max value" do
     2.times { @tm.start ; sleep 0.05 ; @tm.stop }
-    @tm.max.should be_within( 0.002 ).of(0.05)
+    @tm.max.must_be_close_to(0.05, 0.01)
   end
 
   it "keeps track of the sum value" do
     2.times { @tm.start ; sleep 0.05 ; @tm.stop }
-    @tm.sum.should be_within( 0.005 ).of(0.10)
+    @tm.sum.must_be_close_to(0.10, 0.01)
   end
 
   it "keeps track of the sum of squars value" do
     3.times { @tm.start ; sleep 0.05 ; @tm.stop }
-    @tm.sumsq.should be_within(0.001).of(0.0075)
+    @tm.sumsq.must_be_close_to(0.0075)
   end
 
   it "keeps track of the minimum start time of all the intervals" do
     f1 = Time.now.gmtime.to_f * 1_000_000
     5.times { @tm.start ; sleep 0.05 ; @tm.stop }
     f2 = Time.now.gmtime.to_f * 1_000_000
-    @tm.sampling_start_time.should be >= f1
-    @tm.sampling_start_time.should be < f2
+    @tm.sampling_start_time.must_be :>=, f1
+    @tm.sampling_start_time.must_be :<, f2
     # distance from now to start time should be greater than the distance from
     # the start to the min start_time
-    (f2 - @tm.sampling_start_time).should > ( @tm.sampling_start_time - f1 )
+    (f2 - @tm.sampling_start_time).must_be :>, ( @tm.sampling_start_time - f1 )
   end
 
   it "keeps track of the last stop time of all the intervals" do
@@ -98,57 +98,57 @@ describe Hitimes::TimedMetric do
     5.times { @tm.start ; sleep 0.05 ; @tm.stop }
     sleep 0.01
     f2 = Time.now.gmtime.to_f * 1_000_000
-    @tm.sampling_stop_time.should be > f1
-    @tm.sampling_stop_time.should be <= f2
+    @tm.sampling_stop_time.must_be :>, f1
+    @tm.sampling_stop_time.must_be :<=, f2
     # distance from now to max stop time time should be less than the distance
     # from the start to the max stop time
-    (f2 - @tm.sampling_stop_time).should < ( @tm.sampling_stop_time - f1 )
+    (f2 - @tm.sampling_stop_time).must_be :<, ( @tm.sampling_stop_time - f1 )
   end
 
   it "can create an already running timer" do
     t = Hitimes::TimedMetric.now( 'already-running' )
-    t.should be_running
+    t.running?.must_equal true
   end
 
   it "can measure a block of code from an instance" do
     t = Hitimes::TimedMetric.new( 'measure a block' )
     3.times { t.measure { sleep 0.05 } }
-    t.duration.should be_within(0.01).of(0.15)
-    t.count.should be == 3
+    t.duration.must_be_close_to(0.15, 0.01)
+    t.count.must_equal 3
   end
 
   it "returns the value of the block when measuring" do
     t = Hitimes::TimedMetric.new( 'measure a block' )
     x = t.measure { sleep 0.05; 42 }
-    t.duration.should be_within(0.002).of(0.05)
-    x.should be == 42
+    t.duration.must_be_close_to(0.05, 0.002)
+    x.must_equal 42
   end
 
   describe "#to_hash" do
 
     it "has name value" do
       h = @tm.to_hash
-      h['name'].should be == "test-timed-metric"
+      h['name'].must_equal "test-timed-metric"
     end
 
     it "has an empty hash for additional_data" do
       h = @tm.to_hash
-      h['additional_data'].should be == Hash.new
-      h['additional_data'].size.should be == 0
+      h['additional_data'].must_equal Hash.new
+      h['additional_data'].size.must_equal 0
     end
 
     it "has the right sum" do
       10.times { |x| @tm.measure { sleep 0.01*x  } }
       h = @tm.to_hash
-      h['sum'].should be_within( 0.01).of(0.45)
+      h['sum'].must_be_close_to(0.45, 0.01)
     end
 
     fields = ::Hitimes::Stats::STATS.dup + %w[ name additional_data sampling_start_time sampling_stop_time ]
     fields.each do |f|
-      it "should have a value for #{f}" do
+      it "has a value for #{f}" do
         @tm.measure { sleep 0.001 }
         h = @tm.to_hash
-        h[f].should_not be_nil
+        h[f].wont_be_nil
       end
     end
   end 

data/spec/timed_value_metric_spec.rb

@@ -6,100 +6,100 @@ describe Hitimes::TimedValueMetric do
   end
 
   it "knows if it is running or not" do
-    @tm.should_not be_running
+    @tm.running?.must_equal false
     @tm.start
-    @tm.should be_running
+    @tm.running?.must_equal true
     @tm.stop( 1 )
-    @tm.should_not be_running
+    @tm.running?.must_equal false
   end
 
   it "#split returns the last duration and the timer is still running" do
     @tm.start
     d = @tm.split( 1 )
-    @tm.should be_running
-    d.should be > 0
-    @tm.value_stats.count.should be == 1
-    @tm.timed_stats.count.should be == 1
-    @tm.duration.should be == d
+    @tm.running?.must_equal true
+    d.must_be :>, 0
+    @tm.value_stats.count.must_equal 1
+    @tm.timed_stats.count.must_equal 1
+    @tm.duration.must_equal d
   end
 
   it "#stop returns false if called more than once in a row" do
     @tm.start
-    @tm.stop( 1 ).should be > 0
-    @tm.stop( 1 ).should be == false
+    @tm.stop( 1 ).must_be :>, 0
+    @tm.stop( 1 ).must_equal false
   end
 
   it "does not count a currently running interval as an interval in calculations" do
     @tm.start
-    @tm.value_stats.count.should be == 0
-    @tm.timed_stats.count.should be == 0
+    @tm.value_stats.count.must_equal 0
+    @tm.timed_stats.count.must_equal 0
     @tm.split( 1 )
-    @tm.value_stats.count.should be == 1
-    @tm.timed_stats.count.should be == 1
+    @tm.value_stats.count.must_equal 1
+    @tm.timed_stats.count.must_equal 1
   end
 
   it "#split called on a stopped timer does nothing" do
     @tm.start
     @tm.stop( 1 )
-    @tm.split( 1 ).should be == false
+    @tm.split( 1 ).must_equal false
   end
 
   it "calculates the mean of the durations" do
     3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop(x) }
-    @tm.timed_stats.mean.should be_within(0.01).of(0.05)
-    @tm.value_stats.mean.should be == 1.00
+    @tm.timed_stats.mean.must_be_close_to(0.05, 0.01)
+    @tm.value_stats.mean.must_equal 1.00
   end
 
   it "calculates the rate of the counts " do
     5.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.rate.should be_within(1.0).of(40.0)
+    @tm.rate.must_be_close_to(40.0, 1.0)
   end
 
 
   it "calculates the stddev of the durations" do
     3.times { |x| @tm.start ; sleep(0.05 * x) ; @tm.stop(x) }
-    @tm.timed_stats.stddev.should be_within(0.001).of(0.05)
-    @tm.value_stats.stddev.should be == 1.0
+    @tm.timed_stats.stddev.must_be_close_to(0.05, 0.001)
+    @tm.value_stats.stddev.must_equal 1.0
   end
 
   it "returns 0.0 for stddev if there is no data" do
-    @tm.timed_stats.stddev.should be == 0.0
-    @tm.value_stats.stddev.should be == 0.0
+    @tm.timed_stats.stddev.must_equal 0.0
+    @tm.value_stats.stddev.must_equal 0.0
   end
 
   it "keeps track of the min value" do
     3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.timed_stats.min.should be_within( 0.003 ).of(0.05)
-    @tm.value_stats.min.should be == 0
+    @tm.timed_stats.min.must_be_close_to( 0.05, 0.003 )
+    @tm.value_stats.min.must_equal 0
   end
 
   it "keeps track of the max value" do
     3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.timed_stats.max.should be_within(0.003).of( 0.05 )
-    @tm.value_stats.max.should be == 2
+    @tm.timed_stats.max.must_be_close_to( 0.05, 0.003 )
+    @tm.value_stats.max.must_equal 2
   end
 
   it "keeps track of the sum value" do
     3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.timed_stats.sum.should be_within(0.01).of(0.15)
-    @tm.value_stats.sum.should be == 3
+    @tm.timed_stats.sum.must_be_close_to( 0.15, 0.01 )
+    @tm.value_stats.sum.must_equal 3
   end
   
   it "keeps track of the sum of squares value" do
     3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
-    @tm.timed_stats.sumsq.should be_within(0.0005).of(0.0075)
-    @tm.value_stats.sumsq.should be == 5
+    @tm.timed_stats.sumsq.must_be_close_to(0.0075, 0.0005)
+    @tm.value_stats.sumsq.must_equal 5
   end
 
   it "keeps track of the minimum start time of all the intervals" do
     f1 = Time.now.gmtime.to_f * 1000000
     5.times { @tm.start ; sleep 0.05 ; @tm.stop( 1 ) }
     f2 = Time.now.gmtime.to_f * 1000000
-    @tm.sampling_start_time.should be >= f1
-    @tm.sampling_start_time.should be < f2
+    @tm.sampling_start_time.must_be :>=, f1
+    @tm.sampling_start_time.must_be :<, f2
     # distance from now to start time should be greater than the distance from
     # the start to the min start_time
-    (f2 - @tm.sampling_start_time).should > ( @tm.sampling_start_time - f1 )
+    (f2 - @tm.sampling_start_time).must_be :>, ( @tm.sampling_start_time - f1 )
   end
 
   it "keeps track of the last stop time of all the intervals" do
@@ -107,64 +107,64 @@ describe Hitimes::TimedValueMetric do
     5.times { @tm.start ; sleep 0.05 ; @tm.stop( 1 ) }
     sleep 0.05
     f2 = Time.now.gmtime.to_f * 1_000_000
-    @tm.sampling_stop_time.should be > f1
-    @tm.sampling_stop_time.should be <= f2
+    @tm.sampling_stop_time.must_be :>, f1
+    @tm.sampling_stop_time.must_be :<=, f2
     # distance from now to max stop time time should be less than the distance
     # from the start to the max stop time
-    (f2 - @tm.sampling_stop_time).should < ( @tm.sampling_stop_time - f1 )
+    (f2 - @tm.sampling_stop_time).must_be :<, ( @tm.sampling_stop_time - f1 )
   end
 
   it "can create an already running timer" do
     t = Hitimes::TimedValueMetric.now( 'already-running' )
-    t.should be_running
+    t.running?.must_equal true
   end
 
   it "can measure a block of code from an instance" do
     t = Hitimes::TimedValueMetric.new( 'measure a block' )
     3.times { t.measure( 1 ) { sleep 0.05 } }
-    t.duration.should be_within(0.004).of(0.15)
-    t.timed_stats.count.should be == 3
-    t.value_stats.count.should be == 3
+    t.duration.must_be_close_to(0.15, 0.004)
+    t.timed_stats.count.must_equal 3
+    t.value_stats.count.must_equal 3
   end
 
   it "returns the value of the block when measuring" do
     t = Hitimes::TimedValueMetric.new( 'measure a block' )
     x = t.measure( 42 ) { sleep 0.05; 42 }
-    t.duration.should be_within(0.002).of(0.05)
-    x.should be == 42
+    t.duration.must_be_close_to(0.05, 0.002)
+    x.must_equal 42
   end
 
   describe "#to_hash" do
 
     it "has name value" do
       h = @tm.to_hash
-      h['name'].should be == "test-timed-value-metric"
+      h['name'].must_equal "test-timed-value-metric"
     end
 
     it "has an empty has for additional_data" do
       h = @tm.to_hash
-      h['additional_data'].should be == Hash.new
-      h['additional_data'].size.should be == 0
+      h['additional_data'].must_equal Hash.new
+      h['additional_data'].size.must_equal 0
     end
 
     it "has a rate" do
       5.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
       h = @tm.to_hash
-      h['rate'].should be_within(1.0  ).of(40.0)
+      h['rate'].must_be_close_to(40.0, 1.0)
     end
 
     it "has a unit_count" do
       5.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
       h = @tm.to_hash
-      h['unit_count'].should be ==  10
+      h['unit_count'].must_equal  10
     end
 
     fields = %w[ name additional_data sampling_start_time sampling_stop_time value_stats timed_stats rate unit_count ]
     fields.each do |f|
-      it "should have a value for #{f}" do
+      it "has a value for #{f}" do
         3.times { |x| @tm.measure(x) { sleep 0.001 } }
         h = @tm.to_hash
-        h[f].should_not be_nil
+        h[f].wont_be_nil
       end
     end
   end 

data/spec/value_metric_spec.rb

@@ -7,50 +7,50 @@ describe Hitimes::ValueMetric do
   end
 
   it 'has a name' do
-    @metric.name.should be == "testing"
+    @metric.name.must_equal "testing"
   end
 
   it "has associated data from initialization" do
     m = Hitimes::ValueMetric.new( "more-data", 'foo' => 'bar', 'this' => 'that' )
-    m.additional_data['foo'].should be == 'bar'
-    m.additional_data['this'].should be == 'that'
+    m.additional_data['foo'].must_equal 'bar'
+    m.additional_data['this'].must_equal 'that'
     
     m = Hitimes::ValueMetric.new( "more-data", { 'foo' => 'bar', 'this' => 'that' } )
-    m.additional_data['foo'].should be == 'bar'
-    m.additional_data['this'].should be == 'that'
+    m.additional_data['foo'].must_equal 'bar'
+    m.additional_data['this'].must_equal 'that'
   end
 
   it "calculates the mean of the measurements" do
-    @metric.mean.should be == 4.5
+    @metric.mean.must_equal 4.5
   end
 
   it "calculates the stddev of the measurements" do
-    @metric.stddev.should > 0.0
+    @metric.stddev.must_be :>, 0.0
   end
 
   it "returns 0.0 for stddev if there is no data" do
     m = Hitimes::ValueMetric.new('0-data')
-    m.stddev.should be == 0.0
+    m.stddev.must_equal 0.0
   end
 
   it "keeps track of the sum of data" do
-    @metric.sum.should be == 45.0
+    @metric.sum.must_equal 45.0
   end
 
   it "keeps track of the sum of squars of data" do
-    @metric.sumsq.should be == 285.0
+    @metric.sumsq.must_equal 285.0
   end
 
   it "retuns 0.0 for mean if there is no data" do
-    Hitimes::ValueMetric.new('0-data').mean.should be == 0.0
+    Hitimes::ValueMetric.new('0-data').mean.must_equal 0.0
   end
 
   it "keeps track of the min value" do
-    @metric.min.should be == 0
+    @metric.min.must_equal 0
   end
 
   it "keeps track of the max value" do
-    @metric.max.should be == 9
+    @metric.max.must_equal 9
   end
 
   it "keeps track of the first start time of all the measurements" do
@@ -58,11 +58,11 @@ describe Hitimes::ValueMetric do
     f1 = Time.now.gmtime.to_f * 1_000_000
     10.times{ |x| m.measure( x ); sleep 0.1 }
     f2 = Time.now.gmtime.to_f * 1_000_000
-    m.sampling_start_time.should be >= f1
-    m.sampling_start_time.should be < f2
+    m.sampling_start_time.must_be :>=, f1
+    m.sampling_start_time.must_be :<, f2
     # distance from now to start time should be greater than the distance from
     # the start to the min start_time
-    (f2 - m.sampling_start_time).should > ( m.sampling_start_time - f1 )
+    (f2 - m.sampling_start_time).must_be :>, ( m.sampling_start_time - f1 )
   end
 
   it "keeps track of the last stop time of all the intervals" do
@@ -70,37 +70,37 @@ describe Hitimes::ValueMetric do
     f1 = Time.now.gmtime.to_f * 1_000_000
     10.times {|x| m.measure( x ); sleep 0.1  }
     f2 = Time.now.gmtime.to_f * 1_000_000
-    m.sampling_stop_time.should be > f1
-    m.sampling_stop_time.should be <= f2
+    m.sampling_stop_time.must_be :>, f1
+    m.sampling_stop_time.must_be :<=, f2
     # distance from now to max stop time time should be less than the distance
     # from the start to the max stop time
-    (f2 - m.sampling_stop_time).should < ( m.sampling_stop_time - f1 )
+    (f2 - m.sampling_stop_time).must_be :<, ( m.sampling_stop_time - f1 )
   end
 
   describe "#to_hash" do
 
     it "has name value" do
       h = @metric.to_hash
-      h['name'].should be == "testing"
+      h['name'].must_equal "testing"
     end
 
     it "has an empty has for additional_data" do
       h = @metric.to_hash
-      h['additional_data'].should be == Hash.new
-      h['additional_data'].size.should be == 0
+      h['additional_data'].must_equal Hash.new
+      h['additional_data'].size.must_equal 0
     end
 
     it "has the right sum" do
       h = @metric.to_hash
-      h['sum'].should be == 45
+      h['sum'].must_equal 45
     end
 
     fields = ::Hitimes::Stats::STATS.dup + %w[ name additional_data sampling_start_time sampling_stop_time ]
     fields = fields - [ 'rate' ]
     fields.each do |f|
-      it "should have a value for #{f}" do
+      it "has a value for #{f}" do
         h = @metric.to_hash
-        h[f].should_not be_nil
+        h[f].wont_be_nil
       end
     end
   end

data/spec/version_spec.rb

@@ -2,6 +2,6 @@ require "spec_helper"
 
 describe "Hitimes::Version" do
   it "should be accessable as a constant" do
-    Hitimes::VERSION.should match(/\d+\.\d+\.\d+/)
+    Hitimes::VERSION.must_match(/\d+\.\d+\.\d+/)
   end
 end

data/tasks/default.rake

@@ -1,5 +1,6 @@
 # vim: syntax=ruby
 require 'rake/clean'
+require 'digest'
 #------------------------------------------------------------------------------
 # If you want to Develop on this project just run 'rake develop' and you'll
 # have all you need to get going. If you want to use bundler for development,
@@ -11,7 +12,7 @@ namespace :develop do
   # gemspec.
   task :default do
     require 'rubygems/dependency_installer'
-    installer = Gem::DependencyInstaller.new
+    installer = ::Gem::DependencyInstaller.new
 
     This.set_coverage_gem
 
@@ -30,7 +31,9 @@ namespace :develop do
   # Create a Gemfile that just references the gemspec
   file 'Gemfile' => :gemspec do
     File.open( "Gemfile", "w+" ) do |f|
-      f.puts 'source :rubygems'
+      f.puts "# DO NOT EDIT - This file is automatically generated"
+      f.puts "# Make changes to Manifest.txt and/or Rakefile and regenerate"
+      f.puts 'source "https://rubygems.org/"'
       f.puts 'gemspec'
     end
   end
@@ -53,8 +56,8 @@ begin
   require 'rake/testtask'
   Rake::TestTask.new( :test ) do |t|
     t.ruby_opts    = %w[ -w -rubygems ]
-    t.libs         = %w[ lib spec ]
-    t.pattern      = "spec/**/*_spec.rb"
+    t.libs         = %w[ lib spec test ]
+    t.pattern      = "{test,spec}/**/{test_*,*_spec}.rb"
   end
 
   task :test_requirements
@@ -79,7 +82,7 @@ begin
     t.rdoc_files.include( FileList['*.{rdoc,md,txt}'], FileList['ext/**/*.c'],
                           FileList['lib/**/*.rb'] )
   end
-rescue LoadError => le
+rescue StandardError, LoadError
   This.task_warning( 'rdoc' )
 end
 
@@ -106,9 +109,9 @@ else
     desc 'Run tests with code coverage'
     task :coverage do
       ENV['COVERAGE'] = 'true'
-      Rake::Task[:test].execute
+      Rake::Task[:test].invoke
     end
-    CLOBBER << FileList["coverage"]
+    CLOBBER << FileList["coverage"] if File.directory?( "coverage" )
   rescue LoadError
     This.task_warning( 'simplecov' )
   end
@@ -222,6 +225,8 @@ task :fixme => "fixme:default"
 desc "Build the #{This.name}.gemspec file"
 task :gemspec do
   File.open( This.gemspec_file, "wb+" ) do |f|
+    f.puts "# DO NOT EDIT - This file is automatically generated"
+    f.puts "# Make changes to Manifest.txt and/or Rakefile and regenerate"
     f.write This.platform_gemspec.to_ruby
   end
 end
@@ -234,7 +239,7 @@ CLOBBER << FileList["**/*.rbc"]
 
 # The standard gem packaging task, everyone has it.
 require 'rubygems/package_task'
-Gem::PackageTask.new( This.platform_gemspec ) do
+::Gem::PackageTask.new( This.platform_gemspec ) do
   # nothing
 end
 

data/tasks/this.rb

@@ -25,7 +25,7 @@ class ThisProject
   #
   # Yields self
   def initialize(&block)
-    @exclude_from_manifest = %r/\.(git|DS_Store)|^(doc|coverage|pkg|tmp)|Gemfile*|\.(gemspec|swp|jar|bundle|so|rvmrc)$|~$/
+    @exclude_from_manifest = %r/\.(git|DS_Store)|^(doc|coverage|pkg|tmp|Gemfile(\.lock)?)|^[^\/]+\.gemspec|\.(swp|jar|bundle|so|rvmrc)$|~$/
     @gemspecs              = Hash.new
     yield self if block_given?
   end
@@ -132,6 +132,7 @@ class ThisProject
 
       spec.summary     = summary
       spec.description = description
+      spec.license     = license
 
       spec.files       = manifest
       spec.executables = spec.files.grep(/^bin/) { |f| File.basename(f) }
@@ -176,7 +177,7 @@ class ThisProject
     if RUBY_VERSION < "1.9.0"
       platform_gemspec.add_development_dependency( 'rcov', '~> 1.0.0' )
     else
-      platform_gemspec.add_development_dependency( 'simplecov', '~> 0.7.1' )
+      platform_gemspec.add_development_dependency( 'simplecov', '~> 0.8.2' )
     end
   end
 
@@ -195,11 +196,15 @@ class ThisProject
     description_section.first
   end
 
-  # Internal: Return the full description text from the READEM
+  # Internal: Return the full description text from the README
   def description
     description_section.join(" ").tr("\n", ' ').gsub(/[{}]/,'').gsub(/\[[^\]]+\]/,'') # strip rdoc
   end
 
+  def license
+    "ISC"
+  end
+
   # Internal: The path to the gemspec file
   def gemspec_file
     project_path( "#{ name }.gemspec" )

metadata

@@ -1,85 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: hitimes
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Jeremy Hinegardner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-12 00:00:00.000000000 Z
+date: 2014-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.0.3
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.0.3
+        version: '10.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.13.0
+        version: '5.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.13.0
+        version: '5.3'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.1'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.7.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.7.7
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: '0.9'
 description: 'Hitimes is a fast, high resolution timer library for recording performance
   metrics.  It uses the appropriate low method calls for each system to get the highest
   granularity time increments possible.   It currently supports any of the following
@@ -96,6 +96,7 @@ extra_rdoc_files:
 - Manifest.txt
 - README.md
 files:
+- ".travis.yml"
 - CONTRIBUTING.md
 - HISTORY.md
 - LICENSE
@@ -141,29 +142,30 @@ files:
 - tasks/extension.rake
 - tasks/this.rb
 homepage: http://github.com/copiousfreetime/hitimes
-licenses: []
+licenses:
+- ISC
 metadata: {}
 post_install_message: 
 rdoc_options:
-- --main
+- "--main"
 - README.md
-- --markup
+- "--markup"
 - tomdoc
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Hitimes is a fast, high resolution timer library for recording performance