carats 0.3.0

data/lib/carat/timer.rb

@@ -0,0 +1,99 @@
+=begin rdoc
+  
+= Timer, with #timed
+
+Timer class. Also provides a block method for running a timed procedure.
+
+== Usage
+
+  require 'carat/timer'
+
+  timed { |timer|
+
+     timer.total_time.round #=> 0
+
+     sleep 1
+     timer.total_time.round #=> 1
+
+     timer.stop
+     timer.total_time.round #=> 1
+
+     sleep 2
+     timer.total_time.round #=> 1
+
+     timer.start
+     timer.total_time.round #=> 1
+
+     sleep 1
+     timer.total_time.round #=> 2
+
+  }
+
+== Notes
+
+I would like to take this and meger it with TimeLimit in some manner.
+
+== Author
+
+* Paul Brannan <paul@atdesk.com>
+
+== Legal
+
+Adapted from Ruby Treasures 0.4
+Copyright (C) 2002 Paul Brannan <paul@atdesk.com>
+
+You may distribute this software under the same terms as Ruby (see the file
+COPYING that was distributed with this library).
+  
+=end
+
+class Timer
+  attr_reader :start_time
+  attr_reader :end_time
+
+  def initialize
+    @start_time = nil
+    @end_time = nil
+    @total_time = 0
+    @runnning = nil
+    start
+  end
+
+  def start
+    @start_time = Time.now
+    @running = true
+  end
+
+  def stop
+    @end_time = Time.now
+    @total_time += @end_time - @start_time
+    @running = false
+  end
+
+  def running?
+    return @running
+  end
+
+  def stopped?
+    return !@running
+  end
+
+  def total_time
+    if running? then
+      return @total_time + (Time.now - @start_time)
+    else
+      return @total_time
+    end
+  end
+  
+end
+
+# Takes a block and returns the total time it
+# took to execute.
+module Kernel
+  def timed
+    timer = Timer.new
+    yield(timer)
+    return timer.total_time
+  end
+end

data/lib/carat/tracepoint.rb

