scoot 0.0.4

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/ext/hitimes/c/hitimes_stats.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2008 Jeremy Hinegardner
+ * All rights reserved.  See LICENSE and/or COPYING for details.
+ *
+ * vim: shiftwidth=4 
+ */ 
+
+#ifndef __HITIMES_STATS_H__
+#define __HITIMES_STATS_H__
+
+#include <ruby.h>
+#include <math.h>
+
+/* classes and modules defined elswhere */
+extern VALUE mH;        /* Hitimes */
+extern VALUE eH_Error;  /* Hitimes::Error */
+extern VALUE cH_Stats;  /* Hitimes::Stats */
+
+
+typedef struct hitimes_stats {
+    long double min;
+    long double max;
+    long double sum;
+    long double sumsq;
+    long long   count;
+} hitimes_stats_t;
+
+#endif
+
+

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/ext/hitimes/java/src/hitimes/Hitimes.java

@@ -0,0 +1,54 @@
+package hitimes;
+
+import java.lang.Math;
+import java.lang.System;
+
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyModule;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyException;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+
+import org.jruby.exceptions.RaiseException;
+
+
+/**
+ * @author <a href="mailto:jeremy@hinegardner.org">Jeremy Hinegardner</a>
+ */
+@JRubyModule( name = "Hitimes" )
+public class Hitimes {
+
+    public static RubyClass hitimesIntervalClass;
+    /**
+     * Create the Hitimes module and add it to the Ruby runtime.
+     */
+    public static RubyModule createHitimes( Ruby runtime ) {
+        RubyModule mHitimes = runtime.defineModule("Hitimes");
+
+        RubyClass  cStandardError = runtime.getStandardError();
+        RubyClass  cHitimesError  = mHitimes.defineClassUnder("Error", cStandardError, cStandardError.getAllocator());
+
+        RubyClass  cHitimesStats  = mHitimes.defineClassUnder("Stats", runtime.getObject(), HitimesStats.ALLOCATOR );
+        cHitimesStats.defineAnnotatedMethods( HitimesStats.class );
+
+        RubyClass  cHitimesInterval  = mHitimes.defineClassUnder("Interval", runtime.getObject(), HitimesInterval.ALLOCATOR );
+        Hitimes.hitimesIntervalClass = cHitimesInterval;
+        cHitimesInterval.defineAnnotatedMethods( HitimesInterval.class );
+
+        return mHitimes;
+    }
+
+    static RaiseException newHitimesError( Ruby runtime, String message ) {
+        RubyClass errorClass = runtime.getModule("Hitimes").getClass( "Error" );
+        return new RaiseException( RubyException.newException( runtime, errorClass, message ), true );
+    }
+
+
+
+    @JRubyClass( name = "Hitimes::Error", parent = "StandardError" )
+    public static class Error {};
+
+}

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/ext/hitimes/java/src/hitimes/HitimesInterval.java

