carats 0.3.0

data/lib/carat-dev/class-constructor/constructor_methods.rb

@@ -0,0 +1,78 @@
+# = ClassMethods
+#
+# This allows all classes to be instantiated via methods of the same name,
+# rather then having to use #new. Because these methods are capitalized,
+# like their class couterpart, parenthesis are required.
+#
+# == Example
+# 
+#   require 'carat-dev/class_methods'
+#
+#   class AClass
+#     include ClassMethods
+#     def initialize(a)
+#       @a = a
+#     end
+#   end
+#
+#   aobj = AClass(1)   # same as AClass.new(1)
+#
+#   class BClass < AClass
+#   end
+#
+#   bobj = BClass(2)   # same as BClass.new(2)
+#
+module ClassMethods
+  
+  def self.included( klass )
+    Object.instance_eval {
+      define_method( klass.name ) do |*args|
+        klass.new(*args)
+      end
+    }
+    def klass.inherited( klass )
+      Object.instance_eval {
+        define_method( klass.name ) do |*args|
+          klass.new(*args)
+        end
+      }
+      super if defined? super
+    end
+  end
+  
+  def self.include_in_all
+    Object.class_eval do
+      include ClassMethods
+    end
+  end
+  
+end
+
+### OLD CODE
+# class Object
+#   class << self
+#     alias_method( :inherited_without_method_constructor , :inherited ) if respond_to?( :inherited )
+#     def inherited( klass )
+#       define_method( klass.name ) do |*args|
+#         klass.new(*args)
+#       end
+#       inherited_without_method_constructor( klass ) if respond_to?( :inherited_without_method_constructor )
+#     end
+#   end
+# end
+
+
+# --- test ---
+
+if $0 == __FILE__
+
+  class AClass
+    include ClassMethods
+    def initialize(a)
+      @a = a
+    end
+  end
+  aobj = AClass(1)   # same as AClass.new(1)
+  p aobj
+  
+end

data/lib/carat-dev/class-constructor/tc_constructor.rb

@@ -0,0 +1,35 @@
+
+require 'test/unit'
+require 'trix/constructor'
+
+
+# setup
+  
+module A
+  D = "d"
+  class B
+    def initialize
+    end
+  end
+end
+
+class C
+  def initialize
+  end  
+end
+
+E = 1
+  
+
+# testcase
+  
+class TC_Constructor < Test::Unit::TestCase
+
+  def test_run
+    assert_nothing_raised do
+      c = C()
+      b = A::B()
+    end
+  end
+  
+end

data/lib/carat-dev/closecall/closecall-test.rb

@@ -0,0 +1,39 @@
+
+require 'test/unit'
+require 'trix/closecall'
+
+# fixture
+
+class T
+  include CloseCall
+
+  def someMethod(arg1)
+    return "1:#{arg1}"
+  end
+
+  def someMethod2(arg1)
+    return "2:#{arg1}"
+  end
+
+  def someMethod3(arg1, arg2)
+    return "3:#{arg1},#{arg2}"
+  end
+end
+
+#class Object
+#  include CloseCall
+#end
+
+# test
+
+class TC_CloseCall < Test::Unit::TestCase
+
+  def test_it
+    test = T.new
+    assert_equal( '3:a,b', test.somemethod('a', 'b') )
+    assert_equal( '1:a', test.somemethod('a') )
+    assert_equal( '2:b', test.somemethod2('b') )
+    assert_raises( NameError, test.somemethod('a', 'b', 'c') )
+  end
+ 
+end

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

@@ -0,0 +1,101 @@
+=begin
+
+= CloseCall
+
+Mixin that allows programs to make slight spelling and/or arity mistakes on 
+method calls and the program will still work. It achieves this by applying 
+some hueristics in method_missing. It searches all the methods on the object
+with the same (or compatible) arity, and uses the String#fuzzy_match method
+from the code snippets on rubyforge to find a method with a similar name. 
+When it finds one similar enough, it uses class_eval to define the method,
+so method_missing doesn't get called the next time.
+
+This is highly experimental, and is here primarily for expirementation with 
+Natural Langauge Computing.
+
+== Author
+
+* Derek Lewis <lewisd#f00f.net>
+
+== History
+
+  $Id: CloseCall, v 0.1.0 2004/10/10 transami Exp $
+  
+=end
+
+require 'atomx/string/fuzzy_match'
+
+module CloseCall
+
+  MIN_SCORE = 0.75
+
+  def find_similar_symbol(symbol, args)
+    methods = self.public_methods.find_all do |sym|
+      arity = self.method(sym).arity
+      arity < 0 || arity == args
+    end
+    #p methods
+    method,score = best_match(symbol, methods)
+    #puts "Method: #{method}   Score: #{score}"
+    return method if (score > MIN_SCORE)
+    puts "Score = #{score}"
+    return nil
+  end
+
+  def best_match(name, things)
+    high_score = -1
+    high_match = nil
+    name = name.to_s
+    things.each do |thing|
+      str = thing.to_str
+      if str != nil
+        #puts "Checking #{str}"
+        score = str.fuzzy_match(name)
+        if (score > high_score)
+          high_score = score
+          high_match = thing
+        end
+      end
+    end
+    return high_match, high_score
+  end
+
+  def method_missing(symbol, *args)
+    puts "Finding method for #{symbol} with #{args.length} args"
+    sym = find_similar_symbol(symbol, args.length)
+    if sym != nil
+      method = method(sym)
+      max_arity = self.public_methods.collect{|sym| self.method(sym).arity}.sort.last
+      if !self.respond_to?(symbol)
+        code = %'
+          def #{symbol}(*args)
+            case args.length'
+        0.upto(max_arity) do |x|
+          sym = find_similar_symbol(symbol, x);
+          if (sym != nil)
+            code += %'
+            when #{x}
+              if block_given?
+                #{sym}(*args) { |*bargs| yield *bargs }
+              else
+                #{sym}(*args)
+              end'
+          end
+        end
+        code = code + %'
+            else
+              raise NameError, "no method similar to \'#{symbol}\' found for \#{args.length} args"
+            end
+          end'
+        #puts code
+        puts "defining method for #{symbol}"
+        self.class.class_eval code
+      end
+      return self.send(symbol, *args) { |*bargs| yield *bargs }
+    end
+    raise NameError, "no method similar to `#{symbol}' with #{args.length} args for \"#{self}\":#{self.class}"
+  end
+
+  private :find_similar_symbol, :best_match
+
+end

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

