carats 0.3.0

data/lib/carat-dev/interface_work/contracts/contract/lib/contract/overrides.rb

@@ -0,0 +1,32 @@
+# This file contains a few overrides of Test::Unit behavior that are
+# either necessary for the contract library to work correctly or that
+# make things a bit more comfortable to use.
+
+
+class Contract < Test::Unit::TestCase
+  # The resulting suite() should pass along additional parameters that
+  # are given to the suite.run method so we can supply a specific Object
+  # to run the test suite against.
+  def self.suite() # :nodoc:
+    result = super()
+    def result.run(result, *more, &progress_block)
+      progress_block ||= lambda { |*args| }
+      progress_block.call(STARTED, name)
+      @tests.each do |test|
+        test.run(result, *more, &progress_block)
+      end
+      progress_block.call(FINISHED, name)
+    end
+    return result
+  end
+
+  # We need to run the test suite against a specific Object.
+  def run(result, object) # :nodoc:
+    @object = object
+    super(result)
+  end
+
+  # Having empty contracts makes sense and is not an unexpected situation.
+  def default_test() # :nodoc:
+  end
+end

data/lib/carat-dev/interface_work/must.rb

@@ -0,0 +1,37 @@
+#
+# must.rb
+#
+#   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.
+#
+#   $Id: must.rb,v 1.12 2002/01/05 06:19:34 aamine Exp $
+#
+class Object
+
+  def must( *args )
+    args.each {|c| return self if c === self }
+    raise TypeError, "wrong arg type '#{self.class}' for required #{args.join('/')}"
+  end
+
+  def must_have( *args )
+    args.each do |m|
+      self.respond_to? m or
+        raise ArgumentError, "receiver #{inspect} does not have '#{m}'"
+    end
+    self
+  end
+  alias_method :needed, :must_have
+
+  def must_be( obj )
+    self == obj or raise ArgumentError, "expected #{eq.inspect} but is #{inspect}"
+    self
+  end
+
+  def must_exist
+    nil? and raise ArgumentError, 'receiver is wrongly nil'
+  end
+
+end

data/lib/carat-dev/interface_work/type.rb