@@ -0,0 +1,181 @@
+package hitimes;
+
+import org.jruby.runtime.builtin.IRubyObject;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+
+@JRubyClass( name = "Hitimes::Interval" )
+public class HitimesInterval extends RubyObject {
+
+    /* this is a double to force all division by the conversion factor
+     * to cast to doubles
+     */
+    private static final double INSTANT_CONVERSION_FACTOR = 1000000000d;
+
+    private static final long   INSTANT_NOT_SET  = Long.MIN_VALUE;
+    private static final double DURATION_NOT_SET = Double.NaN;
+
+    public static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new HitimesInterval( runtime, klass );
+        }
+    };
+
+    public HitimesInterval( Ruby runtime, RubyClass klass ) {
+        super( runtime, klass );
+    }
+
+    public HitimesInterval( Ruby runtime, RubyClass klass, long start ) {
+        super( runtime, klass );
+        this.start_instant = start;
+    }
+
+
+    private long start_instant = INSTANT_NOT_SET;
+    private long stop_instant  = INSTANT_NOT_SET;
+    private double duration    = DURATION_NOT_SET;
+
+    @JRubyMethod( name = "duration", alias = { "length", "to_f", "to_seconds" } )
+    public IRubyObject duration() {
+
+        /*
+         * if start has not yet been called, then raise an exception.
+         */
+        if ( INSTANT_NOT_SET == this.start_instant ) {
+            throw Hitimes.newHitimesError( getRuntime(), "Attempt to report a duration on an interval that has not started");
+        }
+
+        /*
+         * if stop has not yet been called, then return the amount of time so far
+         */
+        if ( INSTANT_NOT_SET == this.stop_instant ) {
+            double d = ( System.nanoTime() - this.start_instant ) / INSTANT_CONVERSION_FACTOR;
+            return getRuntime().newFloat( d );
+        }
+
+        /*
+         * if stop has been called, then calculate the duration and return
+         */
+        if ( DURATION_NOT_SET == this.duration ) {
+            this.duration = (this.stop_instant - this.start_instant) / INSTANT_CONVERSION_FACTOR;
+        }
+
+        return getRuntime().newFloat( this.duration );
+
+    }
+
+    @JRubyMethod( name = "duration_so_far" )
+    public IRubyObject duration_so_far() {
+        IRubyObject rc = getRuntime().getFalse();
+
+        if ( INSTANT_NOT_SET == this.start_instant ) {
+            return rc;
+        }
+
+        if ( INSTANT_NOT_SET == this.stop_instant ) {
+            double d = ( System.nanoTime() - this.start_instant ) / INSTANT_CONVERSION_FACTOR;
+            return getRuntime().newFloat( d );
+        }
+
+        return rc;
+    }
+
+    @JRubyMethod( name = "started?" )
+    public IRubyObject is_started() {
+        if ( INSTANT_NOT_SET == this.start_instant ) {
+            return getRuntime().getFalse();
+        }
+        return getRuntime().getTrue();
+    }
+
+    @JRubyMethod( name = "running?" )
+    public IRubyObject is_running() {
+        if ( ( INSTANT_NOT_SET != this.start_instant ) && ( INSTANT_NOT_SET == this.stop_instant ) ) {
+            return getRuntime().getTrue();
+        }
+        return getRuntime().getFalse();
+    }
+
+    @JRubyMethod( name = "stopped?" )
+    public IRubyObject is_stopped() {
+        if ( INSTANT_NOT_SET == this.stop_instant ) {
+            return getRuntime().getFalse();
+        }
+        return getRuntime().getTrue();
+    }
+
+    @JRubyMethod( name = "start_instant" )
+    public IRubyObject start_instant() {
+        return getRuntime().newFixnum( this.start_instant );
+    }
+
+    @JRubyMethod( name = "stop_instant" )
+    public IRubyObject stop_instant() {
+        return getRuntime().newFixnum( this.stop_instant );
+    }
+
+    @JRubyMethod( name = "start" )
+    public IRubyObject start() {
+        if ( INSTANT_NOT_SET == this.start_instant ) {
+            this.start_instant = System.nanoTime();
+            return getRuntime().getTrue();
+        }
+        return getRuntime().getFalse();
+    }
+
+    @JRubyMethod( name = "stop" )
+    public IRubyObject stop() {
+        if ( INSTANT_NOT_SET == this.start_instant ) {
+            throw Hitimes.newHitimesError( getRuntime(), "Attempt to stop an interval that has not started" );
+        }
+
+        if ( INSTANT_NOT_SET == this.stop_instant ) {
+            this.stop_instant = System.nanoTime();
+            this.duration = (this.stop_instant - this.start_instant) / INSTANT_CONVERSION_FACTOR;
+            return getRuntime().newFloat( this.duration );
+        }
+
+        return getRuntime().getFalse();
+    }
+
+    @JRubyMethod( name = "split" )
+    public IRubyObject split() {
+        this.stop();
+        return new HitimesInterval( getRuntime(), Hitimes.hitimesIntervalClass, this.stop_instant );
+    }
+
+    @JRubyMethod( name = "now", module = true )
+    public static IRubyObject now( IRubyObject self ) {
+        return new HitimesInterval( self.getRuntime(), Hitimes.hitimesIntervalClass, System.nanoTime() );
+    }
+
+    @JRubyMethod( name = "measure", module = true, frame = true )
+    public static IRubyObject measure( IRubyObject self, Block block ) {
+
+        Ruby runtime = self.getRuntime();
+
+        if ( block.isGiven() ) {
+            IRubyObject       nil = runtime.getNil();
+            ThreadContext context = runtime.getCurrentContext();
+
+            HitimesInterval interval = new HitimesInterval( runtime, Hitimes.hitimesIntervalClass );
+
+            interval.start();
+            block.yield( context, nil );
+            interval.stop();
+
+            return interval.duration();
+        } else {
+            throw Hitimes.newHitimesError( runtime, "No block given to Interval.measure" );
+        }
+    }
+}

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/ext/hitimes/java/src/hitimes/HitimesService.java

@@ -0,0 +1,16 @@
+package hitimes;
+
+import java.io.IOException;
+
+import org.jruby.Ruby;
+
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class HitimesService implements BasicLibraryService {
+    public boolean basicLoad( final Ruby runtime ) throws IOException {
+        Hitimes.createHitimes( runtime );
+        return true;
+    }
+}
+
+

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/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/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/lib/hitimes/metric.rb

