sdb_dal 0.0.4 → 0.0.5

data/lib/sdb_dal/domain_object.rb

@@ -6,76 +6,94 @@ require File.dirname(__FILE__) +"/index_description.rb"
 require File.dirname(__FILE__) +"/lazy_loading_text.rb"
 require File.dirname(__FILE__) +"/repository_factory.rb"
 module SdbDal
-class DomainObject
+  class DomainObject
   
-  @@items_to_commit=nil
-  @@transaction_depth=0
-  attr_accessor :sdb_key 
-  def initialize(options={})
-    @attribute_values=HashWithIndifferentAccess.new
-    self.class.attribute_descriptions.each do |attribute_name,description|
-      if description.is_primary_key && options.has_key?(:primary_key)
-        @attribute_values[attribute_name]=options[:primary_key]
-      else  
-        value=options[attribute_name]
-        value=value || options[attribute_name.intern]
-        if !description.is_collection && value.respond_to?(:flatten) && value.length==1
-          value=value[0]
-        end
-        @attribute_values[attribute_name]=value
+    @@items_to_commit=nil
+    @@transaction_depth=0
+    attr_accessor :sdb_key
+    def initialize(options={})
+      @attribute_values=HashWithIndifferentAccess.new
+
+      self.class.attribute_descriptions.each do |attribute_name,description|
+          value=options[attribute_name]
+          value=value || options[attribute_name.intern]
+          if !description.is_collection && value.respond_to?(:flatten) && value.length==1
+            value=value[0]
+          end
+          @attribute_values[attribute_name]=value
+        
       end
+      @accessor_cache={}
+      @repository=options[:repository]
     end
