knjrbfw 0.0.7 → 0.0.8

data/lib/knj/mutexcl.rb

@@ -1,7 +1,7 @@
 class Knj::Mutexcl
   def initialize(args = {})
     @args = args
-    raise "No ':modes' given in arguments." if !@args.has_key?(:modes)
+    raise "No ':modes' given in arguments." if !@args.key?(:modes)
     @mutex = Mutex.new
     @blocked = {}
     @args[:modes].each do |mode, data|
@@ -24,7 +24,7 @@ class Knj::Mutexcl
   end
   
   def sync(mode)
-    raise "No such mode: '#{mode}'." if !@args[:modes].has_key?(mode)
+    raise "No such mode: '#{mode}'." if !@args[:modes].key?(mode)
     
     while @blocked[mode][:count].to_i > 0
       STDOUT.print "Sleeping because blocked '#{mode}' (#{@blocked[mode][:count]}).\n"

data/lib/knj/objects.rb

@@ -1,5 +1,5 @@
 class Knj::Objects
-	attr_reader :args, :events
+	attr_reader :args, :events, :data
 	
 	def initialize(args)
 		@callbacks = {}
@@ -7,7 +7,11 @@ class Knj::Objects
 		@args[:col_id] = :id if !@args[:col_id]
 		@args[:class_pre] = "class_" if !@args[:class_pre]
 		@args[:module] = Kernel if !@args[:module]
+		@args[:cache] = :weak if !@args.key?(:cache)
 		@objects = {}
+		@data = {}
+		
+		require "weakref" if @args[:cache] == :weak
 		
 		@events = Knj::Event_handler.new
 		@events.add_event(
@@ -20,11 +24,30 @@ class Knj::Objects
 		)
 		
 		raise "No DB given." if !@args[:db]
-		raise "No class path given." if !@args[:class_path] and (@args[:require] or !@args.has_key?(:require))
+		raise "No class path given." if !@args[:class_path] and (@args[:require] or !@args.key?(:require))
+		
+		if args[:require_all]
+      loads = []
+      
+      Dir.foreach(@args[:class_path]) do |file|
+        next if file == "." or file == ".." or !file.match(/\.rb$/)
+        file_parsed = file
+        file_parsed.gsub!(@args[:class_pre], "") if @args.key?(:class_pre)
+        file_parsed.gsub!(/\.rb$/, "")
+        file_parsed = Knj::Php.ucwords(file_parsed)
+        
+        loads << file_parsed
+        self.requireclass(file_parsed, {:load => false})
+      end
+      
+      loads.each do |load_class|
+        self.load_class(load_class)
+      end
+		end
 	end
 	
 	def init_class(classname)
-    return false if @objects.has_key?(classname)
+    return false if @objects.key?(classname)
     @objects[classname] = {}
 	end
 	
@@ -54,7 +77,7 @@ class Knj::Objects
 	
 	def connect(args, &block)
 		raise "No object given." if !args["object"]
-		raise "No signals given." if !args.has_key?("signal") and !args.has_key?("signals")
+		raise "No signals given." if !args.key?("signal") and !args.key?("signals")
 		args["block"] = block if block_given?
 		@callbacks[args["object"]] = {} if !@callbacks[args["object"]]
 		conn_id = @callbacks[args["object"]].length.to_s
@@ -64,11 +87,11 @@ class Knj::Objects
 	def call(args, &block)
 		classstr = args["object"].class.to_s
 		
-		if @callbacks[classstr]
+		if @callbacks.key?(classstr)
 			@callbacks[classstr].clone.each do |callback_key, callback|
 				docall = false
 				
-				if callback.has_key?("signal") and args.has_key?("signal") and callback["signal"] == args["signal"]
+				if callback.key?("signal") and args.key?("signal") and callback["signal"] == args["signal"]
 					docall = true
 				elsif callback["signals"] and args["signal"] and callback["signals"].index(args["signal"]) != nil
 					docall = true
@@ -97,52 +120,103 @@ class Knj::Objects
 		end
 	end
 	
-	def requireclass(classname)
+	def requireclass(classname, args = {})
     classname = classname.to_sym
     
