carats 0.3.0

data/lib/carat/snapshot.rb

@@ -0,0 +1,94 @@
+=begin rdoc
+
+= Snapshot
+
+A lightweight single-depth object state capture.
+The #take_snapshot method reads the object's state, 
+which is generally it's collection of instance variables,
+and returns them in a hash. The state can be restored
+with #apply_snapshot.
+
+== Usage
+
+  require 'raspberry/new/snapshot'
+
+  Customer = Struct.new("Customer", :name, :address, :zip)
+  joe = Customer.new( "Joe Pitare", "1115 Lila Ln.", 47634 )
+  
+  # simple transactions
+  joe_snap = joe.take_snapshot
+  begin
+    do_something_with( joe )
+  rescue
+    joe.apply_snapshot( joe_snap )
+  end
+
+  joe_snap[:name]     => "Joe Pitare"
+  joe_snap[:address]  => "1115 Lila Ln."
+  joe_snap[:zip]      => 47634
+  
+== TODO
+
+* Perhaps extend to offer multiple depths.
+* Should key consitancy be enforced? Currently
+  Struct's will have symobl keys while other classes
+  will have string keys in the form of "@name".
+* Add other core classes.
+
+== History
+
+* 20005.04.11 Passed basic test.
+
+==
+
+=end
+
+class Object
+  def take_snapshot
+    snap = Hash.new
+    instance_variables.each do |iv|
+      snap[iv] = instance_variable_get(iv)
+    end
+    snap
+  end
+
+  def apply_snapshot(snap)
+    instance_variables.each do |iv|
+      instance_variable_set(iv, snap[iv])
+    end
+  end
+end
+
+class Array
+  def take_snapshot
+    dup
+  end
+
+  def apply_snapshot(snap)
+    replace(snap)
+  end
+end
+
+class String
+  def take_snapshot
+    dup
+  end
+
+  def apply_snapshot(snap)
+    replace(snap)
+  end
+end
+
+# Struct snapshots look a bit different
+# since they don't use instance variables.
+class Struct
+  def take_snapshot
+    snap = Hash.new
+    each_pair { |k,v| snap[k] = v }
+    snap
+  end
+
+  def apply_snapshot(snap)
+    snap.each_pair{ |k,v| send( "#{k}=", v ) } 
+  end
+end

data/lib/carat/soundex.rb

@@ -0,0 +1,104 @@
+=begin rdoc
+
+= Soundex
+
+Implementation of the soundex algorithm as described by Knuth 
+in volume 3 of The Art of Computer Programming.
+
+== Author
+
+* Michael Neumann (neumann@s-direktnet.de)
+
+== Legal
+
+Copyright (c) 2000 Michael Neumann
+
+GNU GPL (see included file)
+
+== History
+
+* 2005.04.11 Passes basic test.
+
+=end
+
+module Text
+  module Soundex
+
+    def soundex(str_or_arr)
+      case str_or_arr
+      when String
+        soundex_str(str_or_arr)
+      when Array
+        str_or_arr.collect{|ele| soundex_str(ele)}
+      else
+        nil
+      end
+    end
+    module_function :soundex
+    
+    private
+  
+    #
+    # returns nil if the value couldn't be calculated (empty-string, wrong-character)
+    # do not change the parameter "str"
+    #
+    def soundex_str(str)
+      return nil if str.empty?
+  
+      str = str.upcase
+      last_code = get_code(str[0,1])
+      soundex_code = str[0,1]
+  
+      for index in 1...(str.size) do
+        return soundex_code if soundex_code.size == 4
+  
+        code = get_code(str[index,1])
+        
+        if code == "0" then
+          last_code = nil
+        elsif code == nil then
+          return nil
+        elsif code != last_code then
+          soundex_code += code
+          last_code = code        
+        end 
+      end # for
+      
+      return soundex_code + "000"[0,4-soundex_code.size]
+    end
+    module_function :soundex_str
+              
+    def get_code(char)
+      char.tr! "AEIOUYWHBPFVCSKGJQXZDTLMNR", "00000000111122222222334556"
+    end
+    module_function :get_code
+  
+  end # module Soundex
+end # module Text
+
+
+=begin
+
+# --- development testing ----
+
+if __FILE__ == $0
+  testvec = "Euler Ellery Gauss Ghosh Hilbert Heilbronn Knuth Kant Lloyd Ladd Lukasiewicz Lissajous".split(" ")
+  resvec  = "E460 E460 G200 G200 H416 H416 K530 K530 L300 L300 L222 L222".split(" ")
+   
+  wrong = 0
+  
+  testvec.each_with_index {|str,i| 
+    res = Text::Soundex.soundex(str)
+    print "#{str.ljust(11)} => #{res} ... "
+    if res == resvec[i] then
+      puts "ok"
+    else
+      wrong += 1
+      puts "failed, had to be #{resvec[i]}"
+    end    
+  }
+  puts "summary: #{wrong} of #{testvec.size} tests failed!"      
+  readline
+end
+
+=end

