stella 0.5.3 → 0.5.4

data/vendor/frylock/lib/frylock.rb

@@ -0,0 +1,232 @@
+require 'optparse'
+require 'ostruct'
+require 'pp'
+
+require 'frylock/exceptions'
+
+module Frylock
+  class Command
+    attr_reader :cmd, :index
+    def initialize(cmd, index, &b)
+      @cmd = (cmd.kind_of?(Symbol)) ? cmd.to_s : cmd
+      @index = index
+      @b = b
+    end
+    
+    def call(cmd_str, argv, stdin, global_options, options)
+      block_args = [options, argv, global_options, stdin, cmd_str, self]
+      @b.call(*block_args[0..(@b.arity-1)])
+    end
+    def to_s
+      @cmd.to_s
+    end
+  end
+end
+
+module Frylock
+  extend self
+  
+  FORWARDED_METHODS = %w(command before alias_command global_option global_usage usage option stdin default commands).freeze
+  
+  def default(cmd)
+    @default_command = canonize(cmd)
+  end
+  
+  def stdin(&b)
+    @stdin_block = b
+  end
+  def before(&b)
+    @before_block = b
+  end
+  
+  # global_usage
+  # ex: usage "Usage: frylla [global options] command [command options]"
+  def global_usage(msg)
+    @global_opts_parser ||= OptionParser.new 
+    @global_options ||= OpenStruct.new
+  
+    @global_opts_parser.banner = msg
+  end
+  
+
+  
+  # process_arguments
+  #
+  # Split the +argv+ array into global args and command args and 
+  # find the command name. 
+  # i.e. ./script -H push -f (-H is a global arg, push is the command, -f is a command arg)
+  # returns [global_options, cmd, command_options, argv]
+  def process_arguments(argv)
+    global_options = command_options = {}
+    cmd = nil     
+    
+    global_parser = @global_opts_parser
+    
+    global_options = global_parser.getopts(argv)
+    global_options = global_options.keys.inject({}) do |hash, key|
+       hash[key.to_sym] = global_options[key]
+       hash
+    end
+    
+    cmd_name = (argv.empty?) ? @default_command : argv.shift
+    raise UnknownCommand.new(cmd_name) unless command?(cmd_name)
+    
+    cmd = get_command(cmd_name) 
+    command_parser = @command_opts_parser[cmd.index]
+    
+    command_options = command_parser.getopts(argv) if (!argv.empty? && command_parser)
+    command_options = command_options.keys.inject({}) do |hash, key|
+       hash[key.to_sym] = command_options[key]
+       hash
+    end
+    
+    [global_options, cmd_name, command_options, argv]
+  end
+  
+
+  
+  def usage(msg)
+    get_current_option_parser.banner = msg
+  end
+  
+  # get_current_option_parser
+  #
+  # Grab the options parser for the current command or create it if it doesn't exist.
+  def get_current_option_parser
+    @command_opts_parser ||= []
+    @command_index ||= 0
+    (@command_opts_parser[@command_index] ||= OptionParser.new)
+  end
+  
+  def global_option(*args, &b)
+    @global_opts_parser ||= OptionParser.new
+    args.unshift(@global_opts_parser)
+    option_parser(args, &b)
+  end
+  
+  def option(*args, &b)
+    args.unshift(get_current_option_parser)
+    option_parser(args, &b)
+  end
+  
+  # option_parser
+  #
+  # Processes calls to option and global_option. Symbols are converted into 
+  # OptionParser style strings (:h and :help become '-h' and '--help'). If a 
+  # class is included, it will tell OptionParser to expect a value otherwise
+  # it assumes a boolean value.
+  #
+  # +args+ is passed directly to OptionParser.on so it can contain anything
+  # that's valid to that method. Some examples:
+  # [:h, :help, "Displays this message"]
+  # [:m, :max, Integer, "Maximum threshold"]
+  # ['-l x,y,z', '--lang=x,y,z', Array, "Requested languages"]
+  def option_parser(args=[], &b)
+    return if args.empty?
+    opts_parser = args.shift
+    
+    symbol_switches = []
+    args.each_with_index do |arg, index|
+      if arg.is_a? Symbol
+        args[index] = (arg.to_s.length == 1) ? "-#{arg.to_s}" : "--#{arg.to_s}"
+        symbol_switches << args[index]
+      elsif arg.kind_of?(Class)
+        symbol_switches.each do |arg|
+          arg << "=S"
+        end
+      end
+    end
+    
+    if args.size == 1
+      opts_parser.on(args.shift)
+    else
+      opts_parser.on(*args) do |v|
+        block_args = [v, opts_parser]
+        result = (b.nil?) ? v : b.call(*block_args[0..(b.arity-1)])
+      end
+    end
+  end
+  
+  def command(*cmds, &b)
+    @command_index ||= 0
+    @command_opts_parser ||= []
+    cmds.each do |cmd| 
+      c = Command.new(cmd, @command_index, &b)
+      (@commands ||= {})[cmd] = c
+    end
+    
+    @command_index += 1
+  end
+  
+  def alias_command(aliaz, cmd)
+    return unless @commands.has_key? cmd
+    @commands[aliaz] = @commands[cmd]
+  end
+  
+  def run!(argv, stdin=nil)
+    raise NoCommandsDefined.new unless @commands
+    @global_options, cmd_name, @command_options, argv = process_arguments(argv)
+    
+    cmd_name ||= @default_command
+    
+    raise UnknownCommand.new(cmd_name) unless command?(cmd_name)
+    
+    stdin = (defined? @stdin_block) ? @stdin_block.call(stdin, []) : stdin
+    @before_block.call if defined? @before_block
+    
+    
+    call_command(cmd_name, argv, stdin)
+    
+    
+  rescue OptionParser::InvalidOption => ex
+    raise Frylock::InvalidArgument.new(ex.args)
+  rescue OptionParser::MissingArgument => ex
+    raise Frylock::MissingArgument.new(ex.args)
+  end
+  
+  
+  def call_command(cmd_str, argv=[], stdin=nil)
+    return unless command?(cmd_str)
+    get_command(cmd_str).call(cmd_str, argv, stdin, @global_options, @command_options)
+  end
+  
+  def get_command(cmd)
+    return unless command?(cmd)
+    @commands[canonize(cmd)]
+  end 
+  
+  def commands
+    @commands
+  end
+  
+  def run
+    @run || true
+  end
+  
+  def run=(v)
+    @run = v
+  end
+  
+  def command?(cmd)
+    name = canonize(cmd)
+    (@commands || {}).has_key? name
+  end
+  def canonize(cmd)
+    return unless cmd
+    return cmd if cmd.kind_of?(Symbol)
+    cmd.tr('-', '_').to_sym
+  end
+  
+end
+
+Frylock::FORWARDED_METHODS.each do |m|
+  eval(<<-end_eval, binding, "(Frylock)", __LINE__)
+    def #{m}(*args, &b)
+      Frylock.#{m}(*args, &b)
+    end
+  end_eval
+end
+
+
+
+  

