carats 0.3.0

data/lib/carat-dev/range.rb

@@ -0,0 +1,259 @@
+=begin rdoc
+
+= Descrete Range Class
+
+This is the Range class slightly modified to be truly desecrete in nature.
+Use the Interval class (see interval.rb) for a truly continuious range class.
+
+== Synopsis
+
+The following code uses class +Xs+, which is defined in the
+class-level documentation.
+
+  require 'trix/range'
+
+  range = Xs.new(1)..Xs.new(10)
+  range.step(2) {|x| puts x}
+  range.step(3) {|x| puts x}
+  
+_produces:_
+
+  1 x
+  3 xxx
+  5 xxxxx
+  7 xxxxxxx
+  9 xxxxxxxxx
+  1 x
+  4 xxxx
+  7 xxxxxxx
+  10 xxxxxxxxxx
+
+== Notes
+
+Range is not quite have descrete behavior becasue it also performs 
+double-duty as a continious interval class. Its just a bit too overloaded
+and this limits its full potential. To remedy, a separate Interval class
+has been created to handle true interval functionality. And here we 
+adjust Range to be truely discrete.
+ 
+Range originally dependened on two methods: #succ and #<=>. If numeric
+ranges were the only concern, those could just as well be #+ and #<=>,
+but esoteric forms make that unfeasible --the obvious example being a 
+String range. To properly handle this, Range fully seperates and extends
+the parallel methods: #succ for #+, #cmp for #<=> ( in the future we may
+add #pred for #- ). It also adds the option of #distance to properly
+calculate the difference between the sentinals. This is neccessary
+to ensure congruent bahavior. For instance, presently String Range's
+can give bad results because #<=> does not measure order in the same
+manner that #succ generates order.
+
+== Todo List
+
+* Add skip parameter, to allow skip-ranges, i.e. skipping successive iterations.
+
+== Author
+
+* Thomas Sawyer
+
+=end
+
+require 'carat/infinity'
+require 'carat/interval'
+
+
+class Range
+
+  alias_method :initialize_simple, :initialize
+  private :initialize_simple
+
+  def initialize( first, halt, exclude_last=false, &succ )
+    @first = first
+    @last = halt.kind_of?(Proc) ? nil : halt
+    @halt = @last ? nil : halt
+    #@exclude_first = exclude_first
+    @exclude_last = exclude_last
+    @direction = (@last <=> @first)
+    #@direction = 1 if @direction == 0
+    @succ = succ || nil #@first.method(:succ).to_proc
+    #@halt = nil #exclude_last? ? proc{ |x| x.cmp(@last) != -1 } : proc{ |x| x.cmp(@last) == 1 }
+    initialize_simple(@first, @last, @exclude_last)
+  end
+
+  def succ ; @succ ; end
+  
+  def succ!(s)
+   if @succ
+     @succ.call(s)
+   else
+     s.succ
+   end
+  end
+  
+  def succ=(succ_proc)
+    raise ArgumentError unless Proc === succ_proc
+    @succ = succ_proc
+  end
+  
+  def halt ; @halt ; end
+  
+  def halt?(s)
+    if @halt
+      @halt.call(s)
+    else
+     if @exclude_last
+       s.cmp(@last) != -1
+     else
+       s.cmp(@last) == 1
+     end
+    end
+  end
+  
+  def halt=(halt_proc)
+    raise ArgumentError unless Proc === halt_proc
+    @halt = halt_proc
+  end
+  
+  #def first ; @first ; end
+  #def last ; @last ; end    
+  #def exclude_first? ; @exclude_first ; end
+  #def exclude_last? ; @exclude_last ; end
+  alias exclude_last? exclude_end?
+  
+  def direction
+   @direction ||= (@last <=> @first)
+  end
+  
+  # poor names
+  #undef_method :begin
+  #undef_method :end
+  #undef_method :exclude_end?
+  
+  def -@ ;  Range.new( @first, @last, true, &@succ ) ; end
+  
+  def distance
+    return @last.distance(@first) if @last and @last.respond_to?(:distance)
+    self.to_a.length # should it just be nil instead?
+  end
+  alias_method( :length, :distance )
+  alias_method( :size, :distance )
+      
+  def min
+    (@first.cmp(@last) == -1) ? @first : @last
+  end
+  
+  def max
+    (@first.cmp(@last) == 1) ? @first : @last
+  end
+  
+  # +between?+ simply tests whether the given value falls
+  # between the sentinels by comparison. It does not 
+  # verify that the value is acutally in the range's sequence.
+  def between?(x)
+    #tf = exclude_first? ? 1 : 0
+    tl = exclude_last? ? -1 : 0
+    # if other classes handled Infinity in their <=> method
+    # (which probably they should) this clause would not be required
+    if first.kind_of?(InfinityClass)
+      ft = ((first <=> x) <= tf)
+    else
+      ft = (x <=> first) >= tf
+    end
+    if last.kind_of?(InfinityClass)
+      fl = ((last <=> x) >= tl)
+    else
+      fl = (x <=> last) <= tl
+    end
+    ft && fl
+  end
+  
+  # Is this proper alias of +===+?
+  alias_method( :===, :between? )
+  
+  # +include?+ is an alias for +member?+. It is like between
+  # but makes sure that the value is in the range sequence.
+  alias_method( :include?, :member? )
+
+  # Compares two ranges to see if they are equal
+  def eql?(other)
+    return false unless @first == other.first
+    other_last = other.exclude_last? ? other.last : other.last
+    if self.exclude_last? and not other.exclude_last?
+      return false unless self.last == other.last.succ
+    elsif other.exclude_last? and not self.exclude_last?
+      return false unless self.last.succ == other.last
+    else
+      return false unless @last == other.last
+    end
+    true
+  end
+
+  alias each_succ each
+  def each( &blk )
+    return each_succ( &blk ) unless @succ or @halt
+    if @halt
+      halt_proc = @halt
+    else
+      halt_proc = exclude_last? ? proc{ |x| x.cmp(@last) != -1 } : proc{ |x| x.cmp(@last) == 1 }
+    end   
+    #t = exclude_last? ? -1 : 0
+    s = @first
+    if @succ
+      #while (s <=> @last) == -1 or (s <=> @last) == t
+      until halt_proc.call(s)
+        yield(s)
+        @succ.call(s)
+      end
+    else
+      #while (s <=> @last) == -1 or (s <=> @last) == t
+      until halt_proc.call(s)
+        yield(s)
+        s.succ
+      end      
+    end
+  end
+  
+#   # each(n) where n is steps, if n is negative it is nth
+#   # I know, it's a neg num trick :( but I think it's
+#   # better then having another method like #each_nth,
+#   # cause then you'd need #to_a_nth, too, etc.
+#   def each(n=1)  # :yield:
+#     n = (length / n.abs) if n < 0
+#     n = n * direction
+#     i = first; i.succ(n) if exclude_first?
+#     t = exclude_last? ? -1 : 0
+#     while (i <=> last) == -1 or (i <=> last) == t
+#       yield(i)
+#       i.succ(n)
+#     end
+#   end
+    
+#   # each(n) where n is steps, if n is negative it is nth
+#   # I know, it's a neg num trick :( but I think it's
+#   # better then having another method like #each_nth,
+#   # cause then you'd need #to_a_nth, too, etc.
+#   def reverse_each(n=1)  # :yield:
+#     n = (length / n.abs) if n < 0
+#     n = n * direction
+#     i = last; i -= n if exclude_first?
+#     t = exclude_first? ? 1 : 0
+#     while (i <=> first) == 1 or (i <=> first) == t
+#       yield(i)
+#       i += n
+#     end
+#   end
+    
+#   def to_a(n=1)
+#     a=[]; each(n){|e| a << e}
+#     a
+#   end
+    
+    # Is this even desirable at this point?
+    # Sequences depend on #succ rather then #+
+    # so don't expect the same results from each!
+  # def to_seq
+  #   seed = exclude_first? ? first.succ : first
+  #   halt = exclude_last? ? proc{|x| (x <=> last) >= 0} : proc{|x| (x <=> last) > 0}
+  #   Sequence.new( seed, &halt )
+  # end
+    
+end