@@ -0,0 +1,154 @@
+=begin rdoc
+
+= TracePoint
+
+A TracePoint is a CodePoint (i.e. a Binding) with the addition of event information.
+It functions very well as the join-point for Event-based AOP.
+
+== Usage
+
+  require 'raspberry/tracepoint'
+
+  TracePoint.trace { |tp|
+    puts "#{tp.self.class}\t#{tp.called}\t#{tp.event}\t#{tp.return?}\t#{tp.back == tp.bind}"
+  }
+
+  1 + 1
+    
+produces
+  
+  Class   trace   return     true    false
+  Object          line       false   false
+  Fixnum  +       c-call     false   false
+  Fixnum  +       c-return   false   false
+
+== Version
+
+  0.2.0
+  
+=end
+
+require 'facet/binding'
+
+# This is the same as a Binding. Not really needed, but I like consistency :)
+CodePoint = Binding
+
+# You can't subclass Binding, so we delegate (which is better anyway).
+class TracePoint  #< CodePoint
+  
+  # -- class ---------------------
+  class << self
+  
+    @@active = false
+  
+    def active ; @@active ; end
+    
+    def active=(x)
+      @@active = x ? true : false
+      unless @@active
+        set_trace_func nil
+      end
+    end
+  
+    # Trace execution using a TracePoint.
+    def trace # :yield:
+      if active
+        bb_stack = []
+        set_trace_func proc{ |e, f, l, m, b, k|
+          #(p e, f, l, m, b, k, @@bb_stack; puts "---") if $DEBUG
+          if ['call','c-call','class'].include?(e)
+            bb_stack << b
+          elsif ['return','c-return','end'].include?(e)
+            bb = bb_stack.pop
+          end
+          b = bb if ! b    # this sucks!
+          tp = TracePoint.new(e,m,b,bb)
+          yield(tp)
+        }
+      end
+    end
+    
+  end #class
+  
+  # -- instance -------------------
+  
+  attr_accessor :event, :binding, :back_binding
+
+  # Until Ruby has a built-in way to get the name of the calling method
+  # that information must be passed into the TracePoint.
+  def initialize( event, method, bind, back_binding=bind )
+    @event = event
+    @method = method
+    @binding = bind
+    @back_binding = back_binding
+  end
+
+  # shorthand for binding
+  def bind ; @binding ; end
+  
+  # shorthand for back_binding
+  def back ; @back_binding ; end
+  
+  # Delegates "self" to the binding which
+  # in turn delegates the binding object.
+  def self ; @binding.self ; end
+
+  # Returns the name of the event's method.
+  # This could delegate to the binding if Ruby had 
+  # an internal way to retrieve the current method name.
+  def called ; @method ; end
+  alias_method( :method_name, :called )
+  alias_method( :me, :called )
+  
+  # delegate to binding
+  #def method_missing(meth, *args, &blk)
+  #  @binding.send(meth, *args, &blk)
+  #end
+  
+  ### methods for working with events
+
+  EVENT_MAP = {
+    :all     => ['call', 'c-call', 'return', 'c-return', 'line', 'class', 'end', 'raise'],
+    :before  => ['call', 'c-call'],
+    :after   => ['return', 'c-return'],
+    :call    => ['call'],
+    :return  => ['return'],
+    :ccall   => ['c-call'],
+    :creturn => ['c-return'],
+    :line    => ['line'],
+    :class   => ['class'],
+    :end     => ['end'],
+    :raise   => ['raise']
+  }
+  def event_map(e) ; EVENT_MAP[e] ; end
+  
+  # Is the trace point defined or undefined?
+  def event? ; !! @event ; end
+  def eventless? ; ! @event ; end
+    
+  # For use in case conditions
+  def ===(e)
+    EVENT_MAP[e].include?(@event)
+  end
+  
+  # Creates an <event>? method for each of the above event mappings.
+  EVENT_MAP.each_pair { |m,v|
+    define_method( "#{m}?" ){ v.include?(@event) }
+  }
+
+end
+
+
+# --- test ---
+
+if $0 == __FILE__
+
+  TracePoint.active = true
+
+  TracePoint.trace { |tp|
+    puts "#{tp.self.class}\t#{tp.called}\t#{tp.event}\t#{tp.return?}\t#{tp.back == tp.bind}"
+  }
+
+  1 + 1
+
+end

data/lib/carat/tuple.rb

@@ -0,0 +1,31 @@
+=begin rdoc
+
+= Tuple
+
+A Tuple is essentially an Array that is also Comaparable.
+
+== Usage
+  
+  t1 = Tuple.new(1,2,3)
+  t2 = Tuple.new(2,3,4)
+  
+  t1 > t2   #=> false
+  t2 > t1   #=> true
+
+== Note
+
+This class probably needs some enhancements to 
+be truly considered a Tuple. For instance, should
+a Tuple by multiton?
+
+=end
+
+class Tuple < Array
+  include Comparable
+  
+  def initialize(*args)
+    super()
+    self.concat args
+  end
+  
+end

data/lib/carat/uninheritable.rb

@@ -0,0 +1,68 @@
+#:title: Module Uninheritable
+#--
+# Uninheritable
+# Version 1.2.0
+#
+# Copyright (c) 2003 Austin Ziegler
+#
+# $Id: uninheritable.rb,v 1.2 2003/09/18 03:10:10 austin Exp $
+#
+# ==========================================================================
+# Revision History ::
+# YYYY.MM.DD  Developer       Description
+# --------------------------------------------------------------------------
+# 2003.09.17  Austin Ziegler  Minor modifications to documentation.
+# ==========================================================================
+#++
+
+# = Introduction
+#
+# Allows an object to declare itself as unable to be subclassed. The
+# technique behind this is very simple (redefinition of #inherited), so this
+# just provides an easier way to do the same thing with a consistent error
+# message.
+#
+# == Usage
+#
+#   require 'uninheritable'
+#
+#   class A
+#     extend Uninheritable
+#   end
+#
+#   class B < A; end # => raises TypeError
+#
+# == Info
+#
+# Copyright:: Copyright (c) 2003 Austin Ziegler
+# Licence::   MIT-Style
+# Version::   1.2.0
+#
+# == Licence
+#
+# 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.
+#
+module Uninheritable
+  VERSION = "1.2.0"
+  # Redefines a class's #inherited definition to prevent subclassing of the
+  # class extended by this module.
+  def inherited(klass)
+    raise TypeError, "Class #{self} cannot be subclassed."
+  end
+end