@@ -0,0 +1,232 @@
+=begin
+
+ bill/type.rb
+
+ $Author: transami $
+ $Date: 2003/12/06 13:56:57 $
+
+ Copyright (C) 2002 T. Onoma
+
+ This program is free software.
+ You can distribute/modify this program under
+ the terms of the Ruby Distribute License.
+
+=end
+=begin
+
+= Description
+
+= Usage
+
+== Using Cast Attribute Accessors
+
+  # simple type casting
+  attr_reader :a => :to_s
+
+  # fancy type casting
+  attr_reader :a => 'to_s.capitalize'
+
+  # a powerful reader!
+  attr_reader :a => fn{ |x| eval x }
+
+  # a writer that type checks
+  attr_writer :a => fn{ |x| big4 x }
+
+  # backwards compatible, just put cast attributes at end of list
+  attr_accessor :x, :y, :a => :to_s
+
+== Using Types
+
+  A type is defined with a name, a "duck" list of methods that the
+  object must respond to, and an optional validation block
+
+  type :typename, [:methods, :respond_to?, ...] { |x| validation }
+
+  type :big4, [:to_str, :succ] do |x|
+    x > 4
+  end
+
+  def ameth(x)
+    big4 x
+    puts x
+  end
+
+  typecheck = true
+
+  t.ameth(5)  # => 5
+  t.ameth(2)  # TypeError
+
+=== A More Elegant Future?
+
+  type big4(x)
+    :to_str, :succ
+  unless
+    x > 4
+  end
+
+  def ameth(big4 x)
+    puts x
+  end
+
+  # IDEA
+  #
+  # def test(a,b)
+  #   check a=>String, b=>Integer
+  # end 
+
+=end
+
+$typecheck = true  # typechecking defualts to true
+
+T = true
+F = false
+
+# One things that we do is be sure to add
+# self referential to_{type} methods to class'
+# of that type. Thus String should have a to_s method
+# and to forth.
+
+
+class Type
+  class TypeRepositoryError < TypeError
+  end
+  class TypeSignitureError < TypeError
+  end
+  class TypeValidationError < TypeError
+  end
+  #def Type.repository
+    @@repository = {}
+  #end
+  def Type.add(t)
+    raise TypeRepositoryError if !t.kind_of?(Type)
+    @@repository[t.name] = t
+  end
+  def Type.[](name)
+    @@repository[name]
+  end
+  attr_reader :name, :responders, :validator
+  def initialize(name, responders, &validator)
+    @name = name
+    @responders = responders
+    @validator = validator
+    Type.add(self)
+  end
+  def ensign?(obj)
+    @responders.all? { |r| @r = r; obj.send(:respond_to?, r) }
+  end
+  def ensigniate(obj)
+    unless ensign?(obj)
+      raise TypeSignitureError, "#{self.name} #{obj} (#{@r})"
+    end
+  end
+  def valid?(obj)
+    @validator ? @validator.call(obj) : true
+  end
+  def validate(obj)
+    unless valid?(obj)
+      raise TypeValidationError, "#{self.name} #{obj}"
+    end
+  end
+  def check?(obj)
+    ensign?(obj) && valid?(obj)
+  end
+  def check(obj)
+    ensigniate(obj)
+    validate(obj)
+  end
+end
+
+# **REMOVE** **ALL?**
+# NilClass, unlike other classes, is a representation
+# of "nothingness", so #to_{t} returns the empty
+# form of that type, with the exception of to_b
+# which returns false. The standard NilClass already
+# does this for some of the fundemtal classes, but
+# has left a few out which we add here.
+# TODO: Add a switch for the other methods (?)
+#class NilClass
+#  def to_b; false; end
+#  def to_f; 0.0; end
+#  def to_h; {}; end
+#   are these a good idea (some but not all?)
+#  def empty?; true; end
+#  def include?(*args); return nil; end
+#  def [](arg); return nil; end
+#  alias size to_i
+#  alias length to_i
+#end
+
+# Add to_b which returns true
+#class TrueClass
+#  def to_b; true; end
+#end
+
+# Add to_b which returns false
+#class FalseClass
+#  def to_b; false; end
+#end
+
+#class Object
+#  def to_b
+#    self ? true : false
+#  end
+#end
+
+class Symbol
+  def intern
+    self
+  end
+end
+
+# The kernal method typecheck globally turns type checking on or off
+# TODO: Perhpas this should only apply to the current scopes? Possible?
+#module Kernel
+#  alias fn lambda
+#  def typecheck(x=true)
+#    $_tc = (x ? true : false)
+#  end
+#  def typecheck=(x)
+#    $_tc = (x ? true : false)
+#  end
+#  def typecheck?
+#    return $_tc
+#  end
+#end
+
+# Add the type method for defining new types
+# Syntax:
+#   type :name, [:duck_method, ...] { |x| validation code on x }
+class Module
+  def type(name, responders, &validator)
+    Type.new(name, responders, &validator)
+    define_method(name) { |*vars|
+      if $typecheck
+        vars.all? { |v| Type[name].check(v) }
+        return *vars
+      end
+    }
+  end
+end
+
+#class Type
+#  @@conversion_registry = {}
+#  def self.define_conversion(from_class, to_type, &caster)
+#    @@conversion_registry[to_type] ||= {}
+#    @@conversion_registry[to_type][from_type] = &caster
+#  end
+#  def caster(to_type)
+#    @@conversion_registry[to_type]
+#  end
+#end
+
+class Object
+  def self.conversion(to_type)
+    @conversion_registry[to_type]
+  end
+  def self.define_conversion(to_type, &block)
+    @conversion_registry[to_type]
+  end
+  def to(to_type, *args)
+    @conversion_registry[to_type].call(*args)
+  end
+end

data/lib/carat-dev/main/tc_toplevel.rb

@@ -0,0 +1,23 @@
+########################################
+require 'test/unit'
+require 'raspberry/new/toplevel'
+########################################
+
+  ###### #####   #### ######
+    ##   ##     ##      ##
+    ##   ####     ##    ##
+    ##   ##        ##   ##
+    ##   #####  ####    ##
+
+class TC_TopLevel < Test::Unit::TestCase 
+
+  def test_compare
+    assert_equal( TOPLEVEL_BINDING.self , TOPLEVEL_BINDING.self )
+    assert_equal( toplevel , toplevel )
+    assert_equal( TOPLEVEL , TOPLEVEL )
+    assert_equal( TOPLEVEL , toplevel )
+    assert_instance_of( TopLevel, toplevel )
+    assert_eqaul( Object, toplevel.class )
+  end
+
+end

data/lib/carat-dev/main/toplevel.rb

@@ -0,0 +1,33 @@
+#require 'singleton'
+require 'delegate'
+require 'raspberry/new/binding'
+
+class TopLevelClass < DelegateClass(TOPLEVEL_BINDING.self.class)
+  #include Singleton  # doesn't seem to work with delegate
+  class << self
+    private :new
+    def instance
+      @singleton ||= new
+    end
+  end
+  def initialize()
+    super(TOPLEVEL_BINDING.self)
+  end
+  def binding()
+    TOPLEVEL_BINDING
+  end
+  #def method_missing(sym, *args, &blk)
+  #  TOPLEVEL_BINDING.self.send(sym, *args, &blk)
+  #end
+end
+
+module Kernel
+  # perhaps just call this top() ?
+  def toplevel()
+    TopLevelClass.instance
+  end
+end
+
+# assign constant
+TOPLEVEL = TopLevelClass.instance
+

