rhodes 0.3.0 → 1.0.0

data/lib/rhom/rhom_db_adapterME.rb

@@ -1,93 +0,0 @@
-#
-#  rhom_db_adapter.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/>.
-#
-require 'rhodes'
-
-module Rhom
-  class RhomDbAdapter
-    
-    @@database = nil
-    
-    class << self
-      def open(dbfile=nil)
-        puts "DB name = " + dbfile.inspect
-        unless @@database or dbfile.nil?
-			db = DbAdapter.new(Rhodes::DBVERSION)
-			@@database = db
-        end
-		
-      end
-    
-      def close
-        if @@database and not @@database.closed?
-          @@database.close
-          @@database = nil
-        else
-          return false
-        end
-        return true
-      end   
-    
-      # execute a sql statement
-      # optionally, disable the factory processing 
-      # which returns the result array directly
-      def execute_sql
-        result = []
-		  # Make sure we lock the sync engine's mutex
-		  # before we perform a database transaction.
-		  # This prevents concurrency issues.
-		  begin
-			SyncEngine::lock_sync_mutex
-			result = yield
-			SyncEngine::unlock_sync_mutex
-		  rescue Exception => e
-			puts "exception when running query: #{e}"
-			# make sure we unlock even if there's an error!
-			SyncEngine::unlock_sync_mutex
-		  end
-        puts "returned #{result.length.to_s} records..."
-        result
-      end
-    
-      def select_from_table(table=nil,columns=nil,condition=nil,params=nil)
-	    execute_sql { @@database.selectFromTable(table, columns, condition, params) }
-      end
-    
-      def insert_into_table(table=nil,values=nil)
-	    execute_sql { @@database.insertIntoTable(table, values) }
-      end
-    
-      def delete_from_table(table=nil,condition=nil)
-	    execute_sql { @@database.deleteFromTable(table, condition) }
-	  end
-    
-      def delete_all_from_table(table=nil)
-	    execute_sql { @@database.deleteAllFromTable(table) }
-	  end
-    
-      def update_into_table(table=nil,values=nil,condition=nil)
-		execute_sql { @@database.updateIntoTable(table, values, condition) }
-	  end
-    end # class methods
-  end # RhomDbAdapter
-end # Rhom
-
-at_exit do
-	Rhom::RhomDbAdapter::close
-end

data/lib/rhom/rhom_object.rb

@@ -1,65 +0,0 @@
-#
-#  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(/=/,"")
-        setting = (name.to_s =~ /=/)
-        inst_var = nil
-
-        if setting
-          inst_var = instance_variable_set( "@#{varname}", args[0] )  
-        else
-          inst_var = instance_variable_get( "@#{varname}" )
-        end
-        
-        inst_var
-      end
-    end
-    
-    def remove_var(name)
-      remove_instance_variable("@#{name}")
-    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
-    
-    def method_name_reserved?(method)
-      method =~ /object|source_id|update_type|type/
-    end
-  end # RhomObject
-end # Rhom

data/lib/rhom/rhom_object_factory.rb

@@ -1,197 +0,0 @@
-#
-#  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_objects
-  	  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}=".to_sym(), 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 = []
-                  hash_list = {}
-                  conditions = {}
-
-                  # first find all query objects
-                  if args.first == :all
-                    conditions = {"source_id"=>get_source_id}
-                  else
-                    conditions = {"object"=>strip_braces(args.first.to_s)}
-                  end
-                  
-                  # process query, create, and update lists in order
-                  ["query", "create", "update"].each do |update_type|
-                    conditions.merge!({"update_type"=>update_type})
-                    objs = ::Rhom::RhomDbAdapter::select_from_table(::Rhom::TABLE_NAME, '*', conditions,
-                                                                    {"order by"=>'object'})
-                    objs.collect! do |obj|
-                      object = obj['object']
-                      attrib = obj['attrib']
-                      value = obj['value']
-                      hash_list[object] = get_new_obj(obj) if not hash_list[object]
-                      if not method_name_reserved?(attrib) and hash_list[object].send(attrib.to_sym)
-                        hash_list[object].remove_var(attrib)
-                      end
-                      hash_list[object].send("#{attrib}=".to_sym(), value) if not method_name_reserved?(attrib)
-                      nil # remove the element from the array
-                    end
-                  end
-
-                  # convert hash to array
-                  list = hash_list.values
-                  hash_list = nil
-                  if list.length == 1 and args.first != :all
-                    return list[0]
-                  end
-                  list
-                end
-              
-                def find_by(*args)
-                  # TODO: implement
-                end
-  
-                private
-                # 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
-                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
-                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 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
-            end)
-        end
-      end
-    end
-  end # RhomObjectFactory
-end # Rhom

data/lib/rhom/rhom_source.rb

@@ -1,60 +0,0 @@
-require 'time'
-require 'rhom/rhom_object'
-
-module Rhom
-  class RhomSource
-    include RhomObject
-    attr_accessor :source_url
-    attr_reader   :source_id, :name, :last_updated, :last_inserted_size, 
-                  :last_deleted_size, :last_sync_duration,
-                  :last_sync_success, :distinct_objects
-                  
-    def initialize(args,count=0)
-      # setup the name
-      # TODO: should really store this in the database
-      Rho::RhoConfig::sources.each do |key,value|
-        if value['source_id'].to_i == args['source_id'].to_i
-          @name = key
-        end
-      end
-      @source_id = args['source_id'].to_i
-      @source_url = args['source_url']
-      @last_updated = Time.at(args['last_updated'].to_i).to_s
-      @last_inserted_size = args['last_inserted_size'].to_i
-      @last_deleted_size = args['last_deleted_size'].to_i
-      @last_sync_duration = args['last_sync_duration'].to_i
-      @last_sync_success = args['last_sync_success'].to_i == 1 ? true : false
-      @distinct_objects = ::Rhom::RhomDbAdapter::select_from_table(
-                                                             ::Rhom::TABLE_NAME,
-                                                             'object',
-                                                             {"source_id"=>@source_id},
-                                                             {"distinct"=>true}).length
-    end
-    
-    class << self
-      include RhomObject
-      def find(*args)
-        list = []
-        if args.first == :all
-          results = ::Rhom::RhomDbAdapter::select_from_table('sources', '*')
-          
-          results.each do |result|
-            list << RhomSource.new(result)
-          end
-        else
-          result = ::Rhom::RhomDbAdapter::select_from_table('sources', '*', 
-                                                            {"source_id" => strip_braces(args.first)}).first
-          list << RhomSource.new(result)
-        end
-        list.size > 1 ? list : list[0]
-      end
-    end
-    
-    def update_attributes(params=nil)
-      if params
-        ::Rhom::RhomDbAdapter::update_into_table('sources', {"source_url"=>params['source_url']},
-                                                 {"source_id"=>strip_braces(params['source_id'])})
-      end
-    end
-  end
-end

data/lib/singleton.rb

@@ -1,137 +0,0 @@
-# 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