-    if !@args[:require] and @args.has_key?(:require)
-      @objects[classname] = {} if !@objects.has_key?(classname)
-      return nil
-    end
-    
-		if !@objects.has_key?(classname)
-			filename = @args[:class_path] + "/#{@args[:class_pre]}#{classname.downcase}.rb"
-			filename_req = @args[:class_path] + "/#{@args[:class_pre]}#{classname.downcase}"
-			raise "Class file could not be found: #{filename}." if !File.exists?(filename)
-			require filename_req
-			@args[:module].const_get(classname).load_columns(Knj::Hash_methods.new(:args => args, :ob => self, :db => @args[:db]))
+		if !@objects.key?(classname)
+      if (@args[:require] or !@args.key?(:require)) and (!args.key?(:require) or args[:require])
+        filename = "#{@args[:class_path]}/#{@args[:class_pre]}#{classname.to_s.downcase}.rb"
+        filename_req = "#{@args[:class_path]}/#{@args[:class_pre]}#{classname.to_s.downcase}"
+        raise "Class file could not be found: #{filename}." if !File.exists?(filename)
+        require filename_req
+      end
+      
+      if args[:class]
+        classob = args[:class]
+      else
+        classob = @args[:module].const_get(classname)
+      end
+			
+			if (classob.respond_to?(:load_columns) or classob.respond_to?(:datarow_init)) and (!args.key?(:load) or args[:load])
+        self.load_class(classname, args)
+			end
+			
 			@objects[classname] = {}
 		end
 	end
 	
+	def load_class(classname, args = {})
+    if args[:class]
+      classob = args[:class]
+    else
+      classob = @args[:module].const_get(classname)
+    end
+    
+    pass_arg = Knj::Hash_methods.new(:ob => self, :db => @args[:db])
+    classob.load_columns(pass_arg) if classob.respond_to?(:load_columns)
+    classob.datarow_init(pass_arg) if classob.respond_to?(:datarow_init)
+	end
+	
 	def get(classname, data)
 		classname = classname.to_sym
 		
-		if data.is_a?(Hash) and data[@args[:col_id].to_sym]
+		if data.is_a?(Integer) or data.is_a?(String) or data.is_a?(Fixnum)
+      id = data.to_i
+		elsif data.is_a?(Hash) and data[@args[:col_id].to_sym]
 			id = data[@args[:col_id].to_sym].to_i
 		elsif data.is_a?(Hash) and data[@args[:col_id].to_s]
 			id = data[@args[:col_id].to_s].to_i
-		elsif data.is_a?(Integer) or data.is_a?(String) or data.is_a?(Fixnum)
-			id = data.to_i
 		elsif
 			raise Knj::Errors::InvalidData, "Unknown data: '#{data.class.to_s}'."
 		end
 		
-    return @objects[classname][id] if @objects.has_key?(classname) and @objects[classname].has_key?(id)
-    self.requireclass(classname) if !@objects.has_key?(classname)
+		if @objects.key?(classname) and @objects[classname].key?(id)
+      case @args[:cache]
+        when :weak
+          begin
+            obj = @objects[classname][id]
+            obj = obj.__getobj__ if obj.is_a?(WeakRef)
+            
+            #This actually happens sometimes... WTF!? - knj
+            if obj.is_a?(Knj::Datarow) and obj.respond_to?(:table) and obj.respond_to?(:id) and obj.table.to_sym == classname and obj.id.to_i == id
+              return obj
+            else
+              raise WeakRef::RefError
+            end
+          rescue WeakRef::RefError
+            @objects[classname].delete(id)
+          end
+        else
+          return @objects[classname][id]
+      end
+    end
+    
+    self.requireclass(classname) if !@objects.key?(classname)
     
     if @args[:datarow]
-      @objects[classname][id] = @args[:module].const_get(classname).new(Knj::Hash_methods.new(
-        :ob => self,
-        :data => data
-      ))
+      obj = @args[:module].const_get(classname).new(Knj::Hash_methods.new(:ob => self, :data => data))
     else
       args = [data]
       args = args | @args[:extra_args] if @args[:extra_args]
-      @objects[classname][id] = @args[:module].const_get(classname).new(*args)
+      obj = @args[:module].const_get(classname).new(*args)
     end
     
-    return @objects[classname][id]
+    case @args[:cache]
+      when :weak
+        @objects[classname][id] = WeakRef.new(obj)
+      else
+        @objects[classname][id] = obj
+    end
+    
+    return obj
+	end
+	
+	def object_finalizer(id)
+    classname = @objects_idclass[id]
+    if classname
+      @objects[classname].delete(id)
+      @objects_idclass.delete(id)
+    end
 	end
 	
 	def get_by(classname, args = {})