data/lib/carat-dev/main/toplevel_test.rb

@@ -0,0 +1,24 @@
+require 'test/unit'
+require 'abc/lib/toplevel'
+
+a = "a"
+@x = "x"
+
+class TC_TopLevel < Test::Unit::TestCase
+
+  def test_instance
+    assert_nothing_raised do
+      @t = toplevel
+    end
+  end
+  
+  def test_local_vars
+    assert_equal(['a'], toplevel.local_variables)
+  end
+  
+  def test_instance_vars
+    assert_equal(['@x'], toplevel.self.instance_variables)
+  end
+  
+end
+ 

data/lib/carat-dev/misc/1.rb

@@ -0,0 +1,40 @@
+# 1.rb one-liners helper lib.
+
+K=Kernel
+O=Object
+C=Class
+
+module Kernel
+  alias pi p
+  alias p print
+  alias ps puts
+  alias s sleep
+  alias l loop
+end
+
+module Enumerable
+  alias m map
+end
+
+class Array
+  alias e each
+  alias r reverse
+end
+
+class String
+  alias e each
+  alias r reverse
+end
+
+class Integer
+  alias t times
+end
+
+# --- dev testing ---
+
+  # normal
+  s="\e[2J\e[0;0H         _\nQuack! >(*)____,\n        (` =~~/\n^v^v^v^v^`---'v^v^v^v^\n";i=0;loop{s[21,6]=i&1>0?'Quack!':' '*6;s.tr!(t='*.>v^<,"',t.reverse);$><<s;i+=sleep 1}
+  
+  # new
+#  s="\e[2J\e[0;0H         _\nQuack! >(*)____,\n        (` =~~/\n^v^v^v^v^`---'v^v^v^v^\n";i=0;l{s[21,6]=i&1>0?'Quack!':' '*6;s.tr!(t='*.>v^<,"',t.r);$><<s;i+=s 1}
+  

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

@@ -0,0 +1,44 @@
+
+module Miscellaneous
+
+  extend self
+
+  def fractree1(m=32,l="A")
+    #n.times{|y|print" "*(n-1-y);(y+1).times{|x|print~y&x>0?" .":" #{l[0.1]}"};puts}
+    n.times{|y|print" "*(n-1-y),(0..y).map{|x|~y&x>0?" .":" #{l}"},$/}
+  end
+
+  def facttree2
+    a=[];10.times{|n|a<<1;puts" "*(9-n)*3+"%6d"*(n+1)%a;n.times{|i|a[n]+=a[n-=1]}}
+  end
+
+  def facttree3
+    a=[];10.times{|n|a<<1;puts" "*(9-n)*3+"%6d"*-~n%a;n.times{|i|a[n]+=a[n-=1]}}
+  end
+  
+  def duck1
+    s="\033[2J\033[0;0H          _\n Quack! >(')____,\n         (` =~~/\n~^~^~^~^~^`---'~^~^~^~^";(1..(1/0.0)).each{|i|s[23,6]=(i%2)==0?"Quack!":" "*6;s.tr!('>~^^~<','<^~~^>');puts s;sleep 1}
+  end
+  
+  def duck2
+    s="\e[2J\e[0;0H         _\nQuack! >(*)____,\n        (` =~~/\n^v^v^v^v^`---'v^v^v^v^\n";i=0;loop{s[21,6]=i&1>0?'Quack!':' '*6;s.tr!(t='*.>v^<,"',t.reverse);$><<s;i+=sleep 1}
+  end
+
+  def duck3
+    q,w='Quack! >','~^'*11;t="\e[2J\e[0;0H         _\n%8s(')____,\n        (` =^^/\n%20s \n";i=0;loop{s=t%[i&1>0?q:'<',w[i%2,20]];$><<s;i+=sleep 1}
+  end
+  
+  def duck4
+    i=1;loop{puts"\e[2J\e[0;0H#{' '*10}_\n %8s(*)____,\n#{' '*9}(` =~~/\n#{'~^~'[i%2,2]*9}"%(i&1>0?'<':'Quack! >');i+=sleep 1}
+  end
+  
+  def ruby_quiz
+    "bp6siZmijp5CiZlCiW5CgAAChpbiiZYiiZZCi5aCZ2bs".unpack("m")[0].unpack("C*").map{|x|x.chr}.join.unpack("B*")[0].scan(/.{24}/){i=7;$&.scan(/..../){print"\e[3#{i-=1};1;40m  ";$&.each_byte{|z|print" #"[z-?0,1]*2}};puts"\e[0m"}
+  end
+end
+
+if $0 == __FILE__
+
+  Miscellaneous.duck4
+
+end