data/lib/carat/sstruct.rb

@@ -0,0 +1,223 @@
+=begin rdoc
+
+= SuperStruct
+
+This is an easy way to create Struct-like classes; it converts easily
+between hashes and arrays, and it allows OpenStruct-like dynamic naming
+of members.
+
+Unlike Struct, it creates a "real" class, and it has real instance variables 
+with predictable names.
+
+A basic limitation is that the hash keys must be legal method names (unless
+used with send()).
+
+Basically, ss["alpha"], ss[:alpha], ss[0], and ss.alpha all mean the same.
+
+== Usage
+
+
+== Author(s)
+
+* Hal Fulton
+
+== Legal
+
+Ruby License (see incuded file)
+
+=end
+
+
+class SuperStruct
+
+  def SuperStruct.new(*args)
+    @table = []
+    @setsyms = []        # Setter symbols
+    klass = Class.new
+    if (args.size == 1) && (args[0].is_a? Array)
+      args = args[0]
+    end
+    strs = args.map {|x| x.to_s }
+    args.each_with_index do |k,i|
+      case
+	when (! [String,Symbol].include? k.class)
+	  raise ArgumentError, "Need a String or Symbol"
+        when (strs[i] !~ /[_a-zA-Z][_a-zA-Z0-9]*/)
+          raise ArgumentError, "Illegal character"
+      end
+      k = k.intern if k.is_a? String
+      @table << k
+      @setsyms << (k.to_s + "=").intern
+      klass.instance_eval { attr_accessor k }
+    end
+
+    setsyms = @setsyms
+    table   = @table
+    vals    = @vals
+    klass.class_eval do
+      attr_reader :singleton
+      define_method(:initialize) do |*vals|
+        n = vals.size
+	m = table.size
+	case 
+	  when n < m
+	    # raise ArgumentError, "Too few arguments (#{n} for #{m})"
+	    # Never mind... extra variables will just be nil
+	  when n > m
+	    raise ArgumentError, "Too many arguments (#{n} for #{m})"
+	end
+        setsyms.each_with_index do |var,i|
+          self.send(var,vals[i])
+        end
+      end
+      define_method(:pretty_print) do |q|  # pp.rb support
+        q.object_group(self) do
+          q.seplist(self.members, proc { q.text "," }) do |member|
+#         self.members.each do |member|
+#           q.text ","  # unless q.first?
+            q.breakable
+            q.text member.to_s
+            q.text '='
+            q.group(1) do
+              q.breakable ''
+              q.pp self[member]
+            end
+          end
+        end
+      end
+      define_method(:inspect) do
+        str = "#<#{self.class}:"
+        table.each {|item| str << " #{item}=#{self.send(item)}" }
+        str + ">"
+      end
+      define_method(:[]) do |*index|
+        case index.map {|x| x.class }
+	  when [Fixnum]
+            self.send(table[*index])
+          when [Fixnum,Fixnum], [Range]
+	    table[*index].map {|x| self.send(x)}
+	  when [String]
+	    self.send(index[0].intern)
+	  when [Symbol]
+	    self.send(index[0])
+        else
+          raise ArgumentError,"Illegal index"
+	end
+      end
+      define_method(:[]=) do |*index|
+        value = index[-1]
+        index = index[0..-2]
+        case index.map {|x| x.class }
+	  when [Fixnum]
+            self.send(table[*index])
+          when [Fixnum,Fixnum], [Range]
+	    setsyms[*index].map {|x| self.send(x,value) }
+	  when [String]
+	    self.send(index[0].intern,value)
+	  when [Symbol]
+	    self.send(index[0],value)
+        else
+          raise ArgumentError,"Illegal index"
+	end
+      end
+      define_method(:to_a)    { table.map {|x| eval("@"+x.to_s) } }
+      define_method(:to_ary)  { to_a }
+      define_method(:members) { table.map {|x| x.to_s } }
+      define_method(:to_struct) do
+        mems = table
+        Struct.new("TEMP",*mems)
+        # Struct::TEMP.new(*vals) # Why doesn't this work??
+        data = mems.map {|x| self.send(x) }
+        Struct::TEMP.new(*data)
+      end
+      define_method(:to_hash) do
+        hash = {}
+	table.each do |mem|
+          mem = mem.to_s
+          hash.update(mem => self.send(mem))
+        end
+	hash
+      end
+      define_method(:set) {|h| h.each_pair {|k,v| send(k.to_s+"=",v) } }
+
+      # Class methods...
+
+      @singleton = class << self
+        self
+      end
+
+      @singleton.instance_eval do
+        define_method(:members) do 
+	  table.map {|x| x.to_s }
+	end
+        me = self
+        define_method(:attr_tester) do |*syms| 
+          syms.each {|sym| alias_method(sym.to_s+"?",sym) }
+        end
+      end
+
+    end
+    klass
+  end
+
+
+  def SuperStruct.open(*args)
+    klass = SuperStruct.new(*args)
+    table = @table
+    setsyms = @setsyms
+    table = @table
+    klass.class_eval do
+      define_method(:method_missing) do |meth, *args|
+        mname = meth.id2name
+        if mname =~ /=$/
+          getter = mname.chop
+          setter = mname
+        elsif mname =~ /\?$/
+          raise NoMethodError  # ?-methods are not created automatically
+        else
+          getter = mname
+          setter = mname + "="
+        end
+        gsym = getter.intern
+        ssym = setter.intern
+        ivar = "@" + getter
+        setsyms << setter
+        table << getter
+        len = args.length
+        if mname == getter
+          klass.class_eval do                 # getter
+            define_method(getter) do
+              instance_variable_get(ivar)
+            end
+          end
+        else
+          klass.class_eval do                 # setter
+            define_method(setter) do |*args|
+              if len != 1
+                raise ArgumentError, "Wrong # of arguments (#{len} for 1)", 
+                      caller(1)
+              end
+              instance_variable_set(ivar,args[0])
+              instance_variable_get(ivar)
+            end
+          end
+        end
+        if mname == setter
+          self.send(setter,*args)
+        else
+          if len == 0
+            self.send(getter)
+          else
+            raise NoMethodError, "Undefined method '#{mname}' for #{self}", 
+                  caller(1)
+          end
+        end
+      end
+    end
+    klass
+  end
+
+end
+
+
+require "test-sstruct" if $0 == __FILE__

