rhodes 0.1.0

data/lib/rhom/rhom_object.rb

@@ -0,0 +1,53 @@
+#
+#  rhom_object.rb
+#  rhodes
+#
+#  Copyright (C) 2008 Lars Burgess. All rights reserved.
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+module Rhom
+  module RhomObject
+    # defines a method at runtime for the
+    # dynamically created class
+    
+    
+    # we override method_missing here so that instance variables,
+    # when retrieved or set, are added to the object
+    def method_missing(name, *args)
+      unless name == Fixnum
+        varname = name.to_s.gsub(/=/,"")
+        if instance_variable_defined? "@#{varname}"
+          #TODO: Figure out why this returns an array
+          instance_variable_get( "@#{varname}" )[0]
+        else  
+          instance_variable_set( "@#{varname}", args )  
+        end
+      end
+    end
+  
+    def strip_braces(str=nil)
+      str ? str.gsub(/\{/,"").gsub(/\}/,"") : nil
+    end
+  
+    # use djb hash function to generate temp object id
+    def djb_hash(str, len)
+      hash = 5381
+      for i in (0..len) 
+        hash = ((hash << 5) + hash) + str[i].to_i
+      end
+      return hash
+    end
+  end # RhomObject
+end # Rhom

data/lib/rhom/rhom_object_factory.rb