@@ -245,9 +319,9 @@ class Knj::Objects
 				elsif object.respond_to?(:data)
 					obj_data = object.data
 					
-					if obj_data.has_key?(:name)
+					if obj_data.key?(:name)
 						objhtml = obj_data[:name]
-					elsif obj_data.has_key?(:title)
+					elsif obj_data.key?(:title)
 						objhtml = obj_data[:title]
 					end
 				else
@@ -333,7 +407,7 @@ class Knj::Objects
 			
 			required_data = classobj.required_data
 			required_data.each do |req_data|
-        if !data.has_key?(req_data[:col])
+        if !data.key?(req_data[:col])
           raise "No '#{req_data[:class]}' given by the data '#{req_data[:col]}'."
         end
         
@@ -419,9 +493,9 @@ class Knj::Objects
 		
 		classname = classname.to_sym
 		
-		#if !@objects.has_key?(classname)
+		#if !@objects.key?(classname)
 			#raise "Could not find object class in cache: #{classname}."
-		#elsif !@objects[classname].has_key?(object.id.to_i)
+		#elsif !@objects[classname].key?(object.id.to_i)
 			#errstr = ""
 			#errstr += "Could not unset object from cache.\n"
 			#errstr += "Class: #{object.class.name}.\n"
@@ -444,7 +518,7 @@ class Knj::Objects
 		
 		classname = classname.to_sym
 		
-		return false if !@objects.has_key?(classname)
+		return false if !@objects.key?(classname)
     @objects[classname] = {}
 	end
 	
@@ -497,18 +571,22 @@ class Knj::Objects
 	
 	# Try to clean up objects by unsetting everything, start the garbagecollector, get all the remaining objects via ObjectSpace and set them again. Some (if not all) should be cleaned up and our cache should still be safe... dirty but works.
 	def clean(classn)
+    return false if @args[:cache] == :weak
+    
 		if classn.is_a?(Array)
 			classn.each do |realclassn|
 				self.clean(realclassn)
 			end
 		else
-			return false if !@objects.has_key?(classn)
+			return false if !@objects.key?(classn)
       @objects[classn] = {}
       GC.start
 		end
 	end
 	
 	def clean_all
+    return false if @args[:cache] == :weak
+    
 		classnames = []
     @objects.keys.each do |classn|
       classnames << classn
@@ -522,55 +600,65 @@ class Knj::Objects
 	end
 	
 	def clean_recover
+    return false if @args[:cache] == :weak
+    return false if RUBY_ENGINE == "jruby" and !JRuby.objectspace
+    
     @objects.keys.each do |classn|
       data = @objects[classn]
-      classobj = Kernel.const_get(classn)
+      classobj = @args[:module].const_get(classn)
       ObjectSpace.each_object(classobj) do |obj|
-        data[obj.id] = obj
+        begin
+          data[obj.id.to_i] = obj
+        rescue => e
+          if e.message == "No data on object."
+            #Object has been unset - skip it.
+            next
+          end
+          
+          raise e
+        end
       end
     end
 	end
 	
-	def sqlhelper(list_args, args)
+	def sqlhelper(list_args, args_def)
 		if args[:db]
 			db = args[:db]
 		else
 			db = @args[:db]
 		end
 		
+		args = args_def
+		
 		if args[:table]
-			table = "`#{db.esc_table(args[:table])}`."
+			table_def = "`#{db.esc_table(args[:table])}`."
 		else
-			table = ""
+			table_def = ""
 		end
 		
+		sql_joins = ""
 		sql_where = ""
 		sql_order = ""
 		sql_limit = ""
 		
+		do_joins = {}
+		
 		limit_from = nil
 		limit_to = nil
 		
-		cols_str_has = args.has_key?(:cols_str)
-		cols_num_has = args.has_key?(:cols_num)
-		cols_date_has = args.has_key?(:cols_date)
-		cols_dbrows_has = args.has_key?(:cols_dbrows)
-		cols_bools_has = args.has_key?(:cols_bools)
-		
-		if list_args.has_key?("orderby")
+		if list_args.key?("orderby")
 			orders = []
 			orderstr = list_args["orderby"]