data/lib/carat-dev/system/rubyinfo.rb

@@ -0,0 +1,75 @@
+=begin
+
+  = RubyInfo
+  
+  Constants pertaining to Ruby itself.
+  
+  == Authors
+  
+  * Minero Aoki
+  * T. Onoma
+  
+  == Legal
+  
+  Adapted from RubyParams module by Minero Aoki
+  Copyright (c) 1999-2002 Minero Aoki <aamine@loveruby.net>
+
+  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.
+  
+  == Version
+  
+    $Id: rubyloader.rb,v 1.3 2002/01/05 06:19:34 aamine Exp $
+
+=end
+
+require 'rbconfig'
+
+module RubyInfo
+
+  CONFIG     = Config::CONFIG
+
+  PLATFROM = RUBY_PLATFORM
+  
+  RUBY = CONFIG['ruby_install_name']
+  VERSION = RUBY_VERSION
+  RELEASE_DATE = RUBY_RELEASE_DATE
+  
+  MAJOR_VERSION = CONFIG['MAJOR'].to_i
+  MINOR_VERSION = CONFIG['MINOR'].to_i
+  TEENY_VERSION = CONFIG['TEENY'].to_i
+  #VERSION = CONFIG['MAJOR'] + '.' + CONFIG['MINOR']
+
+  
+
+  BINDIR     = File.join( CONFIG['bindir'] )
+  LIBDIR     = File.join( CONFIG['libdir'], 'ruby' )
+  DATADIR    = File.join( CONFIG['datadir'] )
+
+  ARCH       = CONFIG['arch']
+
+  NEW_LIB_PATH = ((MAJOR_VERSION >= 2) or
+                  ((MAJOR_VERSION == 1) and
+                   ((MINOR_VERSION >= 5) or
+                    ((MINOR_VERSION == 4) and (TEENY_VERSION >= 4)))))
+    
+  if NEW_LIB_PATH then
+    SITELIBDIR = File.join( LIBDIR, 'site_ruby', VERSION )
+  else
+    SITELIBDIR = File.join( LIBDIR, VERSION, 'site_ruby' )
+  end
+
+  STDLIBDIR  = File.join( LIBDIR, VERSION )
+  RBDIR      = File.join( STDLIBDIR )
+  SODIR      = File.join( STDLIBDIR, ARCH )
+
+  SITE_RB    = File.join( SITELIBDIR )
+  SITE_SO    = File.join( SITELIBDIR, ARCH )
+
+  RUBY_PATH  = File.join( BINDIR, RUBY )
+
+  DLEXT      = CONFIG['DLEXT']
+  Extentions = [ 'rb', DLEXT ]
+
+end