@@ -0,0 +1,118 @@
+
+#--
+# 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
+  #
+  # All metrics hold the meta information of:
+  #
+  # * The name of the metric
+  # * The time of day the first measurement is taken
+  # * The time of day the last measurement is taken
+  # * additional data 
+  #
+  # Each derived class is assumed to set the sampling_start_time and
+  # sampling_stop_time appropriately.
+  # 
+  # Metric itself should generally not be used.  Only use the derived classes.
+  #
+  class Metric
+
+    # the number of seconds as a float since the sampling_start_time
+    attr_reader :sampling_delta
+
+    # An additional hash of data to associate with the metric
+    attr_reader :additional_data
+
+    # The 'name' to associate with the metric
+    attr_reader :name
+
+    #
+    # :call-seq:
+    #   Metric.new( 'my_metric' ) -> Metric
+    #   Metric.new( 'my_metric', 'foo' => 'bar', 'this' => 42 ) -> Metric
+    #
+    # Create a new ValueMetric giving it a name and additional data.
+    #
+    # +additional_data+ may be anything that follows the +to_hash+ protocol.
+    # +name+ may be anything that follows the +to_s+ protocol.
+    #
+    def initialize( name, additional_data = {} )
+      @sampling_start_time     = nil
+      @sampling_start_interval = nil
+      @sampling_delta          = 0
+
+      @name                = name.to_s
+      @additional_data     = additional_data.to_hash
+    end
+
+    #
+    # :call-seq: 
+    #   metric.sampling_start_time -> Float or nil
+    #
+    # The time at which the first sample was taken.
+    # This is the number of microseconds since UNIX epoch UTC as a Float
+    #
+    # If the metric has not started measuring then the start time is nil.
+    #
+    def sampling_start_time
+      if @sampling_start_interval then
+        @sampling_start_time ||= self.utc_microseconds()
+      else
+        nil
+      end
+    end
+
+    #
+    # :call-seq:
+    #   metric.sampling_stop_time -> Float or nil
+    #
+    # The time at which the last sample was taken
+    # This is the number of microseconds since UNIX epoch UTC as a Float
+    # 
+    # If the metric has not completely measured at least one thing then 
+    # stop time is nil.
+    #
+    # Because accessing the actual 'time of day' is an expesive operation, we
+    # only get the time of day at the beginning of the first measurement and we
+    # keep track of the offset from that point in @sampling_delta.
+    #
+    # When sampling_stop_time is called, the actual time of day is caculated.
+    #
+    def sampling_stop_time
+      if @sampling_delta > 0 then
+        (self.sampling_start_time + (@sampling_delta * 1_000_000))
+      else 
+        nil
+      end
+    end
+
+    #
+    # :call-seq:
+    #    metric.to_hash -> Hash
+    #    metric.to_hash
+    #
+    # Convert the metric to a Hash.  
+    #
+    def to_hash
+      { 'sampling_start_time' => self.sampling_start_time,
+        'sampling_stop_time'  => self.sampling_stop_time,
+        'additional_data'     => self.additional_data,
+        'name'                => self.name }
+    end
+
+    #
+    # :call-seq:
+    #   metric.utc_microseconds -> Float
+    #
+    # The current time in microseconds from the UNIX Epoch in the UTC
+    #
+    def utc_microseconds
+      Time.now.gmtime.to_f * 1_000_000
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/lib/hitimes/mutexed_stats.rb

@@ -0,0 +1,32 @@
+#--
+# Copyright (c) 2008, 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'thread'
+
+module Hitimes
+  #
+  # MutexedStats is the start of a threadsafe Stats class.  Currently, on MRI
+  # Ruby the Stats object is already threadsafe, so there is no need to use
+  # MutexedStats.
+  #
+  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/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/lib/hitimes/paths.rb

@@ -0,0 +1,53 @@
+#--
+# 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
+      @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 
+
+    # 
+    # :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/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/lib/hitimes/stats.rb

@@ -0,0 +1,58 @@
+#--
+# Copyright (c) 2008, 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'stringio'
+module Hitimes
+  class Stats
+    # A list of the available stats
+    STATS = %w[ count max mean min rate stddev sum sumsq ]
+
+    # 
+    # 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
+
+    #
+    # call-seq:
+    #   stat.to_json  -> String
+    #   stat.to_json( *args ) -> String
+    #
+    # return a json string of the stats.  By default this returns a json string
+    # of all the stats.  If an array of items is passed in, those that match the
+    # known stats will be all that is included in the json output.
+    #
+    def to_json( *args )
+      h = to_hash( *args )
+      a = []
+      s = StringIO.new
+
+      s.print "{ "
+      h.each_pair do |k,v|
+        a << "\"#{k}\": #{v}"
+      end
+      s.print a.join(", ")
+      s.print "}"
+      return s.string
+    end
+
+  end
+end