@@ -0,0 +1,246 @@
+#
+#  rhom_object_factory.rb
+#  rhodes
+#  Returns an array of RhomObjects
+#
+#  Copyright (C) 2008 Lars Burgess. All rights reserved.
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+require 'rhom'
+require 'rho'
+
+module Rhom
+  class RhomObjectFactory
+    
+    def initialize
+	    unless not defined? Rho::RhoConfig::sources
+  	    init_source_attribs
+  	    init_objects
+  	  end
+    end
+	
+	  def init_source_attribs
+  	  # merge source attributes into config hash
+  	  # TODO: This shouldn't reference 'source[1]' directly
+  	  Rho::RhoConfig::sources.each do |source|
+  	    src_attribs = ::Rhom::RhomDbAdapter::select_from_table(::Rhom::TABLE_NAME,
+  	                                                         'attrib',
+  	                                                         {"source_id"=>source[1]['source_id'].to_s},
+  	                                                         {"distinct"=>true})
+  	    # update our source with the proper attributes
+  		  source[1].merge!({"attribs"=>src_attribs})
+  	  end
+  	end
+  
+    # Initialize new object with dynamic attributes
+    def init_objects
+      Rho::RhoConfig::sources.each do |classname,source|
+        unless Object::const_defined?(classname.intern)
+          Object::const_set(classname.intern, 
+            Class::new do
+              include ::Rhom::RhomObject
+              extend ::Rhom::RhomObject
+          
+              def initialize(obj=nil)
+                if obj
+                  # create a temp id for the create type
+                  # TODO: This is duplicative of get_new_obj
+                  temp_objid = djb_hash(obj.values.to_s, 10).to_s
+                  self.send 'object'.to_sym, "#{temp_objid}"
+                  self.send 'source_id'.to_sym, obj['source_id'].to_s
+                  self.send 'update_type'.to_sym, 'create'
+                  obj.each do |key,value|
+					          val =  self.inst_strip_braces(value)
+                    self.send key, val
+                  end
+                end
+            
+              end
+		  
+              class << self
+              
+                def get_source_id
+                  Rho::RhoConfig::sources[self.name.to_s]['source_id'].to_s
+                end
+                # retrieve a single record if object id provided, otherwise return
+                # full list corresponding to factory's source id
+                def find(*args)
+                  list = []
+                  if args.first == :all
+                    result = ::Rhom::RhomDbAdapter::select_from_table(::Rhom::TABLE_NAME,
+                                                              '*',
+                                                              {"source_id"=>get_source_id,"update_type"=>'query'},
+                                                              {"order by"=>'object'})
+                  else
+                    obj = strip_braces(args.first.to_s)
+                    result = ::Rhom::RhomDbAdapter::select_from_table(::Rhom::TABLE_NAME,
+                                                              '*',
+                                                              {"object"=>obj})
+                  end
+                  list = get_list(result)
+                  if list.length == 1
+                    return list[0]
+                  end
+                  list
+                end
+              
+                def find_by(*args)
+                  # TODO: implement
+                end
+
+                # returns an array of objects based on an existing array
+                def get_list(objs)
+                  new_list = []
+                  if objs and defined? Rho::RhoConfig::sources[self.name.to_s]
+                    attrib_length = Rho::RhoConfig::sources[self.name.to_s]['attribs'].length
+                    list_length = 0
+                    list_length = (objs.length / attrib_length) unless attrib_length == 0
+                    new_obj = nil
+                    # iterate over the array and determine object
+                    # structure based on attribute/value pairs
+                    list_length.times do |i|
+                      new_obj = get_new_obj(objs[i*attrib_length])
+                      attrib_length.times do |j|
+                        # setup index and assign accessors
+                        idx = i*attrib_length+j
+                        begin
+                          # only update attributes if they belong
+                          # to the current object
+                          if objs[idx]['object'] == strip_braces((new_obj.send 'object'.to_sym))
+                            attrib = objs[idx]['attrib'].to_s
+                            value = objs[idx]['value'].to_s
+                            new_obj.send attrib.to_sym, value
+                          end
+                        rescue
+                          puts "failed to reference objs[#{idx}]..."
+                        end
+                      end
+                      new_list << new_obj
+                    end
+                  else
+                    # source attributes are not initialized, 
+                    # try again
+                    RhomObjectFactory::init_sources
+                  end
+                  new_list
+                end
+  
+                # returns new model instance with a temp object id
+                def get_new_obj(obj, type='query')
+                  tmp_obj = self.new
+                  tmp_obj.send 'object'.to_sym, "{#{obj['object'].to_s}}"
+                  tmp_obj.send 'source_id'.to_sym, get_source_id
+                  tmp_obj.send 'update_type'.to_sym, type
+                  tmp_obj
+                end
+              end #class methods
+	
+              # deletes the record from the viewable list as well as
+              # adding a delete record to the list of sync operations
+              def destroy
+                result = nil
+                obj = self.inst_strip_braces(self.object)
+                if obj
+                  # first delete the record from viewable list
+                  result = ::Rhom::RhomDbAdapter::delete_from_table(::Rhom::TABLE_NAME,
+                                                            {"object"=>obj})
+                  # now add delete operation
+                  result = ::Rhom::RhomDbAdapter::insert_into_table(::Rhom::TABLE_NAME,
+                                                            {"source_id"=>self.get_inst_source_id,
+                                                             "object"=>obj,
+                                                             "update_type"=>'delete'})
+                end
+                result
+              end
+		
+              # saves the current object to the database as a create type
+              def save
+                result = nil
+                # iterate over each instance variable and insert create row to table
+				        obj = self.inst_strip_braces(self.object)
+                self.instance_variables.each do |method|
+                  method = method.to_s.gsub(/@/,"")
+                  # Don't save objects with braces to database
+                  val = self.inst_strip_braces(self.send(method.to_sym))
+                  # add rows excluding object, source_id and update_type
+                  unless self.method_name_reserved?(method) or val.nil?
+                    result = ::Rhom::RhomDbAdapter::insert_into_table(::Rhom::TABLE_NAME,
+                                                              {"source_id"=>self.get_inst_source_id,
+                                                               "object"=>obj,
+                                                               "attrib"=>method,
+                                                               "value"=>val,
+                                                               "update_type"=>'create'})
+                  end
+                end
+                # Create a temporary query record to display in the list
+                Rho::RhoConfig::sources[self.class.name.to_s]['attribs'].each do |attrib|
+                  result = ::Rhom::RhomDbAdapter::insert_into_table(::Rhom::TABLE_NAME,
+                                                            {"source_id"=>self.get_inst_source_id,
+                                                             "object"=>obj,
+                                                             "attrib"=>attrib['attrib'],
+                                                             "value"=>self.send(attrib['attrib'].to_sym),
+                                                             "update_type"=>'query'})
+                end
+                result
+              end
+          
+              # updates the current record in the viewable list and adds
+              # a sync operation to update
+              def update_attributes(attrs)
+                result = nil
+                obj = self.inst_strip_braces(self.object)
+                self.instance_variables.each do |method|
+                  method = method.to_s.gsub(/@/,"")
+                  val = self.send method.to_sym
+                  # Don't save objects with braces to database
+                  new_val = self.inst_strip_braces(attrs[method])
+                  # if the object's value doesn't match the database record
+                  # then we procede with update
+                  if new_val and val != new_val
+                    unless self.method_name_reserved?(method) or new_val.length == 0
+                      # update viewable list
+                      result = ::Rhom::RhomDbAdapter::update_into_table(::Rhom::TABLE_NAME,
+                                                                {"value"=>new_val},
+                                                                {"object"=>obj, "attrib"=>method})
+                      # update sync list
+                      result = ::Rhom::RhomDbAdapter::insert_into_table(::Rhom::TABLE_NAME,
+                                                                {"source_id"=>self.get_inst_source_id,
+                                                                 "object"=>obj,
+                                                                 "attrib"=>method,
+                                                                 "value"=>new_val,
+                                                                 "update_type"=>'update'})
+                    end
+                  end
+                end
+                result
+              end
+	
+              def get_inst_source_id
+                Rho::RhoConfig::sources[self.class.name.to_s]['source_id'].to_s
+              end
+              
+              def inst_strip_braces(str=nil)
+                str ? str.gsub(/\{/,"").gsub(/\}/,"") : nil
+              end
+            
+              def method_name_reserved?(method)
+                method =~ /object|source_id|update_type/
+              end
+            end)
+        end
+      end
+    end
+  end # RhomObjectFactory
+end # Rhom