data/lib/carat-dev/system/system.rb

@@ -0,0 +1,105 @@
+=begin
+
+  System module is inteded for system info. Mostly is is used
+  as a service module but it can be used as a mixin too module System.
+  
+=end
+
+module System
+
+  # service or mixin
+  extend self
+  
+  ### Execution Environment
+  
+  def program_name; $0 ; end
+  def program_name=(x); $0=x ; end
+  
+  def argv; $* ; end
+  alias options argv
+  
+  # these won't work here
+  #def file; __FILE__ ; end
+  #def filepath; File.expand_path(__FILE__) ; end
+  #def lineno; __LINE__ ; end
+  
+  def process_id; $$ ; end
+  alias_method :pid, :process_id
+  
+  def child_status; $? ; end
+  alias exit_status child_status
+  
+  def error_info; $! ; end
+  def error_position; $@ ; end 
+  
+  def debug; $DEBUG; end
+  
+  def safe; $SAFE; end
+  
+  def load_path; $: ; end
+  
+  def loaded_features; $" ; end
+  alias_method :required, :loaded_features
+  
+  def verbose; $VERBOSE; end
+  def verbose=(x); $VERBOSE=x; end
+  
+  def coding; $-K ; end
+  def coding=(x); $-K=x ; end
+
+  def line_end_processing; $-l ; end
+  
+  def program_loop; $-p ; end
+  
+  def env; ENV; end
+  
+  
+  ### Input/Ouput Variables
+  
+  def stdin; $stdin ; end
+  def stdin=(x); $stdin=x ; end
+  
+  def stdout; $stdout ; end
+  def stdout=(x); $stdout=x ; end
+  
+  def stderr; $stderr ; end
+  def stderr=(x); $stderr=x ; end
+
+  def default_input; $< ; end
+  alias_method :defin, :default_input
+  alias_method :argf, :default_input
+  
+  def default_output; $> ; end
+  def default_output=(x); $defout=x ; end
+  alias_method :defout, :default_output
+  alias_method :defout=, :default_output=
+  
+  def output_record_separator; $\ ; end
+  def output_record_separator=(x); $\=x ; end
+  alias_method :ors, :output_record_separator
+  alias_method :ors=, :output_record_separator=
+
+  def output_field_separator; $-F ; end
+  def output_field_separator=(x); $-F=x ; end
+  alias_method :ofs, :output_field_separator
+  alias_method :ofs=, :output_field_separator=
+  
+  def input_record_separator; $/ ; end
+  def input_record_separator=(x); $/=x ; end
+  alias_method :rs, :input_record_separator
+  alias_method :rs=, :input_record_separator=
+  
+  def input_field_separator; $/ ; end
+  def input_field_separator=(x); $/=x ; end
+  alias_method :fs, :input_field_separator
+  alias_method :fs=, :input_field_separator=
+  
+  def input_line_number; $. ; end
+  alias_method :input_lineno, :input_line_number
+  
+  ###
+  
+  def data; DATA ; end
+  
+end
+