data/lib/carat/version.rb

@@ -0,0 +1,147 @@
+=begin rdoc
+
+= Version
+
+A class for manipulating and storing conventional version numbers
+in the form of "1.0.0".
+
+== Usage
+
+  VERSION = Version("1.2.3")  # same as Version.new()
+  
+  VERSION.major               #=> 1
+  VERSION.minor               #=> 2
+  VERSION.teeny               #=> 3
+
+  VERSION.teeny += 1          #=> 4
+  
+  VERSION > Version(1,2,3)    #=> true
+  VERSION > Version("1.2.4")  #=> false
+
+== Author(s)
+
+* Minero Aoki
+* Thomas Sawyer
+
+== License
+
+Based on original by Minero Aoki.
+GPL Copyright (c) 2000-2001 Minero Aoki <aamine at loveruby.net>
+GPL Copyright (c) 2004-2005 Thomas Sawyer <tranfire at gmail.com>
+
+This program is free software.
+You can distribute/modify this program under the terms of
+the GNU Lesser General Public License version 2 or later.
+
+=end
+
+
+class Version
+
+  VERSION_EXP = /\d+(?:\.\d+)*/
+
+  def self.[](*args)
+    Version.new(*args)
+  end
+
+  include Comparable
+
+  def initialize( arg, *nums )
+    set( arg, *nums )
+  end
+
+  def set( arg, *nums )
+    if String === arg then
+      unless m = VERSION_EXP.match( arg ) then
+        raise ArgumentError, "wrong version string format '#{arg}'"
+      end
+      @num = m[0].split('.').collect {|i| i.to_i }
+    else
+      @num = [ arg, *(nums || []) ]
+      #@num.unshift arg
+    end
+  end
+  
+  def dup
+    self.class.new( *@nums )
+  end
+
+  def ==( other )
+    @num == other.to_a
+  end
+  alias_method( :eql?, :== )
+
+  def hash ; @num.hash ; end
+
+  def to_s ; @num.join '.' ; end
+  def to_a ; @num.dup ; end
+
+  def inspect
+    "\#<#{self.class} #{to_s}>"
+  end
+
+  def major       ; @num[0]     ; end
+  def major=( i ) ; @num[0] = i ; end
+
+  def minor       ; @num[1]     ; end
+  def minor=( i ) ; @num[1] = i ; end
+
+  def teeny       ; @num[2]     ; end
+  def teeny=( i ) ; @num[2] = i ; end
+
+  def weeny       ; @num[3]     ; end
+  def weeny=( i ) ; @num[3] = i ; end
+    
+  def next_major!    
+    (1..last_index).each{ |i| @num[i] = 0 } if last_index > 0
+    @num[0] += 1
+  end
+  
+  def next_minor!
+    (2..last_index).each{ |i| @num[i] = 0 } if last_index > 1
+    if @num[1]
+      @num[1] += 1
+    end
+  end
+  
+  def next_teeny!
+    (3..last_index).each{ |i| @num[i] = 0 } if last_index > 2
+    if @num[2]
+      @num[2] += 1
+    end
+  end
+
+  def next_weeny!
+    #(4..last_index).each{ |i| @num[i] = 0 } if last_index > 3
+    if @num[3]
+      @num[3] += 1
+    end
+  end
+
+  def type
+    case last_index
+    when 0 then :major
+    when 1 then :minor
+    when 2 then :teeny
+    when 3 then :weeny
+    end
+  end
+  
+  def <=>( other )
+    return false unless self.class === other
+    n = @num
+    ret = nil; other.instance_eval { ret = (n <=> @num) }
+    ret
+  end 
+  
+  private
+  
+  def last_index
+    @num.length - 1
+  end
+  
+end
+
+# not really the ruby way
+#def Version(*args) ; Version.new(*args) ; end
+