data/vendor/frylock/test/command_test.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + "/../lib/frylock"
+require "rubygems"
+require "test/spec"
+require "mocha"
+
+class Test::Unit::TestCase
+  def test_command(cmd, argv, &b)
+    Frylock::Command.new(cmd, &b).call(argv)
+  end
+end
+
+Frylock.run = false
+
+context "command" do
+  
+  setup { @mock = mock() }
+  
+  specify "should know a symbol is the full command name" do
+    @mock.expects(:called).with()
+    test_command(:foo, ['foo']) { @mock.called }
+  end
+  
+  specify "should know only send params needed by block" do
+    @mock.expects(:called).with('bar')
+    test_command(:foo, ['foo', 'bar']) { |a| @mock.called(a) }
+  end
+
+  specify "should know only send params needed by block 2" do
+    @mock.expects(:called).with('bar', 'baz')
+    test_command(:foo, ['foo', 'bar', 'baz']) { |a,b| @mock.called(a,b) }
+  end
+  
+end

data/vendor/hitimes-0.4.0/HISTORY

@@ -0,0 +1,28 @@
+= Changelog
+== Version 0.4.0 2008-12-20
+
+* Added new stat 'rate'
+* Added new stat method to_hash
+* Added MutexedStats class for threadsafe stats collection 
+  - not needed when used in MRI 1.8.x
+* remove stale dependency on mkrf
+
+== Version 0.3.0
+
+* switched to extconf for building extensions
+* first release of windows binary gem
+* reverted back to normal rdoc
+
+== Version 0.2.1
+
+* added Timer#rate method
+* switched to darkfish rdoc
+
+== Version 0.2.0
+
+* Performance improvements
+* Added Stats class
+
+== Version 0.1.0
+
+* Initial completion