data/lib/carat-dev/tc_range.rb

@@ -0,0 +1,118 @@
+
+  require 'test/unit'
+  require 'carat/range'
+
+
+  class GeneralTest < Test::Unit::TestCase
+
+    def test_include_001
+      a = Range.new(1,10)
+      assert_equal(false, a.include?(0))
+      assert_equal(true, a.include?(1))
+      assert_equal(true, a.include?(2))
+      assert_equal(true, a.include?(9))
+      assert_equal(true, a.include?(10))
+      assert_equal(false, a.include?(11))
+    end
+
+    def test_include_002
+      a = Range.new(1,10,false,true)
+      assert_equal(false, a.include?(0))
+      assert_equal(true, a.include?(1))
+      assert_equal(true, a.include?(2))
+      assert_equal(true, a.include?(9))
+      assert_equal(false, a.include?(10))
+      assert_equal(false, a.include?(11))
+    end
+
+    def test_include_003
+      a = Range.new(1,10,true,false)
+      assert_equal(false, a.include?(0))
+      assert_equal(false, a.include?(1))
+      assert_equal(true, a.include?(2))
+      assert_equal(true, a.include?(9))
+      assert_equal(true, a.include?(10))
+      assert_equal(false, a.include?(11))
+    end
+
+    def test_include_004
+      a = Range.new(1,10,true,true)
+      assert_equal(false, a.include?(0))
+      assert_equal(false, a.include?(1))
+      assert_equal(true, a.include?(2))
+      assert_equal(true, a.include?(9))
+      assert_equal(false, a.include?(10))
+      assert_equal(false, a.include?(11))
+    end
+
+  end
+  
+  class LrgNumericTest < Test::Unit::TestCase
+    def test_include
+      a = Range.new(0,100000000)
+      assert_equal(true, a.include?(0))
+      assert_equal(true, a.include?(1000))
+      assert_equal(true, a.include?(1000000))
+      assert_equal(true, a.include?(100000000))
+      assert_equal(false, a.include?(INFINITY))
+    end
+    def test_include_with_step
+      a = Range.new(0,100000000)
+      assert_equal(true, a.include?(0))
+      assert_equal(true, a.include?(5))
+      assert_equal(true, a.include?(70007))
+      assert_equal(true, a.include?(5000005))
+      assert_equal(false, a.include?(INFINITY))
+    end
+  end
+  
+  class InfTest < Test::Unit::TestCase
+    def test_include?
+      a = Range.new(-INFINITY,-3)
+      assert_equal(true, a.include?(-INFINITY))
+      assert_equal(true, a.include?(-4))
+      assert_equal(true, a.include?(-3))
+      assert_equal(false, a.include?(-2))
+      assert_equal(false, a.include?(INFINITY))
+      a = Range.new(-INFINITY,-3,false,true)
+      assert_equal(true, a.include?(-INFINITY))
+      assert_equal(true, a.include?(-4))
+      assert_equal(false, a.include?(-3))
+      assert_equal(false, a.include?(-2))
+      assert_equal(false, a.include?(INFINITY))
+      a = Range.new(-3,INFINITY)
+      assert_equal(false, a.include?(-INFINITY))
+      assert_equal(false, a.include?(-4))
+      assert_equal(true, a.include?(-3))
+      assert_equal(true, a.include?(-2))
+      assert_equal(true, a.include?(INFINITY))
+      a = Range.new(-INFINITY,INFINITY)
+      assert_equal(true, a.include?(-INFINITY))
+      assert_equal(true, a.include?(-4))
+      assert_equal(true, a.include?(-3))
+      assert_equal(true, a.include?(-2))
+      assert_equal(true, a.include?(INFINITY))
+      a = Range.new(-3,-2)
+      assert_equal(false, a.include?(-INFINITY))
+      assert_equal(false, a.include?(-4))
+      assert_equal(true, a.include?(-3))
+      assert_equal(true, a.include?(-2))
+      assert_equal(false, a.include?(INFINITY))
+    end
+  end 
+  
+  class OrdinalTest < Test::Unit::TestCase
+    def test_include
+      a = Range.new('a','g')
+      #assert_equal(false, a.include?(-INFINITY))
+      assert_equal(true, a.include?('a'))
+      assert_equal(true, a.include?('c'))
+      assert_equal(false, a.include?('z'))
+      #assert_equal(false, a.include?(INFINITY))
+    end
+    #def test_error
+    #  assert_raises(ArgumentError) {
+    #    a = (-INFINITY..'z')
+    #  }
+    #end
+  end