@@ -0,0 +1,100 @@
+class CommandRunner
+    attr :command
+    attr :child_pid
+
+    def initialize(*command)
+        @command        = command
+        @child_pid      = nil
+        @waiting_thread = nil
+
+        @read_pipe        = nil
+        @read_error_pipe  = nil
+        @write_pipe       = nil
+    end
+
+    def closeWrite
+        @write_pipe.close
+    end
+
+    def kill
+        Process.kill("KILL", @child_pid)
+    end
+
+    def read
+        return @read_pipe.read
+    end
+
+    def readError
+        return @read_error_pipe.read
+    end
+
+    def run
+        parent_to_child_read, parent_to_child_write             = IO.pipe
+        child_to_parent_read, child_to_parent_write             = IO.pipe
+        child_to_parent_error_read, child_to_parent_error_write = IO.pipe
+
+        @child_pid = fork do
+            parent_to_child_write.close
+            child_to_parent_read.close
+            child_to_parent_error_read.close
+
+            # Wait until parent is ready before we start doing anything
+            if parent_to_child_read.readchar.chr != "R"
+                raise "Unexpected input from parent"
+            end
+
+            $stdin.reopen(parent_to_child_read)
+            $stdout.reopen(child_to_parent_write)
+            $stderr.reopen(child_to_parent_error_write)
+
+            exec(*@command)
+        end
+
+        @waiting_thread = Thread.new(@child_pid) do |pid|
+            return_code = -1
+
+            begin
+                return_code = Process.waitpid2(pid)
+            rescue SystemError
+                raise "Process finished running already!"
+            end
+            return_code = return_code[1].exitstatus
+
+            return_code
+        end
+
+        child_to_parent_write.close
+        child_to_parent_error_write.close
+        parent_to_child_read.close
+
+        @read_pipe        = child_to_parent_read
+        @read_error_pipe  = child_to_parent_error_read
+        @write_pipe       = parent_to_child_write
+
+        @write_pipe.write("R")
+        @write_pipe.flush
+    end
+
+    #--------------------------------------------------------------------------
+    # Waits for command to exit
+    # Returns: The return code of the program when it exited
+    #--------------------------------------------------------------------------
+    def wait
+        if not @child_pid or not @waiting_thread
+            raise "Waiting for a process that has not started"
+        end
+
+        return_value = @waiting_thread.value
+
+        @waiting_thread = nil
+        @child_pid = nil
+
+        return return_value
+    end
+
+    def write(string)
+        @write_pipe.write(string)
+    end
+end
+
+

data/lib/carat-dev/conditional/conditionals.rb

@@ -0,0 +1,106 @@
+
+class Object
+  def false? ; nil ; end
+  def true? ; yield ; end
+end
+
+class FalseClass
+  def false? ; yield ; end
+  def true? ; nil ; end
+end
+
+class NilClass
+  def false? ; yield ; end
+  def true? ; nil ; end
+end
+
+module Kernel
+  def _if(exp, &block)
+    else_block = callcc { |cont|
+      @condition = cont
+      return exp.true?(&block)
+    }
+    @condition = nil
+    exp.false?(&else_block)
+  end
+  def _unless(exp, &block)
+    else_block = callcc { |cont|
+      @condition = cont
+      return exp.false?(&block)
+    }
+    @condition = nil
+    exp.true?(&else_block)
+  end
+  def _else(&block)
+    @condition.call(block) if @condition
+  end
+end
+
+
+# --- Test ---
+ 
+a = nil
+b = 2
+c = false
+
+_if(a != b) {
+  puts "a!=b"
+}
+_else {
+  puts "a==b"
+}
+
+_unless(b) {
+  puts "b is false"
+}
+_else {
+  puts "b is true"
+}
+
+
+# I was thinking of allowing for a multi block scenario.
+module Kernel
+  alias fn lambda
+  def iff( *exp_blks )
+    r = nil
+    exp_blks.each_with_index{ |e,i| 
+      if i % 2 == 0
+        r = e.true?(&exp_blks[i+1]); break if e
+      end
+    }
+    r
+  end
+  def unles( *exp_blks )
+    r = nil
+    exp_blks.each_with_index{ |e,i| 
+      if i % 2 == 0
+        r = e.false?(&exp_blks[i+1]); break if ! e
+      end
+    }
+    r
+  end
+end
+
+# --- test ---
+
+a = nil
+b = 2
+c = false
+
+iff(
+  (a != b), fn{
+    puts "a!=b"
+  }, 
+  (true), fn{
+    puts "a==b"
+  } 
+)
+
+unles( 
+  (b), fn{
+    puts "b is false"
+  }, 
+  (false), fn{
+    puts "b is true"
+  }
+)