+			list_args["orderby"] = [list_args["orderby"]] if list_args["orderby"].is_a?(Hash)
 			
 			if list_args["orderby"].is_a?(String)
 				found = false
-				found = true if !found and cols_str_has and args[:cols_str].index(orderstr) != nil
-				found = true if !found and cols_date_has and args[:cols_date].index(orderstr) != nil
-				found = true if !found and cols_num_has and args[:cols_num].index(orderstr) != nil
+				found = true if args[:cols].key?(orderstr)
 				
 				if found
 					sql_order += " ORDER BY "
 					ordermode = " ASC"
-					if list_args.has_key?("ordermode")
+					if list_args.key?("ordermode")
 						if list_args["ordermode"] == "desc"
 							ordermode = " DESC"
 						elsif list_args["ordermode"] == "asc"
@@ -581,16 +669,20 @@ class Knj::Objects
 						list_args.delete("ordermode")
 					end
 					
-					sql_order += "#{table}`#{db.esc_col(list_args["orderby"])}`#{ordermode}"
+					sql_order += "#{table_def}`#{db.esc_col(list_args["orderby"])}`#{ordermode}"
 					list_args.delete("orderby")
 				end
 			elsif list_args["orderby"].is_a?(Array)
 				sql_order += " ORDER BY "
 				
 				list_args["orderby"].each do |val|
+          ordermode = nil
+          orderstr = nil
+          found = false
+          
 					if val.is_a?(Array)
 						orderstr = val[0]
-						
+            
 						if val[1] == "asc"
 							ordermode = " ASC"
 						elsif val[1] == "desc"
@@ -599,18 +691,32 @@ class Knj::Objects
 					elsif val.is_a?(String)
 						orderstr = val
 						ordermode = " ASC"
+          elsif val.is_a?(Hash)
+            raise "No joined tables." if !args.key?(:joined_tables)
+            
+            if val[:mode] == "asc"
+              ordermode = " ASC"
+            elsif val[:mode] == "desc"
+              ordermode = " DESC"
+            end
+            
+            if args[:joined_tables]
+              args[:joined_tables].each do |table_name, table_data|
+                if table_name.to_s == val[:table]
+                  do_joins[table_name] = true
+                  orders << "`#{db.esc_table(table_name)}`.`#{db.esc_col(val[:col])}`#{ordermode}"
+                  found = true
+                  break
+                end
+              end
+            end
 					else
 						raise "Unknown object: #{val.class.name}"
 					end
 					
-					found = false
-					found = true if !found and cols_str_has and args[:cols_str].index(orderstr) != nil
-					found = true if !found and cols_date_has and args[:cols_date].index(orderstr) != nil
-					found = true if !found and cols_num_has and args[:cols_num].index(orderstr) != nil
-					found = true if !found and cols_bools_has and args[:cols_bools].index(orderstr) != nil
-					
+					found = true if args[:cols].key?(orderstr)
 					raise "Column not found for ordering: #{orderstr}." if !found
-					orders << "#{table}`#{db.esc_col(orderstr)}`#{ordermode}"
+					orders << "#{table_def}`#{db.esc_col(orderstr)}`#{ordermode}" if orderstr
 				end
 				
 				sql_order += orders.join(", ")
@@ -620,10 +726,27 @@ class Knj::Objects
 			end
 		end
 		
-		list_args.each do |key, val|
+		list_args.each do |realkey, val|
 			found = false
 			
-			if (cols_str_has and args[:cols_str].index(key) != nil) or (cols_num_has and args[:cols_num].index(key) != nil) or (cols_dbrows_has and args[:cols_dbrows].index(key) != nil)
+			if realkey.is_a?(Array)
+        if !args[:joins_skip]
+          datarow_obj = self.datarow_obj_from_args(args_def, list_args, realkey[0])
+          args = datarow_obj.columns_sqlhelper_args
+        else
+          args = args_def
+        end
+        
+        do_joins[realkey[0].to_sym] = true
+        table = "`#{db.esc_table(realkey[0])}`."
+        key = realkey[1]
+      else
+        table = table_def
+        args = args_def
+        key = realkey
+      end
+			
+			if args[:cols].key?(key)
         if val.is_a?(Array)
           escape_sql = Knj::ArrayExt.join(
             :arr => val,
@@ -633,12 +756,23 @@ class Knj::Objects
             :sep => ",",
             :surr => "'")
           sql_where += " AND #{table}`#{db.esc_col(key)}` IN (#{escape_sql})"