data/vendor/hitimes-0.4.0/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Jeremy Hinegardner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/vendor/hitimes-0.4.0/README

@@ -0,0 +1,80 @@
+== hitimes
+
+* Homepage[http://copiousfreetime.rubyforge.org/hitimes] 
+* {Rubyforge project}[http://rubyforge.org/projects/copiousfreetime/]
+* email jeremy at copiousfreetime dot org
+* git clone url git://github.com/copiousfreetime/hitimes.git
+
+== INSTALL
+
+* gem install hitimes
+
+== DESCRIPTION
+
+Hitimes is a fast, high resolution timer library for recording
+performance metrics.  It uses the appropriate C method calls for each
+system to get the highest granularity time increments possible.  
+
+It currently supports any system with the POSIX call clock_gettime(),
+Mac OS X and Windows.
+
+Using Hitimes can be faster than using a series of Time.new calls, and
+it will have a much higher granularity.   It is definitely faster than
+using Process.times. 
+
+== SYNOPSIS
+
+Use Hitimes::Interval to calculate only the duration of a block of code
+
+  duration = Hitimes::Interval.measure do
+               # some operation ...
+             end
+
+  puts duration   
+
+Use a Hitimes::Timer to calculate statistics about an iterative operation
+
+  timer = Hitimes::Timer.new
+  collection.each do |item|
+    timer.start
+    # .. do something with item
+    timer.stop
+  end
+
+  puts timer.mean
+  puts timer.median
+  puts timer.max
+  puts timer.min
+  puts timer.stddev
+  puts timer.rate
+
+
+== CHANGES
+
+Read the HISTORY file.
+
+== CREDITS
+
+* Bruce Williams for suggesting the idea
+
+== MIT LICENSE
+
+Copyright (c) 2008 Jeremy Hinegardner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/vendor/hitimes-0.4.0/Rakefile

@@ -0,0 +1,63 @@
+#--
+# Copyright (c) 2008 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+#-------------------------------------------------------------------------------
+# make sure our project's top level directory and the lib directory are added to
+# the ruby search path.
+#-------------------------------------------------------------------------------
+$: << File.expand_path(File.join(File.dirname(__FILE__),"ext"))
+$: << File.expand_path(File.join(File.dirname(__FILE__),"lib"))
+$: << File.expand_path(File.dirname(__FILE__))
+
+
+#-------------------------------------------------------------------------------
+# load the global project configuration and add in the top level clean and
+# clobber tasks so that other tasks can utilize those constants if necessary
+# This loads up the defaults for the whole project configuration
+#-------------------------------------------------------------------------------
+require 'rubygems'
+require 'tasks/config.rb'
+require 'rake/clean'
+
+#-------------------------------------------------------------------------------
+# Main configuration for the project, these overwrite the items that are in
+# tasks/config.rb
+#-------------------------------------------------------------------------------
+require 'hitimes/version'
+require 'hitimes/paths'
+
+Configuration.for("project") {
+  name      "hitimes"
+  version   Hitimes::VERSION
+  author    "Jeremy Hinegardner"
+  email     "jeremy@copiousfreetime.org"
+  homepage  "http://copiousfreetime.rubyforge.org/hitimes/"
+}
+
+#-------------------------------------------------------------------------------
+# load up all the project tasks and setup the default task to be the
+# test:default task.
+#-------------------------------------------------------------------------------
+Configuration.for("packaging").files.tasks.each do |tasklib|
+  import tasklib
+end
+task :default => 'test:default'
+
+#-------------------------------------------------------------------------------
+# Finalize the loading of all pending imports and update the top level clobber
+# task to depend on all possible sub-level tasks that have a name like
+# ':clobber'  in other namespaces.  This allows us to say:
+#
+#   rake clobber
+#
+# and it will get everything.
+#-------------------------------------------------------------------------------
+Rake.application.load_imports
+Rake.application.tasks.each do |t| 
+  if t.name =~ /:clobber/ then
+    task :clobber => [t.name] 
+  end 
+end
+

data/vendor/hitimes-0.4.0/examples/benchmarks.rb

@@ -0,0 +1,86 @@
+require 'benchmark'
+require 'time'
+
+#
+# this is all here in case this example is run from the examples directory
+#
+begin
+  require 'hitimes'
+rescue LoadError => le
+  ext_path = File.expand_path( File.join( File.dirname( __FILE__ ), "..", "ext" ) )
+  lib_path = File.expand_path( File.join( File.dirname( __FILE__ ), "..", "lib" ) )
+  if $:.include?( ext_path ) then
+    raise le
+  end
+  $: << ext_path
+  $: << lib_path
+  retry
+end
+
+#----------------------------------------------------------------------
+# test program to look at the performance sampling time durations using
+# different methods
+#----------------------------------------------------------------------
+
+include Benchmark
+
+#
+# Normal apprach to Interval usage
+#
+def hitimes_duration_i1
+  i = Hitimes::Interval.new
+  i.start
+  i.stop
+end
+
+#
+# Use the easy access method to start stop an interval
+#
+def hitimes_duration_i2
+  Hitimes::Interval.now.stop
+end
+
+#
+# Use a new timer each time
+#
+def hitimes_duration_t1
+  Hitimes::Timer.now.stop
+end
+
+#
+# reuse the same timer over and over
+#
+HT = Hitimes::Timer.new
+def hitimes_duration_t2
+  HT.start
+  HT.stop
+end
+
+#
+# use the Struct::Tms values and return  the difference in User time between 2 
+# successive calls
+#
+def process_duration
+  t1 = Process.times.utime
+  Process.times.utime - t1
+end
+
+#
+# Take 2 times and subtract one from the other
+#
+def time_duration
+  t1 = Time.now.to_f
+  Time.now.to_f - t1
+end
+  
+
+puts "Testing time sampling 100,000 times"
+
+bm(20) do |x|
+  x.report("Process")              { 100_000.times { process_duration } }
+  x.report("Time")                 { 100_000.times { time_duration    } }
+  x.report("Hitimes::Timer 1")     { 100_000.times { hitimes_duration_t1 } }
+  x.report("Hitimes::Timer 2")     { 100_000.times { hitimes_duration_t2 } }
+  x.report("Hitimes::Interval 1")  { 100_000.times { hitimes_duration_i1 } }
+  x.report("Hitimes::Interval 2")  { 100_000.times { hitimes_duration_i2 } }
+end

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

@@ -0,0 +1,29 @@
+#
+# this is all here in case this example is run from the examples directory
+#
+begin
+  require 'hitimes'
+rescue LoadError => le
+  %w[ ext lib ].each do |p|
+    path = File.expand_path( File.join( File.dirname( __FILE__ ), "..", p ) )
+    if $:.include?( path ) then
+      raise le
+    end
+    $: << path
+  end
+  retry
+end
+
+s = Hitimes::Stats.new
+dir = ARGV.shift || Dir.pwd
+Dir.entries( dir ).each do |entry|
+  fs = File.stat( entry )
+  if fs.file? then
+    s.update( fs.size )
+  end
+end
+
+%w[ count min max mean sum stddev ].each do |m|
+  puts "#{m.rjust(6)} : #{s.send( m ) }"
+end
+

data/vendor/hitimes-0.4.0/ext/extconf.rb

@@ -0,0 +1,15 @@
+require 'rbconfig'
+require 'mkmf'
+
+if Config::CONFIG['host_os'] =~ /darwin/ then
+  $CFLAGS += " -DUSE_INSTANT_OSX=1 -Wall"
+  $LDFLAGS += " -framework CoreServices"
+elsif Config::CONFIG['host_os'] =~ /win32/ or Config::CONFIG['host_os'] =~ /mingw/ then
+  $CFLAGS += " -DUSE_INSTANT_WINDOWS=1"
+else
+  if have_library("rt", "clock_gettime") then
+    $CFLAGS += " -DUSE_INSTANT_CLOCK_GETTIME=1"
+  end
+end
+
+create_makefile('hitimes_ext')

data/vendor/hitimes-0.4.0/ext/hitimes_ext.c

@@ -0,0 +1,21 @@
+#include <ruby.h>
+#include "hitimes_interval.h"
+
+/* Module and Classes */
+VALUE mH;           /* module Hitimes            */
+VALUE eH_Error;     /* class  Hitimes::Error     */
+
+/*
+ * Document-class: Hitimes::Error
+ *
+ * General error class for the Hitimes module
+ */
+void Init_hitimes_ext( )
+{
+    mH = rb_define_module("Hitimes");
+     
+    eH_Error = rb_define_class_under(mH, "Error", rb_eStandardError);
+
+    Init_hitimes_interval();
+    Init_hitimes_stats( );
+}

data/vendor/hitimes-0.4.0/ext/hitimes_instant_clock_gettime.c

@@ -0,0 +1,20 @@
+#ifdef USE_INSTANT_CLOCK_GETTIME
+
+#include "hitimes_interval.h"
+
+#include <sys/time.h>
+
+hitimes_instant_t hitimes_get_current_instant( )
+{
+    struct timespec time;
+    int rc;
+
+    rc = clock_gettime( CLOCK_MONOTONIC, &time);
+    if ( 0 != rc )  {
+        char* e = strerror( rc );
+        rb_raise(eH_Error, "Unable to retrieve time for CLOCK_MONOTONIC :  %s", e );
+    }
+
+    return ( ( NANOSECONDS_PER_SECOND * (long)time.tv_sec ) + time.tv_nsec );
+}
+#endif

data/vendor/hitimes-0.4.0/ext/hitimes_instant_osx.c

@@ -0,0 +1,16 @@
+#ifdef USE_INSTANT_OSX
+
+#include "hitimes_interval.h"
+#include <CoreServices/CoreServices.h>
+
+/* 
+ * returns the number of nanoseconds since the machine was booted
+ */
+hitimes_instant_t hitimes_get_current_instant( )
+{
+    Nanoseconds  nano    = AbsoluteToNanoseconds( UpTime() );
+
+    return *( hitimes_instant_t *)&nano;
+}
+
+#endif

data/vendor/hitimes-0.4.0/ext/hitimes_instant_windows.c

@@ -0,0 +1,27 @@
+#ifdef USE_INSTANT_WINDOWS
+
+#include "hitimes_interval.h"
+
+
+/*
+ * returns the conversion factor, this value is used to convert
+ * the value from hitimes_get_current_instant() into seconds
+ */
+double hitimes_instant_conversion_factor()
+{
+    LARGE_INTEGER ticks_per_second;
+    QueryPerformanceFrequency( &ticks_per_second );
+    return (double)ticks_per_second.QuadPart;
+}
+
+/*
+ * returns the number of ticks
+ */
+hitimes_instant_t hitimes_get_current_instant()
+{
+    LARGE_INTEGER tick;
+    QueryPerformanceCounter(&tick);
+    return (hitimes_instant_t)tick.QuadPart;
+}
+
+#endif