-    @accessor_cache={}
-    @repository=options[:repository]
-  end
-  def self.primary_key_attribute_name
-    return @primary_key_attribute_name
-  end
-  def id
-    return @attribute_values[:id] if self.class.attribute_descriptions[:id] 
-    return base.id
-  end
-  def self.index_names
-    []
-  end
-  def self.index(name,columns,options={}) 
-    class_eval <<-GETTERDONE
-    @@index_names||=[]
-    @@index_descriptions||={}
-    @@index_names<<:#{name}
+
+
+    def self.primary_key_attribute_names
+      return @primary_key_attribute_names
+    end
+
+
+    def id
+      return @attribute_values[:id] if self.class.attribute_descriptions[:id]
+      return base.id
+    end
+    def set_map(keys,values)
+      (0..keys.length-1).each do |i|
+          key=keys[i]
+          value=values[i]
+          @attribute_values[key]=value
+        end
+
+
+    end
+
+
+    def self.index_names
+      []
+    end
+
+    def self.index(name,columns,options={})
+       return if self.index_descriptions[name]
+      $columns_xxx=columns
+      class_eval <<-GETTERDONE
+
+      @@index_descriptions||={}
+      unless @@index_descriptions.has_key?(:#{name})
+      @@index_names||=[]
+      @@index_names<<:#{name}
 
     def self.index_names
         @@index_names
     end
 
-    attribute_description=SdbDal::DomainAttributeDescription.new(name,:string,{})
-    @@index_descriptions[name]=SdbDal::IndexDescription.new(name,columns)
-   
-    GETTERDONE
+    attribute_description=SdbDal::DomainAttributeDescription.new(:#{name},:string,{})
+    @@index_descriptions[:#{name}]=SdbDal::IndexDescription.new(:#{name},$columns_xxx)
+   end
+      GETTERDONE
      
-    getter_params=[]
-    finder_code=""
+      getter_params=[]
+      finder_code=""
      
-    params=[]
-    columns.each do |column|
-      if column.respond_to?(:transform)
-        finder_code<<"h[:#{column.name}]=#{column.name.to_s.downcase}\n"
-        getter_params<<"@attribute_values[:#{column.source_column}]"
+      params=[]
+      columns.each do |column|
+        if column.respond_to?(:transform)
+          finder_code<<"h[:#{column.name}]=#{column.name.to_s.downcase}\n"
+          getter_params<<"@attribute_values[:#{column.source_column}]"
        
-        params<<"#{column.name.to_s.downcase}"
-      else
-        finder_code<<"h[:#{column}]=#{column.to_s.downcase}\n"
-        getter_params<<"@attribute_values[:#{column}]"
-        params<<"#{column.to_s.downcase}"
+          params<<"#{column.name.to_s.downcase}"
+        else
+          finder_code<<"h[:#{column}]=#{column.to_s.downcase}\n"
+          getter_params<<"@attribute_values[:#{column}]"
+          params<<"#{column.to_s.downcase}"
        
-      end
+        end
        
-    end
-    find_scope=":all"
-    if options[:unique]
-      find_scope=":first"
-    end
-    class_eval <<-GETTERDONE
+      end
+      find_scope=":all"
+      if options[:unique]
+        find_scope=":first"
+      end
+      class_eval <<-GETTERDONE
         def #{name}              
             return	self.class.calculate_#{name}(#{getter_params.join(",")})
         end
@@ -93,21 +111,25 @@ class DomainObject
           options[:index_value]=self.calculate_#{name}(#{params.join(",")})
            find(#{find_scope},options)
       end
-    GETTERDONE
-  end
-  @@index_descriptions ={}
-  def self.index_descriptions
+      GETTERDONE
+    end
+
+
+    @@index_descriptions ||={}
+
+    def self.index_descriptions
       @@index_descriptions || {}
     end
-  def self.data_attribute(name,type,options={})
-    class_eval <<-GETTERDONE
+
+    def self.data_attribute(name,type,options={})
+      class_eval <<-GETTERDONE
     @@attribute_descriptions||=HashWithIndifferentAccess.new 
     
     @@non_clob_attribute_names||=[]
     @@clob_attribute_names||=[]
     @@on_destroy_blocks||=[]
     def self.on_destroy_blocks
-      @@on_destroy_blocks
+      @@on_destroy_blocks || []
     end
      def self.attribute_descriptions
       @@attribute_descriptions
@@ -127,37 +149,39 @@ class DomainObject
                 return true
             end
     end
-    GETTERDONE
-    
+      GETTERDONE
+    return if self.attribute_descriptions.has_key?(name)
   
-    attribute_description=DomainAttributeDescription.new(name,type,options)
-    self.attribute_descriptions[name] = attribute_description
-    if attribute_description.is_primary_key
-      class_eval <<-GETTERDONE
-       def self.primary_key_attribute_name
-            '#{name}'
+      attribute_description=DomainAttributeDescription.new(name,type,options)
+      self.attribute_descriptions[name] = attribute_description
+      @primary_key_attribute_names||=[]
+      if attribute_description.is_primary_key 
+        @primary_key_attribute_names<<name
+        pk_code="[:#{@primary_key_attribute_names.join(",:")}]"
+        class_eval <<-GETTERDONE
+       def self.primary_key_attribute_names
+            #{pk_code}
        end
       def self.exists?(primary_key)
             return self.find(primary_key)!=nil
        end
         
-      GETTERDONE
-    end
-    if !attribute_description.is_primary_key
-      if attribute_description.value_type==:clob
-        clob_attribute_names<<attribute_description.name
-      else
-        non_clob_attribute_names<<attribute_description.name
+        GETTERDONE
       end
-    end
-    scope=":all"
-    if(options[:unique] && options[:unique]==true)
-      scope=":first"
-    end
-    if type==:reference_set
+        if attribute_description.value_type==:clob
+          clob_attribute_names<<attribute_description.name
+        else
+          non_clob_attribute_names<<attribute_description.name
+        end
+
+      scope=":all"
+      if(options[:unique] && options[:unique]==true)
+        scope=":first"
+      end
+      if type==:reference_set
         
     
-      class_eval <<-GETTERDONE
+        class_eval <<-GETTERDONE
         def #{attribute_description.name}
               result=@attribute_values[:#{attribute_description.name}] || []
               result=result.sort_by{|item|item.index}
@@ -177,10 +201,10 @@ class DomainObject
                 end
 	end
         
-      GETTERDONE
+        GETTERDONE
     
-    elsif type==:clob
-      class_eval <<-GETTERDONE
+      elsif type==:clob
+        class_eval <<-GETTERDONE
          
         def #{attribute_description.name}
             if @attribute_values[:#{attribute_description.name}]!= nil && 
@@ -191,17 +215,17 @@ class DomainObject
             end
 	end
         
-      GETTERDONE
-    else
+        GETTERDONE
+      else
      
-      class_eval <<-GETTERDONE
+        class_eval <<-GETTERDONE
         def #{attribute_description.name}
 		return @attribute_values[:#{attribute_description.name}] 
 	end
        
-      GETTERDONE
-    end
-    class_eval <<-GETTERDONE
+        GETTERDONE
+      end
+      class_eval <<-GETTERDONE
     
 	 def #{attribute_description.name}=(xvalue)
                 @attribute_values[:#{attribute_description.name}] =xvalue
@@ -214,45 +238,50 @@ class DomainObject
           options[:params]={:#{attribute_description.name}=>#{attribute_description.name.to_s.downcase}}
                find(#{scope},options)
 	end
-    GETTERDONE
-  end
+      GETTERDONE
+    end
   
-  def self.belongs_to(domain_class,foreign_key_attribute=nil,accesser_attribute_name=nil,options={})
+    def self.belongs_to(domain_class,foreign_key_attribute=nil,accesser_attribute_name=nil,options={})
     
-    foreign_key_attribute ||= "#{domain_class.to_s.downcase}_id".to_sym
-    accesser_attribute_name ||=domain_class.to_s.downcase
+      foreign_key_attribute ||= "#{domain_class.to_s.downcase}_id".to_sym
+      accesser_attribute_name ||=domain_class.to_s.downcase
   
-    class_eval <<-GETTERDONE
+      class_eval <<-GETTERDONE
 	def #{accesser_attribute_name}
 		#{domain_class}.find(self.#{foreign_key_attribute})
 	end
         
-    GETTERDONE
-  end
-  def self.many_to_many(domain_class,
-      through_class,
-      reflecting_key_attribute=nil,
-      foriegn_key_attribute=nil,
-      accesser_attribute_name=nil,
-      options={})
-    reflecting_key_attribute ||= (self.name+"_"+primary_key_attribute_name.to_s).downcase.to_sym
-    accesser_attribute_name ||=domain_class.to_s.downcase+'s'
-    order=""
-    if options[:order_by]
-      if options[:order]
-        order="result=DomainObject.sort_result(result,:#{options[:order_by]},:#{options[:order]})"
-      else
-        order="result=DomainObject.sort_result(result,:#{options[:order_by]},:ascending)"
-      end
+      GETTERDONE
     end
+    def self.many_to_many(domain_class,
+        through_class,
+        reflecting_key_attributes=nil,
+        foriegn_key_attribute=nil,
+        accesser_attribute_name=nil,
+        options={})
+      reflecting_key_attributes ||= primary_key_attribute_names.map{|x|self.name+"_"+x.to_s}
+      reflecting_key_attributes =arrayify(reflecting_key_attributes)
+      reflecting_array_code="[:"+reflecting_key_attributes.join(",:")+"]"
+
+      accesser_attribute_name ||=domain_class.to_s.downcase+'s'
+      order=""
+      if options[:order_by]
+        if options[:order]
+          order="result=DomainObject.sort_result(result,:#{options[:order_by]},:#{options[:order]})"
+        else
+          order="result=DomainObject.sort_result(result,:#{options[:order_by]},:ascending)"
+        end
+      end
    
        
-    foriegn_key_attribute=options[:foriegn_key_attribute] || "#{domain_class.to_s.downcase}_id".to_sym
-    primary_key=options[:primary_key] || "id".to_sym
-    class_eval <<-XXDONE
+      foriegn_key_attributes=options[:foriegn_key_attribute] || "#{domain_class.to_s.downcase}_id".to_sym
+      foriegn_key_attributes=arrayify(foriegn_key_attributes)
+      fkey_array_code="[:"+foriegn_key_attributes.join(",:")+"]"
+      class_eval <<-XXDONE
+
 	def #{accesser_attribute_name}
             #unless @accessor_cache.has_key? :#{accesser_attribute_name}
-		through_results= #{through_class}.find(:all,:params=>{:#{reflecting_key_attribute}=>self.primary_key})
+      		through_results= #{through_class}.find(:all,:map=>{:keys=>#{reflecting_array_code},:values=>DomainObject.arrayify(self.primary_key)})
                 result=[]
                 through_results.each do |through_result|
                   item= #{domain_class}.find(through_result.#{foriegn_key_attribute}) 
@@ -268,378 +297,402 @@ class DomainObject
 	end
         def connect_#{domain_class.to_s.downcase}(#{domain_class.to_s.downcase})
             connector=#{through_class}.new
-            connector.#{foriegn_key_attribute}=#{domain_class.to_s.downcase}.primary_key
-            connector.#{reflecting_key_attribute}=self.primary_key
+            connector.set_map(#{fkey_array_code},DomainObject.arrayify(#{domain_class.to_s.downcase}.primary_key))
+            connector.set_map(#{reflecting_array_code},DomainObject.arrayify(self.primary_key))
             connector.save
         end
-    XXDONE
+      XXDONE
        
    
-  end
-  def DomainObject.transaction
-    @@items_to_commit||=[]
-    @@transaction_depth+=1
-    begin
-      yield
-    rescue # catch all
-      raise $! # rethrow 
-    ensure
-      @@transaction_depth-=1
-      
     end
+
+
+    def DomainObject.transaction
+      @@items_to_commit||=[]
+      @@transaction_depth+=1
+      begin
+        yield
+      rescue # catch all
+        raise $! # rethrow
+      ensure
+        @@transaction_depth-=1
+      
+      end
     
     
-    if @@transaction_depth==0
+      if @@transaction_depth==0
      
-      @@items_to_commit.uniq.each do |item |
-        item.save!
+        @@items_to_commit.uniq.each do |item |
+          item.save!
+        end
+        @@items_to_commit=[]
       end
-      @@items_to_commit=[]
-    end
     
-  end
-  def DomainObject.sort_result(results,sort_by,order=:ascending)
-    non_null_results=[]
-    null_results=[]
-    results.each { |i|  
-      sorter_value=i.get_attribute(sort_by)
-      if sorter_value
-        non_null_results<<i
-      else
-        null_results<<i
-      end
-    }
-    sorted_results=non_null_results.sort{ |a,b|
+    end
+    def DomainObject.sort_result(results,sort_by,order=:ascending)
+      non_null_results=[]
+      null_results=[]
+      results.each { |i|
+        sorter_value=i.get_attribute(sort_by)
+        if sorter_value
+          non_null_results<<i
+        else
+          null_results<<i
+        end
+      }
+      sorted_results=non_null_results.sort{ |a,b|
         a_val= a.get_sortable_attribute(sort_by)
         b_val= b.get_sortable_attribute(sort_by)
         
-            a_val <=> b_val
-        }
+        a_val <=> b_val
+      }
         
-    if order!=:ascending
-      sorted_results.reverse!
-    end
-    sorted_results.concat( null_results)
-    sorted_results
-  end
-  def get_sortable_attribute(attr_name)
-       a_val= self.get_attribute(attr_name)
-       return 0 unless a_val
-        if a_val.class== Time
-            return a_val.to_f
-        else
-            return a_val
-        end
-  end
-  def self.has_many(domain_class,
-      reflecting_key_attribute=nil,
-      accesser_attribute_name=nil,
-      options={})
-    
-    reflecting_key_attribute ||= (self.name+"_"+primary_key_attribute_name.to_s).downcase.to_sym
-    accesser_attribute_name ||=domain_class.to_s.downcase+'s'
-    order=""
-    if options[:order_by]
-      order=",:order_by=>:#{options[:order_by]}"
-    end
-    if options[:order]
-      order<<",:order=>:#{options[:order]}"
+      if order!=:ascending
+        sorted_results.reverse!
+      end
+      sorted_results.concat( null_results)
+      sorted_results
+    end
+    def get_sortable_attribute(attr_name)
+      a_val= self.get_attribute(attr_name)
+      return 0 unless a_val
+      if a_val.class== Time
+        return a_val.to_f
+      else
+        return a_val
+      end
     end
+    def self.has_many(domain_class,
+        reflecting_key_attributes=nil,
+        accesser_attribute_name=nil,
+        options={})
+    reflecting_key_attributes ||= primary_key_attribute_names.map{|x|self.name.downcase+"_"+x.to_s}
+      reflecting_key_attributes =arrayify(reflecting_key_attributes)
+      reflecting_array_code="[:"+reflecting_key_attributes.join(",:")+"]"
+
+      accesser_attribute_name ||=domain_class.to_s.downcase+'s'
+      order=""
+      if options[:order_by]
+        order=",:order_by=>:#{options[:order_by]}"
+      end
+      if options[:order]
+        order<<",:order=>:#{options[:order]}"
+      end
   
-    if options[:dependent]
+      if options[:dependent]
         
-      class_eval <<-XXDONE
+        class_eval <<-XXDONE
           
             on_destroy_blocks<<"#{accesser_attribute_name}.each{|item|item.destroy}"
-      XXDONE
-    end
-    #  if options[:tracking]
-    #    #add add_xxx method
-    #    #add to list of tracker attributes
-    #    
-    #      class_eval <<-XXDONE
-    #        
-    #    @@attribute_descriptions[ :#{accesser_attribute_name}_tracker]=TrackerDescription.new(:#{accesser_attribute_name}_tracker,:#{domain_class},:#{reflecting_key_attribute})
-    #	def #{accesser_attribute_name}
-    #		find_tracked_list(:#{accesser_attribute_name}_tracker,#{domain_class},:#{reflecting_key_attribute})
-    #	end
-    #        def add_to_#{accesser_attribute_name}(item)
-    #		item.save!
-    #                add_to_tracked_list(:#{accesser_attribute_name}_tracker,#{domain_class.to_s},:#{reflecting_key_attribute},item.primary_key)
-    #                item.set_attribute(:#{reflecting_key_attribute},self.primary_key)
-    #                
-    #                
-    #	end
-    #    XXDONE
-    #  else
-    class_eval <<-XXDONE
+        XXDONE
+      end
+      #  if options[:tracking]
+      #    #add add_xxx method
+      #    #add to list of tracker attributes
+      #
+      #      class_eval <<-XXDONE
+      #
+      #    @@attribute_descriptions[ :#{accesser_attribute_name}_tracker]=TrackerDescription.new(:#{accesser_attribute_name}_tracker,:#{domain_class},:#{reflecting_key_attribute})
+      # # def #{accesser_attribute_name} # 	find_tracked_list(:#{accesser_attribute_name}_tracker,#{domain_class},:#{reflecting_key_attribute})
+      # # end
+      #        def add_to_#{accesser_attribute_name}(item)
+      # # 	item.save!
+      #                add_to_tracked_list(:#{accesser_attribute_name}_tracker,#{domain_class.to_s},:#{reflecting_key_attribute},item.primary_key)
+      #                item.set_attribute(:#{reflecting_key_attribute},self.primary_key)
+      #
+      #
+      # # end
+      #    XXDONE
+      #  else
+      class_eval <<-XXDONE
 	def #{accesser_attribute_name}
             if !@accessor_cache.has_key? :#{accesser_attribute_name}
-		@accessor_cache[:#{accesser_attribute_name}]=#{domain_class}.find(:all,:params=>{:#{reflecting_key_attribute}=>self.primary_key}#{order})
+               result= #{domain_class}.find(:all,:map=>{:keys=>#{reflecting_array_code},:values=>DomainObject::arrayify(self.primary_key)}#{order})
+                @accessor_cache[:#{accesser_attribute_name}]=result || []
             end
-            return @accessor_cache[:#{accesser_attribute_name}]
+            return @accessor_cache[:#{accesser_attribute_name}] 
 	end
-    XXDONE
-    # end
-  end
-  def self.AttributeDescription(name)
-    return attribute_descriptions[name]
-  end
-  def self.ColumnDescription(name)
-    return column_descriptions[name]
-  end
-  def primary_key
-    
-    @attribute_values[ self.class.primary_key_attribute_name]
-  end
-  def primary_key=(value)
-    @attribute_values[ self.class.primary_key_attribute_name]=value
-  end
-  def method_missing(method_symbol, *arguments) #:nodoc:
-    method_name = method_symbol.to_s
+      XXDONE
+      # end
+    end
+    def self.AttributeDescription(name)
+      return attribute_descriptions[name]
+    end
+    def self.ColumnDescription(name)
+      return column_descriptions[name]
+    end
+    def primary_key
 
-    case method_name.last
-    when "="
-      if @attribute_values.has_key?(method_name.first(-1))
-        @attribute_values[method_name.first(-1)] = arguments.first 
+      result=[]
+      self.class.primary_key_attribute_names.each do |key_part|
+        result<<@attribute_values[key_part ]
+      end
+      return result[0] if result.length==1
+      return result
+    end
+    def primary_key=(value)
+      key=DomainObject::arrayify(value)
+      self.class.primary_key_attribute_names.each do |key_part|
+
+        @attribute_values[ key_part]=key.shift
+      end
+    end
+    def method_missing(method_symbol, *arguments) #:nodoc:
+      method_name = method_symbol.to_s
+
+      case method_name.last
+      when "="
+        if @attribute_values.has_key?(method_name.first(-1))
+          @attribute_values[method_name.first(-1)] = arguments.first
+        else
+          super
+        end
+      when "?"
+        @attribute_values[method_name.first(-1)]
       else
-        super
+        @attribute_values.has_key?(method_name) ? @attribute_values[method_name] : super
       end
-    when "?"
-      @attribute_values[method_name.first(-1)]
-    else
-      @attribute_values.has_key?(method_name) ? @attribute_values[method_name] : super
     end
-  end
-  def index_values
-    result={}
-    self.class.index_names.each do |name|
+    def index_values
+      result={}
+      self.class.index_names.each do |name|
               
-      result[name]=  self.send("#{name}")
+        result[name]=  self.send("#{name}")
    
+      end
+      result
     end
-    result
-  end
-  def set_attribute(name,value)
-    @attribute_values[name]=value
-  end
-  def get_attribute(name)
-    @attribute_values[name]
-  end
-def to_xml
-    result= "<#{self.class.table_name}>"
-    attributes.each do |key,value|
+    def set_attribute(name,value)
+      @attribute_values[name]=value
+    end
+    def get_attribute(name)
+      @attribute_values[name]
+    end
+    def to_xml
+      result= "<#{self.class.table_name}>"
+      attributes.each do |key,value|
         if value.respond_to?(:flatten)
-            result<<"<#{key}>"
-            value.each do |sub_value|
-                result<<"<value>#{h sub_value.to_s}</value>"
-            end
-            result<<"</#{key}>"
+          result<<"<#{key}>"
+          value.each do |sub_value|
+            result<<"<value>#{h sub_value.to_s}</value>"
+          end
+          result<<"</#{key}>"
         else
           result<<"<#{key}>#{h value.to_s}</#{key}>"
         end
-   end
-    result<< "</#{self.class.table_name}>"
-    result
-end
-def destroy(options={})
-    self.class.on_destroy_blocks.each do |block| 
-      instance_eval <<-XXDONE
-                  #{block}
-             
-      XXDONE
-         
-    end
-    if self.primary_key
-      self.repository(options).destroy(self.table_name,self.primary_key)
+      end
+      result<< "</#{self.class.table_name}>"
+      result
+    end
+    def destroy(options={})
+      if self.class.on_destroy_blocks
+        self.class.on_destroy_blocks.each do |block|
+          instance_eval <<-XXDONE
+                    #{block}
+
+          XXDONE
+
+        end
+      end
+      if self.primary_key
+        self.repository(options).destroy(self.table_name,self.primary_key)
+      end
     end
-  end
-  def attributes
-    result={}
-    #todo refactor to avoid this copy
-    self.class.attribute_descriptions.values.each do |description|
-      if !description.is_clob || is_dirty(description.name)
-        result[description.name]=@attribute_values[description.name]
+    def attributes
+      result={}
+      # #todo refactor to avoid this copy
+      self.class.attribute_descriptions.values.each do |description|
+        if !description.is_clob || is_dirty(description.name)
+          result[description.name]=@attribute_values[description.name]
+        end
       end
+      return result
     end
-    return result
-  end
 
-  def find_tracked_list(tracking_attribute,other_class,reflecting_attribute)
-    #if the attribute has no  value do a query
-    list=@attribute_values[tracking_attribute]
-    if !list
-      list=other_class.query_ids(:params=>{reflecting_attribute=>self.primary_key})
-      @attribute_values[tracking_attribute]=list
-      self.save!
-    end
+    def find_tracked_list(tracking_attribute,other_class,reflecting_attribute)
+      # #if the attribute has no  value do a query
+      list=@attribute_values[tracking_attribute]
+      if !list
+        list=other_class.query_ids(:params=>{reflecting_attribute=>self.primary_key})
+        @attribute_values[tracking_attribute]=list
+        self.save!
+      end
       
-    return other_class.find_list(list)
+      return other_class.find_list(list)
     
-  end
+    end
   
-  def add_to_tracked_list(tracking_attribute,other_class,reflecting_attribute,value)
-    list=@attribute_values[tracking_attribute]
-    if !list
-      list=other_class.query_ids(:params=>{reflecting_attribute=>self.primary_key})
+    def add_to_tracked_list(tracking_attribute,other_class,reflecting_attribute,value)
+      list=@attribute_values[tracking_attribute]
+      if !list
+        list=other_class.query_ids(:params=>{reflecting_attribute=>self.primary_key})
       
-    end
-    list<<value
-    @attribute_values[tracking_attribute]=list.uniq
+      end
+      list<<value
+      @attribute_values[tracking_attribute]=list.uniq
     
-  end
-  def save!(options={})
-    save(options)
-  end
-  def save(options={})
-     if !self.primary_key
-      self.primary_key= UUID.generate.to_s
     end
+    def save!(options={})
+      save(options)
+    end
+    def save(options={})
+      if !self.primary_key
+        self.primary_key= UUID.generate.to_s
+      end
         
-    if @@transaction_depth>0
-      #we are in a transaction.  wait to commit
-      @@items_to_commit<<self
+      if @@transaction_depth>0
+        # #we are in a transaction.  wait to commit
+        @@items_to_commit<<self
      
-    else
-      temp_accessor_cache=@accessor_cache
-      @accessor_cache=nil
+      else
+        temp_accessor_cache=@accessor_cache
+        @accessor_cache=nil
    
-      #     $service.put_attributes(class_object.table_name,item.send(name_column),attributes,true)
-      attributes={}
-      #todo refactor to avoid this copy
-      self.class.attribute_descriptions.values.each do |description|
-        if !description.is_clob || is_dirty(description.name)
-          value=@attribute_values[description.name]
-          attributes[description]=value
-        end
+        #     $service.put_attributes(class_object.table_name,item.send(name_column),attributes,true)
+        attributes={}
+        # #todo refactor to avoid this copy
+        self.class.attribute_descriptions.values.each do |description|
+          if !description.is_clob || is_dirty(description.name)
+            value=@attribute_values[description.name]
+            attributes[description]=value
+          end
    
                 
            
-      end
-      self.index_values.each do |name,value|
+        end
+        self.index_values.each do |name,value|
       
-        attributes[self.class.index_descriptions[name]]=value
-      end
+          attributes[self.class.index_descriptions[name]]=value
+        end
   
-      self.repository(options).save(self.table_name,self.primary_key,attributes,self.class.index_descriptions)
-      @accessor_cache=temp_accessor_cache
-    end
-    
-  end
-  def table_name
-    return self.class.table_name
-  end
-  def DomainObject.table_name
-    return self.name
-  end
-  #    def find
-  #       
-  #       attributes=repository.find(self.class.name,self.primary_key,@@non_clob_attribute_names,@@clob_attribute_names)
-  #       attributes.each do |key,value|
-  #           @attribute_values[key]=value
-  #       end
-  #    end
-  def repository(options=nil)
+        self.repository(options).save(self.table_name,self.primary_key,attributes,self.class.index_descriptions)
+        @accessor_cache=temp_accessor_cache
+      end
     
-    if options and options.has_key?(:repository)          
-      return options[:repository]
     end
-    if @repository
-      return @repository
+    def table_name
+      return self.class.table_name
     end
-
-    return self.class.repository
-  end
-  class << self
-    def repository(options={})
+    def DomainObject.table_name
+      return self.name
+    end
+    #    def find
+    #
+    #       attributes=repository.find(self.class.name,self.primary_key,@@non_clob_attribute_names,@@clob_attribute_names)
+    #       attributes.each do |key,value|
+    #           @attribute_values[key]=value
+    #       end
+    #    end
+    def repository(options=nil)
     
-      if options.has_key?(:repository)          
+      if options and options.has_key?(:repository)
         return options[:repository]
       end
+      if @repository
+        return @repository
+      end
+
+      return self.class.repository
+    end
+    class << self
+      def repository(options={})
+    
+        if options.has_key?(:repository)
+          return options[:repository]
+        end
       
-      $repository   ||= RepositoryFactory.instance(options)
+        $repository   ||= RepositoryFactory.instance(options)
     
-      return $repository
-    end
-    def find(*arguments)
-      scope   = arguments.slice!(0)
-      options = arguments.slice!(0) || {}
+        return $repository
+      end
+      def find(*arguments)
+        scope   = arguments.slice!(0)
+        options = arguments.slice!(0) || {}
         
-      case scope
-      when :all   then return find_every(options)
-      when :first then return find_one(options)
-      else             return find_single(scope, options)
+        case scope
+        when :all   then return find_every(options)
+        when :first then return find_one(options)
+        else             return find_single(scope, options)
+        end
       end
-    end
-    def find_one(options)
-      options[:limit]=1
-      find_every(options).first
-    end
-    def find_every(options)
+      def find_one(options)
+        options[:limit]=1
+        find_every(options).first
+      end
+      def find_every(options)
 
-      results=[]
-      untyped_results=self.repository.query(self.table_name,attribute_descriptions,options)
-      untyped_results.each do |item_attributes|
+        results=[]
+        untyped_results=self.repository.query(self.table_name,attribute_descriptions,options)
+        untyped_results.each do |item_attributes|
 
-        results<<istantiate(item_attributes,self.repository(options))
-      end
-      return results
+          results<<istantiate(item_attributes,self.repository(options))
+        end
+        return results
 
-    end
-     def find_list(primary_keys,options={})
-      result=[]
-      primary_keys.each do |key|
-        item=find_single(key,options)
-        result<<item if item
       end
-      return result
-    end
-    def query_ids(options={})
-      self.repository.query_ids(self.table_name,attribute_descriptions,options)
-    end
-    def istantiate(sdb_attributes,repository)
-      this_result=new(sdb_attributes||{})
-      get_clob_proc=nil
-      clob_attribute_names.each do |clob_attribute_name|
-        get_clob_proc= proc {
-          repository.get_clob(self.table_name,this_result.primary_key,clob_attribute_name)
-        }
+      def find_list(primary_keys,options={})
+        result=[]
+        primary_keys.each do |key|
+          item=find_single(key,options)
+          result<<item if item
+        end
+        return result
+      end
+      def query_ids(options={})
+        self.repository.query_ids(self.table_name,attribute_descriptions,options)
+      end
+      def istantiate(sdb_attributes,repository)
+        this_result=new(sdb_attributes||{})
+        get_clob_proc=nil
+        clob_attribute_names.each do |clob_attribute_name|
+          get_clob_proc= proc {
+            repository.get_clob(self.table_name,this_result.primary_key,clob_attribute_name)
+          }
                   
-        this_result.set_attribute(clob_attribute_name, LazyLoadingText.new(get_clob_proc))
+          this_result.set_attribute(clob_attribute_name, LazyLoadingText.new(get_clob_proc))
+        end
+        this_result
       end
-      this_result
-    end
-       
-    def find_single(id, options)
-      return nil if id==nil
-      attributes=self.repository(options).find_one(self.table_name,id,attribute_descriptions)
-      if attributes && attributes.length>0 
-        attributes[@primary_key_attribute_name]=id
-        attributes[:repository]=self.repository(options)
-        return istantiate(attributes,self.repository(options))
-      end
-      return nil
-    end
-    def find_recent_with_exponential_expansion(time_column,how_many,options={})
-      found=[]
-      tries=0
-      timespan=options[:timespan_hint] || 60*60*4
+      def arrayify(x)
+        unless x.is_a?(Array)
+          x=[x]
+        end
+        return x
+
+      end
+      def find_single(id, options)
+        return nil if id==nil
+        id=arrayify(id)
+        attributes=self.repository(options).find_one(self.table_name,id,attribute_descriptions)
+        if attributes && attributes.length>0
+          @primary_key_attribute_names.each do |key_name|
+            attributes[key_name]=id.shift
+          end
+          attributes[:repository]=self.repository(options)
+          return istantiate(attributes,self.repository(options))
+        end
+        return nil
+      end
+      def find_recent_with_exponential_expansion(time_column,how_many,options={})
+        found=[]
+        tries=0
+        timespan=options[:timespan_hint] || 60*60*4
       
-      params = options[:params] || {}
+        params = options[:params] || {}
       
-      while found.length<how_many && tries<4
-        time=Time.now.gmtime-timespan
-        params[time_column]  =AttributeRange.new(:greater_than=>time)
-        found= find(:all,:limit=>how_many,:order=>:descending,:order_by => time_column,
-          :params=>params)
+        while found.length<how_many && tries<4
+          time=Time.now.gmtime-timespan
+          params[time_column]  =AttributeRange.new(:greater_than=>time)
+          found= find(:all,:limit=>how_many,:order=>:descending,:order_by => time_column,
+            :params=>params)
         
-        tries=tries+1
-        timespan=timespan*3
-      end
-      return found
+          tries=tries+1
+          timespan=timespan*3
+        end
+        return found
           
-    end  
+      end
     
+    end
   end
 end
-end