+        elsif val.is_a?(Hash) and val[:type] == "col"
+          if !val.key?(:table)
+            Knj::Php.print_r(val)
+            raise "No table was given for join."
+          end
+          
+          do_joins[val[:table].to_sym] = true
+          sql_where += " AND #{table}`#{db.esc_col(key)}` = `#{db.esc_table(val[:table])}`.`#{db.esc_col(val[:name])}`"
+        elsif val.is_a?(Proc)
+          call_args = Knj::Hash_methods.new(:ob => self, :db => db)
+          sql_where += " AND #{table}`#{db.esc_col(key)}` = '#{db.esc(val.call(call_args))}'"
         else
           sql_where += " AND #{table}`#{db.esc_col(key)}` = '#{db.esc(val)}'"
         end
         
 				found = true
-			elsif cols_bools_has and args[:cols_bools].index(key) != nil
+			elsif args.key?(:cols_bools) and args[:cols_bools].index(key) != nil
 				if val.is_a?(TrueClass) or (val.is_a?(Integer) and val.to_i == 1) or (val.is_a?(String) and (val == "true" or val == "1"))
 					realval = "1"
 				elsif val.is_a?(FalseClass) or (val.is_a?(Integer) and val.to_i == 0) or (val.is_a?(String) and (val == "false" or val == "0"))
@@ -659,10 +793,10 @@ class Knj::Objects
 				limit_from = 0
 				limit_to = val.to_i
 				found = true
-			elsif cols_dbrows_has and args[:cols_dbrows].index(key.to_s + "_id") != nil
+			elsif args.key?(:cols_dbrows) and args[:cols_dbrows].index("#{key.to_s}_id") != nil
 				sql_where += " AND #{table}`#{db.esc_col(key.to_s + "_id")}` = '#{db.esc(val.id)}'"
 				found = true
-			elsif cols_str_has and match = key.match(/^([A-z_\d]+)_(search|has)$/) and args[:cols_str].index(match[1]) != nil
+			elsif args.key?(:cols_str) and match = key.match(/^([A-z_\d]+)_(search|has)$/) and args[:cols_str].index(match[1]) != nil
 				if match[2] == "search"
 					Knj::Strings.searchstring(val).each do |str|
 						sql_where += " AND #{table}`#{db.esc_col(match[1])}` LIKE '%#{db.esc(str)}%'"
@@ -676,24 +810,33 @@ class Knj::Objects
 				end
 				
 				found = true
-			elsif match = key.match(/^([A-z_\d]+)_not$/) and ((cols_str_has and args[:cols_str].index(match[1]) != nil) or (cols_num_has and args[:cols_num].index(match[1]) != nil))
-				sql_where += " AND #{table}`#{db.esc_col(match[1])}` != '#{db.esc(val)}'"
+			elsif match = key.match(/^([A-z_\d]+)_(not|lower)$/) and args[:cols].key?(match[1])
+        if match[2] == "not"
+          sql_where += " AND #{table}`#{db.esc_col(match[1])}` != '#{db.esc(val)}'"
+        elsif match[2] == "lower"
+          sql_where += " AND LOWER(#{table}`#{db.esc_col(match[1])}`) = LOWER('#{db.esc(val)}')"
+        else
+          raise "Unknown mode: '#{match[2]}'."
+        end
+        
 				found = true
-			elsif cols_date_has and match = key.match(/^(.+)_(day|month|from|to)$/) and args[:cols_date].index(match[1]) != nil
+			elsif args.key?(:cols_date) and match = key.match(/^(.+)_(day|month|from|to|below|above)$/) and args[:cols_date].index(match[1]) != nil
+        val = Knj::Datet.in(val) if val.is_a?(Time)
+        
 				if match[2] == "day"
 					sql_where += " AND DATE_FORMAT(#{table}`#{db.esc_col(match[1])}`, '%d %m %Y') = DATE_FORMAT('#{db.esc(val.dbstr)}', '%d %m %Y')"
 				elsif match[2] == "month"
 					sql_where += " AND DATE_FORMAT(#{table}`#{db.esc_col(match[1])}`, '%m %Y') = DATE_FORMAT('#{db.esc(val.dbstr)}', '%m %Y')"