data/lib/carat/statichash.rb

@@ -0,0 +1,49 @@
+=begin rdoc
+
+= StaticHash
+
+A Hash object which raises an error if any 
+previously-defined key attempts to be set again.
+
+== Synopsis
+
+  foo = StaticHash.new
+  foo['name'] = 'Tom'    #=> 'Tom'
+  foo['age']  = 30       #=> 30
+  foo['name'] = 'Bob'
+
+_produces_
+
+  Error: StaticHash has value for key 'name' in object:
+      {"name"=>"Tom", "age"=>30} (RuntimeError)  
+
+== Author(s)
+  
+* Gavin Kistner
+* T. Onoma
+
+== Legal
+
+Adapted from Gavin Kistner's WriteOnceHash in basiclibrary.rb
+Copyright (c)2004 Gavin Kistner
+
+It is covered under the license viewable at http://phrogz.net/JS/_ReuseLicense.txt
+Reuse or modification is free provided you abide by the terms of that license.
+(Including the first two lines above in your source code usually satisfies the conditions.)
+
+== History
+
+* 2005.04.11 Passed basic test.
+
+=end
+
+class StaticHash < Hash
+  # Set a value for a key; raises an error if that key already exists with a different value.
+  def []=(key,val)
+    if self.has_key?(key) && self[key]!=val
+      raise ArgumentError, "StaticHash already has value for key '#{key.to_s}'"
+    end
+    super
+  end
+end
+