data/lib/singleton.rb

@@ -0,0 +1,313 @@
+# The Singleton module implements the Singleton pattern.
+#
+# Usage:
+#    class Klass
+#       include Singleton
+#       # ...
+#    end
+#
+# *  this ensures that only one instance of Klass lets call it
+#    ``the instance'' can be created.
+#
+#    a,b  = Klass.instance, Klass.instance
+#    a == b   # => true
+#    a.new    #  NoMethodError - new is private ...
+#
+# *  ``The instance'' is created at instantiation time, in other
+#    words the first call of Klass.instance(), thus
+#
+#      class OtherKlass
+#        include Singleton
+#        # ...
+#      end
+#      ObjectSpace.each_object(OtherKlass){} # => 0.
+#
+# *  This behavior is preserved under inheritance and cloning.
+#
+#
+#
+# This is achieved by marking
+# *  Klass.new and Klass.allocate - as private
+#
+# Providing (or modifying) the class methods
+# *  Klass.inherited(sub_klass) and Klass.clone()  -
+#    to ensure that the Singleton pattern is properly
+#    inherited and cloned.
+#
+# *  Klass.instance()  -  returning ``the instance''. After a
+#    successful self modifying (normally the first) call the
+#    method body is a simple:
+#
+#       def Klass.instance()
+#         return @singleton__instance__
+#       end
+#
+# *  Klass._load(str)  -  calling Klass.instance()
+#
+# *  Klass._instantiate?()  -  returning ``the instance'' or
+#    nil. This hook method puts a second (or nth) thread calling
+#    Klass.instance() on a waiting loop. The return value
+#    signifies the successful completion or premature termination
+#    of the first, or more generally, current "instantiation thread".
+#
+#
+# The instance method of Singleton are
+# * clone and dup - raising TypeErrors to prevent cloning or duping
+#
+# *  _dump(depth) - returning the empty string.  Marshalling strips
+#    by default all state information, e.g. instance variables and
+#    taint state, from ``the instance''.  Providing custom _load(str)
+#    and _dump(depth) hooks allows the (partially) resurrections of
+#    a previous state of ``the instance''.
+
+require 'thread'
+
+module Singleton
+  #  disable build-in copying methods
+  def clone
+    raise TypeError, "can't clone instance of singleton #{self.class}"
+  end
+  def dup
+    raise TypeError, "can't dup instance of singleton #{self.class}"
+  end
+
+  #  default marshalling strategy
+  def _dump(depth = -1)
+    ''
+  end
+
+  module SingletonClassMethods
+    # properly clone the Singleton pattern - did you know
+    # that duping doesn't copy class methods?
+    def clone
+      Singleton.__init__(super)
+    end
+
+    def _load(str)
+      instance
+    end
+
+    private
+
+    #  ensure that the Singleton pattern is properly inherited
+    def inherited(sub_klass)
+      super
+      Singleton.__init__(sub_klass)
+    end
+  end
+
+  class << Singleton
+    def __init__(klass)
+      klass.instance_eval {
+        @singleton__instance__ = nil
+        @singleton__mutex__ = Mutex.new
+      }
+      def klass.instance
+        return @singleton__instance__ if @singleton__instance__
+        @singleton__mutex__.synchronize {
+          return @singleton__instance__ if @singleton__instance__
+          @singleton__instance__ = new()
+        }
+        @singleton__instance__
+      end
+      klass
+    end
+
+    private
+
+    #  extending an object with Singleton is a bad idea
+    undef_method :extend_object
+
+    def append_features(mod)
+      #  help out people counting on transitive mixins
+      unless mod.instance_of?(Class)
+        raise TypeError, "Inclusion of the OO-Singleton module in module #{mod}"
+      end
+      super
+    end
+
+    def included(klass)
+      super
+      klass.private_class_method  :new, :allocate
+      klass.extend SingletonClassMethods
+      Singleton.__init__(klass)
+    end
+  end
+
+end
+
+
+if __FILE__ == $0
+
+def num_of_instances(klass)
+    "#{ObjectSpace.each_object(klass){}} #{klass} instance(s)"
+end
+
+# The basic and most important example.
+
+class SomeSingletonClass
+  include Singleton
+end
+puts "There are #{num_of_instances(SomeSingletonClass)}"
+
+a = SomeSingletonClass.instance
+b = SomeSingletonClass.instance # a and b are same object
+puts "basic test is #{a == b}"
+
+begin
+  SomeSingletonClass.new
+rescue  NoMethodError => mes
+  puts mes
+end
+
+
+
+puts "\nThreaded example with exception and customized #_instantiate?() hook"; p
+Thread.abort_on_exception = false
+
+class Ups < SomeSingletonClass
+  def initialize
+    self.class.__sleep
+    puts "initialize called by thread ##{Thread.current[:i]}"
+  end
+end
+
+class << Ups
+  def _instantiate?
+    @enter.push Thread.current[:i]
+    while false.equal?(@singleton__instance__)
+      @singleton__mutex__.unlock
+      sleep 0.08
+      @singleton__mutex__.lock
+    end
+    @leave.push Thread.current[:i]
+    @singleton__instance__
+  end
+
+  def __sleep
+    sleep(rand(0.08))
+  end
+
+  def new
+    begin
+      __sleep
+      raise  "boom - thread ##{Thread.current[:i]} failed to create instance"
+    ensure
+      # simple flip-flop
+      class << self
+        remove_method :new
+      end
+    end
+  end
+
+  def instantiate_all
+    @enter = []
+    @leave = []
+    1.upto(9) {|i|
+      Thread.new {
+        begin
+          Thread.current[:i] = i
+          __sleep
+          instance
+        rescue RuntimeError => mes
+          puts mes
+        end
+      }
+    }
+    puts "Before there were #{num_of_instances(self)}"
+    sleep 3
+    puts "Now there is #{num_of_instances(self)}"
+    puts "#{@enter.join '; '} was the order of threads entering the waiting loop"
+    puts "#{@leave.join '; '} was the order of threads leaving the waiting loop"
+  end
+end
+
+
+Ups.instantiate_all
+# results in message like
+# Before there were 0 Ups instance(s)
+# boom - thread #6 failed to create instance
+# initialize called by thread #3
+# Now there is 1 Ups instance(s)
+# 3; 2; 1; 8; 4; 7; 5 was the order of threads entering the waiting loop
+# 3; 2; 1; 7; 4; 8; 5 was the order of threads leaving the waiting loop
+
+
+puts "\nLets see if class level cloning really works"
+Yup = Ups.clone
+def Yup.new
+  begin
+    __sleep
+    raise  "boom - thread ##{Thread.current[:i]} failed to create instance"
+  ensure
+    # simple flip-flop
+    class << self
+      remove_method :new
+    end
+  end
+end
+Yup.instantiate_all
+
+
+puts "\n\n","Customized marshalling"
+class A
+  include Singleton
+  attr_accessor :persist, :die
+  def _dump(depth)
+    # this strips the @die information from the instance
+    Marshal.dump(@persist,depth)
+  end
+end
+
+def A._load(str)
+  instance.persist = Marshal.load(str)
+  instance
+end
+
+a = A.instance
+a.persist = ["persist"]
+a.die = "die"
+a.taint
+
+stored_state = Marshal.dump(a)
+# change state
+a.persist = nil
+a.die = nil
+b = Marshal.load(stored_state)
+p a == b  #  => true
+p a.persist  #  => ["persist"]
+p a.die      #  => nil
+
+
+puts "\n\nSingleton with overridden default #inherited() hook"
+class Up
+end
+def Up.inherited(sub_klass)
+  puts "#{sub_klass} subclasses #{self}"
+end
+
+
+class Middle < Up
+  include Singleton
+end
+
+class Down < Middle; end
+
+puts  "and basic \"Down test\" is #{Down.instance == Down.instance}\n
+Various exceptions"
+
+begin
+  module AModule
+    include Singleton
+  end
+rescue TypeError => mes
+  puts mes  #=> Inclusion of the OO-Singleton module in module AModule
+end
+
+begin
+  'aString'.extend Singleton
+rescue NoMethodError => mes
+  puts mes  #=> undefined method `extend_object' for Singleton:Module
+end
+
+end