-				elsif match[2] == "from"
+				elsif match[2] == "from" or match[2] == "above"
 					sql_where += " AND #{table}`#{db.esc_col(match[1])}` >= '#{db.esc(val.dbstr)}'"
-				elsif match[2] == "to"
+				elsif match[2] == "to" or match[2] == "below"
 					sql_where += " AND #{table}`#{db.esc_col(match[1])}` <= '#{db.esc(val.dbstr)}'"
 				else
 					raise "Unknown date-key: #{match[2]}."
 				end
 				
 				found = true
-			elsif cols_num_has and match = key.match(/^(.+)_(from|to)$/) and args[:cols_num].index(match[1]) != nil
+			elsif args.key?(:cols_num) and match = key.match(/^(.+)_(from|to)$/) and args[:cols_num].index(match[1]) != nil
 				if match[2] == "from"
 					sql_where += " AND #{table}`#{db.esc_col(match[1])}` <= '#{db.esc(val)}'"
 				elsif match[2] == "to"
@@ -703,19 +846,89 @@ class Knj::Objects
 				end
 				
 				found = true
+			elsif match = key.match(/^(.+)_lookup$/) and args[:cols].key?("#{match[1]}_id") and args[:cols].key?("#{match[1]}_class")
+        sql_where += " AND #{table}`#{db.esc_col("#{match[1]}_class")}` = '#{db.esc(val.table)}'"
+        sql_where += " AND #{table}`#{db.esc_col("#{match[1]}_id")}` = '#{db.esc(val.id)}'"
+        found = true
 			end
 			
-			list_args.delete(key) if found
+			list_args.delete(realkey) if found
 		end
 		
+		args = args_def
+		
+		if !args[:joins_skip]
+      raise "No joins defined on '#{args[:table]}' for: '#{args[:table]}'." if !do_joins.empty? and !args[:joined_tables]
+      
+      do_joins.each do |table_name, temp_val|
+        raise "No join defined on table '#{args[:table]}' for table '#{table_name}'." if !args[:joined_tables].key?(table_name)
+        table_data = args[:joined_tables][table_name]
+        
+        if table_data.key?(:parent_table)
+          sql_joins += " LEFT JOIN `#{table_data[:parent_table]}` AS `#{table_name}` ON 1=1"
+        else
+          sql_joins += " LEFT JOIN `#{table_name}` ON 1=1"
+        end
+        
+        if table_data[:ob]
+          ob = table_data[:ob]
+        else
+          ob = self
+        end
+        
+        class_name = args[:table].to_sym
+        
+        if table_data[:datarow]
+          datarow = table_data[:datarow]
+        else
+          self.requireclass(class_name) if @objects.key?(class_name)
+          datarow = @args[:module].const_get(class_name)
+        end
+        
+        if !datarow.columns_sqlhelper_args
+          ob.requireclass(datarow.table.to_sym)
+          raise "No SQL-helper-args on class '#{datarow.table}' ???" if !datarow.columns_sqlhelper_args
+        end
+        
+        newargs = datarow.columns_sqlhelper_args.clone
+        newargs[:table] = table_name
+        newargs[:joins_skip] = true
+        
+        ret = self.sqlhelper(table_data[:where].clone, newargs)
+        sql_joins += ret[:sql_where]
+      end
+    end
+		
 		if limit_from and limit_to
 			sql_limit = " LIMIT #{limit_from}, #{limit_to}"
 		end
 		
 		return {
+      :sql_joins => sql_joins,
 			:sql_where => sql_where,
 			:sql_limit => sql_limit,
 			:sql_order => sql_order
 		}
 	end
+	
+	def datarow_obj_from_args(args, list_args, class_name)
+    class_name = class_name.to_sym
+    
+    if !args.key?(:joined_tables)
+      Knj::Php.print_r(list_args)
+      Knj::Php.print_r(args)
+      raise "No joined tables on '#{args[:table]}' to find datarow for: '#{class_name}'."
+    end
+    
+    args[:joined_tables].each do |table_name, table_data|
+      next if table_name.to_sym != class_name
+      
+      return table_data[:datarow] if table_data[:datarow]
+      
+      self.requireclass(class_name) if @objects.key?(class_name)
+      return @args[:module].const_get(class_name)
+    end
+    
+    raise "Could not figure out datarow for: '#{class_name}'."
+	end
 end