rtm-activerecord 0.2.0

data/lib/rtm/activerecord/sugar/association/hash_access.rb

@@ -0,0 +1,22 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::AR::Sugar
+  module Association
+    # This module implements methods for Hash-like access in Associations.
+    module HashAccess
+      # Returns the roles of the association which match the given role type.
+      # The role type can be specified as String-reference or as Topic.
+      def [](type_reference=:any)
+        return roles if type_reference == :any
+        return roles unless type_reference
+        if type_reference.is_a? String
+          roles.select{|o| o.type == topic_map.get(type_reference)}
+        else
+          # assume topics are given
+          roles.select{|o| o.type == type_reference}
+        end
+      end
+    end
+  end
+end

data/lib/rtm/activerecord/sugar/role/counterparts.rb

@@ -0,0 +1,56 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::AR::Sugar
+  module Role
+    module Counterparts
+
+      # Fetches all roles from the parent association of this role,
+      # except itself (i.e. current role).
+      # A filter-hash may be used to filter for the type of the other role (:otype =>topic_reference).
+      # Examples:
+      # this_role.counterparts # returns all
+      # this_role.counterparts(:otype => some_topic) # returns only other roles which have type some_topic
+      # this_role.counterparts(:otype => "some_reference") # as above, looking up the reference first
+      def counterparts(filter={})
+        self.parent.roles.reject{|r| r.id==self.id}.
+                    select{|r| filter[:otype] ? r.type == self.topic_map.get(filter[:otype]) : true}
+      end
+
+      # This methods fetches all players of the parent association of this role, except the player of itself.
+      # It accepts a filter-hash like the counterparts-method.
+      def counterplayers(*args)
+        self.counterparts(*args).map{|r| r.player}
+      end
+
+      # Fetches the other role, if the parent association is binary.
+      def counterpart
+        n = self.parent.roles.size
+        raise "Association must be unary or binary to use counterpart method. Please use counterparts for n-ary associations." if n > 2
+        return nil if n == 1
+        self.counterparts.first
+      end
+      
+      # Fetches the player of the other role, if the parent association is binary.
+      def counterplayer
+        n = self.parent.roles.size
+        raise "Association must be unary or binary to use counterplayer method. Please use counterplayers for n-ary associations." if n > 2
+        return nil if n == 1
+        self.counterparts.first.player
+      end
+      
+      # Fetches all roles of the (binary) parent associations which play the same role in the same with the counterplayer
+      # TODO: filter not only otype but also atype and rtype.
+      def peers
+        cp = self.counterpart
+        cp.player.roles.select{|r| r.type == cp.type}.map{|r| r.counterpart}
+      end
+      # Fetches all players of roles being in the same association with another topic as self
+      # Example: current_role is a role of player "me" and type "employee"
+      # current_role.peerplayers # returns all employees of my company (including me)
+      def peerplayers
+        self.peers.map{|r| r.player}
+      end
+    end
+  end
+end

data/lib/rtm/activerecord/sugar/topic/characteristics.rb

@@ -0,0 +1,15 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::AR::Sugar
+  module Topic
+    module Characteristics
+      def internal_occurrences
+        occurrences.select{|o| o.datatype != RTM::PSI[:IRI]}
+      end
+      def external_occurrences
+        occurrences.select{|o| o.datatype == RTM::PSI[:IRI]}
+      end      
+    end
+  end
+end

data/lib/rtm/activerecord/sugar/topic/counterparts.rb

@@ -0,0 +1,18 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::AR::Sugar
+  module Topic
+    module Counterparts
+      def counterparts(filter={})
+        self.roles.
+             select{|r| filter[:rtype] ? r.type == self.topic_map.get(filter[:rtype]) : true}.
+             select{|r| filter[:atype] ? r.parent.type == self.topic_map.get(filter[:atype]) : true}.
+             inject([]){|all,r| all+=r.counterparts(filter)}                  
+      end
+      def counterplayers(*args)
+        return self.counterparts(*args).map{|r| r.player}
+      end
+    end
+  end
+end

data/lib/rtm/activerecord/sugar/topic/hash_access.rb

@@ -0,0 +1,78 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::AR::Sugar
+  module Topic
+    # This module implements methods for Hash-like access in Topics.
+    module HashAccess
+      
+      # Returns a list of names or occurrences depending on the arguments given.
+      # 
+      def [](cref)
+        # return occurrences by type if topic is given
+        return occurrences.select{|o| o.type == cref} if cref.is_a? Topic
+        raise "Characteristic reference must be a Topic or a String" unless cref.is_a? String
+        # parse the given String to extract kind (name/occ), type and scope
+        is_name, type_reference, scope_reference = resolve_characteristic(cref)
+        if is_name
+          type_reference = RTM::PSI[:name_type] if type_reference == :any
+          ret = names.select{|n| n.type == topic_map.get(type_reference)}
+        else
+          raise "No occurrence type given" if type_reference == :any
+          ret = occurrences.select{|o| o.type == topic_map.get(type_reference)}
+        end
+        # we now have a list of names or occurrences, now we have to select for scope
+        return ret if scope_reference == :any
+        if scope_reference == :ucs
+          ret.select{|n| n.scope.size == 0}
+        else
+          ret.select{|n| scope_reference.all?{|sr| srt = topic_map.get(sr); srt && n.scope.include?(srt)}}
+        end
+      end
+
+      def []=(cref, value)
+        is_name, type_reference, scope_reference = resolve_characteristic(cref)
+        if is_name
+          type_reference = nil if type_reference == :any
+          nametype = type_reference || topic_map.get!(RTM::PSI[:name_type])
+          ret = create_name(nametype, value)
+        else
+          raise "No occurrence type given" if type_reference == :any
+          ret = create_occurrence(type_reference,value)
+        end
+        # return object without scope if any or ucs
+        return ret if [:any, :ucs].include? scope_reference
+        # set scope
+        scope_reference.each do |sr|
+          ret.scope << topic_map.get!(sr)
+        end
+      end
+      
+      private
+      def resolve_characteristic(ref)
+        ref =~ /^(-\s*)?(.+)?$/
+        is_name = $1 ? true : false
+        type, scope = resolve_type_and_scope($2)
+        [is_name, type, scope]
+      end
+      
+      def resolve_type_and_scope(ref)
+        return [:any, :any] unless ref
+        return [ref, :ucs] if ref.is_a? Topic
+        type, scope = ref.split('@', -1)
+        if type.blank?
+          type = :any
+        else
+          type.strip!
+        end
+        if scope
+          scope = scope.strip.split(/\s+/)
+          scope = :ucs if scope.blank?
+        else
+          scope = :any
+        end
+        [type, scope]
+      end
+    end
+  end
+end

data/lib/rtm/activerecord/sugar/topic/identifier_direct.rb

@@ -0,0 +1,14 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::AR::Sugar
+  module Topic
+    module IdentifierDirect
+      def identifiers
+        subject_identifiers.map{|si| si.to_s} +
+          subject_locators.map{|sl| "=#{sl.to_s}"} +
+          item_identifiers.map{|ii| "^#{ii.to_s}"}
+      end
+    end
+  end
+end

data/lib/rtm/activerecord/sugar/topic/predefined_associations.rb

@@ -0,0 +1,53 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::AR::Sugar
+  module Topic
+    module PredefinedAssociations
+      extend RTM::AR::TraverseAssociations    
+      # maybe these pairs could be declared each with a single statement and a reversible option
+      define_association :types, :type => :Topic, :rule => {
+        :transitive => false,
+        :role_type => RTM::PSI[:instance],
+        :association_type => RTM::PSI[:type_instance],
+        :association_arity => 2,
+        :other_role_type => RTM::PSI[:type],
+        :infer_other => :supertypes,
+        :add => :type,
+      }
+      alias :addType :add_type
+
+      define_association :instances, :type => :Topic, :rule => {
+        :transitive => false,
+        :role_type => RTM::PSI[:type],
+        :association_type => RTM::PSI[:type_instance],
+        :association_arity => 2,
+        :other_role_type => RTM::PSI[:instance],
+        :infer => :subtypes,
+        :add => :instance,
+      }
+      alias :addInstance :add_instance
+
+      define_association :supertypes, :type => :Topic, :rule => {
+        :transitive => true,
+        :role_type => RTM::PSI[:subtype],
+        :association_type => RTM::PSI[:supertype_subtype],
+        :association_arity => 2,
+        :other_role_type => RTM::PSI[:supertype],
+        :add => :supertype,
+      }
+      alias :addSupertype :add_supertype
+
+      define_association :subtypes, :type => :Topic, :rule => {
+        :transitive => true,
+        :role_type => RTM::PSI[:supertype],
+        :association_type => RTM::PSI[:supertype_subtype],
+        :association_arity => 2,
+        :other_role_type => RTM::PSI[:subtype],
+        :add => :subtype,
+      }
+      alias :addSubtype :add_subtype
+
+    end
+  end
+end

data/lib/rtm/activerecord/tm_construct.rb

@@ -0,0 +1,66 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::AR
+  class Construct < TMDelegator
+    include RTM::Construct
+
+    def self.abstract_class?
+      self == Construct
+    end
+    property_set :item_identifiers, :aka => [:ii, :iid, :source_locators], :type => :ItemIdentifier, :wrap => true,
+      #:create => :item_identifier, :create_aka => :cii
+      :add => true, :remove => true
+    alias :getItemIdentifiers :item_identifiers
+    
+    delegate :remove, :to => :destroy
+
+    delegate :id
+    #    property_parent :parent # mmh..
+
+    property :topic_map, :rw => true, :type => :TopicMap, :wrap => true
+
+    #class_delegate :create
+
+    def self.wrap(obj)
+      return nil unless obj
+      raise "Double wrapping" if obj.respond_to?(:__getobj__)
+      case obj.class.name
+      when "RTM::AR::TMDM::Topic"
+        Topic.wrap(obj)
+      when "RTM::AR::TMDM::Variant"
+        Variant.wrap(obj)
+      when "RTM::AR::TMDM::Name"
+        Name.wrap(obj)
+      when "RTM::AR::TMDM::Occurrence"
+        Occurrence.wrap(obj)
+      when "RTM::AR::TMDM::Association"
+        Association.wrap(obj)
+      when "RTM::AR::TMDM::Role"
+        Role.wrap(obj)
+      when "RTM::AR::TMDM::TopicMap"
+        TopicMap.wrap(obj)
+      else
+        raise "Can't wrap object. Class for wrapping #{obj.class} unknown (object: #{obj})"
+      end
+    end
+    
+    def self.find(*args)
+      res = RTM::AR::TMDM.const_get(name.split("::").last).find(*args)
+      if res.respond_to? :each
+        Constructs.wrap(res)
+      else
+        Construct.wrap(res)
+      end
+    end
+  end
+
+  class Reifiable < Construct
+    include RTM::Reifiable
+
+    def self.abstract_class?
+      self == Reifiable
+    end
+    property :reifier, :type => :Topic, :rw => :true, :wrap => true
+  end
+end

data/lib/rtm/activerecord/tm_delegator.rb

@@ -0,0 +1,417 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::AR
+  class TMDelegator
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def __getobj__
+      @obj
+    end
+
+    def __setobj__(obj)
+      @obj = obj
+    end
+    
+    def self.delegate(sym, options={})
+      to = options[:to] || sym
+      options[:reload] ||= sym==:remove ? true : false # dirty hack to get a bit of reloading after delete
+      module_eval(<<-EOS, "(__TMDELEGATOR__)", 1)
+        def #{sym}(*args, &block)
+          __getobj__.send(:#{to}, *args, &block)
+         #{options[:reload] ? "parent.__getobj__.reload" :""}
+        end
+      EOS
+
+      if options[:rw]
+        module_eval(<<-EOS, "(__TMDELEGATOR2__)", 1)
+          def #{sym}=(*args, &block)
+            __getobj__.send(:#{to}=, *args, &block)
+            #{options[:save] ? "__getobj__.save" : "" }
+          end
+        EOS
+      end
+
+      if options[:aka]
+        options[:aka] = [options[:aka]] unless options[:aka].respond_to? :each
+        options[:aka].each do |aka|
+          module_eval(<<-EOS, "(__TMDELEGATOR3__)", 1)
+            alias :#{aka} :#{sym}
+          EOS
+
+          if options[:rw]
+            module_eval(<<-EOS, "(__TMDELEGATOR3__)", 1)
+              alias :#{aka}= :#{sym}=
+            EOS
+          end
+        end
+      end
+    end
+
+    def self.class_delegate(sym, options={})
+      module_eval(<<-EOS, "(__TMDELEGATOR__)", 1)
+        class << self
+          def #{sym}(*args, &block)
+            __getobj__.send(:#{sym}, *args, &block)
+          end
+        end
+      EOS
+
+      if options[:aka]
+        options[:aka] = [options[:aka]] unless options[:aka].respond_to? :each
+        options[:aka].each do |aka|
+          module_eval(<<-EOS, "(__TMDELEGATOR2__)", 1)
+            class << self
+              alias :#{aka} :#{sym}
+            end
+          EOS
+        end
+      end
+    end
+
+    def self.parent(sym, options={})
+      module_eval(<<-EOS, "(__TMDELEGATOR__)", 1)
+        def #{sym}
+          Construct.wrap(__getobj__.send(:#{sym}))
+        end
+      EOS
+      aka_property(sym, [:parent, :p])
+    end
+
+    def self.property_set(prop, options={})
+#      puts "In #{self.name.to_s.ljust(20)} we have type #{options[:type].to_s.ljust(20)} for property #{prop}"
+      if options[:wrap]
+        #puts "#{self}: #{options[:type]}"
+        module_eval(<<-EOS, "(__AR_DELEGATOR_PROPERTY_SET_W__)", 1)          
+          def #{prop}(*args)
+           if args.size == 0
+             # fetch normal
+             #{options[:type]}s.wrap(__getobj__.#{prop}, self, :#{options[:type]})
+           else
+             # fetch with filter
+             # see if we have a custom filtering method
+             if self.respond_to?(:filter_#{prop})
+               res = filter_#{prop}(*args) # tries a custom query, returns false if it doesn't know how to handle args
+               return res if res # return if successful, go on otherwise
+             end
+             # no custom filtering, use regular one
+             #puts args.inspect
+             # TODO enhance/fix condition transform code
+             a1 = args.first
+             unless a1.is_a?(Hash)
+               a1 = topic_map.get(a1) || {}
+             end
+             a = {}.merge(a1)
+             if a[:type] && !a[:ttype]
+               a[:ttype] = a[:type]
+               a.delete(:type)
+             end
+             puts "#{"#"}{self.class}:#{prop} -- #{"#"}{args.first.inspect}"
+             puts
+             puts a.inspect
+             b = {}
+             a.each do |k,v|
+               if RTM::AR::TMDM::#{options[:type]}.columns.map{|c| c.name}.include?(k)
+                 puts "#{options[:type]} hat spalte: #{"#"}{k}"
+               else
+                 puts "#{options[:type]} hat NICHT spalte: #{"#"}{k}"
+                 b[k] = v
+                 a.delete(k)
+               end
+             end
+             
+             a.each do |k,v|
+               if v.respond_to?(:__getobj__)
+                 a[(k.to_s + "_id").to_sym] = v.id
+               end
+             end
+             res = #{options[:type]}s.wrap(__getobj__.#{prop}.find(:all, :conditions=> a), self, :#{options[:type]})
+             if args.size == 1
+               a1 = args.first
+               res = res.select{|t| t}
+             end
+             res
+           end
+          end
+EOS
+      else
+        module_eval(<<-EOS, "(__AR_DELEGATOR_PROPERTY_SET_NW__)", 1)          
+          def #{prop}
+           __getobj__.#{prop}
+          end
+        EOS
+      end
+
+      if options[:create]
+        # some :create_args:
+        # 
+        # create_locator reference:string
+        # [ :name => :reference, :type => :String]
+        #
+        # create_topic_name value:String, scope:Collection
+        # create_topic_name value:String, type: Topic, scope:Collection
+        # [ {:name => :value, :type => :String}, {:name => :type, :type => :Topic, :optional => true}, {:name => :scope, :type => :Collection} ]
+        #
+        # create_occurrence value:String, type: Topic, scope:Collection
+        # create_occurrence resource: Locator, type: Topic, scope:Collection
+        # [ {:name => :value, :type => [:String, :Locator]}, {:name => :type, :type => :Topic}, {:name => :scope, :type => :Collection} ]
+        #
+        # create_association_role player:topic, type: topic
+        # [ {:name => :player, :type => :Topic}, {:name => :type, :type => :Topic}]
+        #
+        # create_variant value:string, :scope:Collection
+        # create_variant resource:locator, :scope:Collection
+        # [ {:name => :value, :type => [:String, :Locator]}, {:name => :scope, :type => :Collection}]
+
+        module_eval(<<-EOS, "(__AR_DELEGATOR_PROPERTY_SET_CREATE__)", 1)
+          def create_#{ options[:create]}(*args, &block)
+            #puts "#{ options[:create]}"
+            #puts args.inspect
+            arg_defs = #{ (options[:create_args] || nil ).inspect}
+
+            a = parse_args(args, arg_defs)
+            #raise "could not parse parameters:" + a.inspect + " from " + args.inspect if a.empty?
+
+            a = enhance_args_hash(a, arg_defs) if arg_defs
+
+            a = a.reject{|k,v| v.nil?}
+
+            # hack to change :type to :ttype for AR backend
+            # puts a.inspect unless a.is_a? Hash
+            if a[:type] && !a[:ttype]
+              a[:ttype] = a[:type]
+              a.delete(:type)
+            end
+            if [:Locator,:ItemIdentifier, :SubjectIdentifier, :SubjectLocator].include?(:#{options[:type]})
+              unless a[:topic_map]
+                a[:topic_map] = topic_map.__getobj__
+              end
+            end
+
+            if block_given?
+#              if a.respond_to?(:__getobj__)
+#                a = a.__getobj__  
+#              end
+              obj = #{options[:type]}.wrap( __getobj__.#{prop}.new(a) )
+              yield obj
+              obj.save
+            else
+#              if a.respond_to?(:__getobj__)
+#                a = a.__getobj__  
+#              end
+#              raise a.inspect unless a.is_a?(RTM::AR::TMDM::Topic)
+              obj = #{options[:type]}.wrap( __getobj__.#{prop}.create(a) )
+            end
+            self.reload
+            obj
+          end
+        EOS
+
+        if options[:create_aka]
+          aka_property("create_#{options[:create]}", options[:create_aka])
+        end
+      end
+      
+      if options[:add] && options[:add] == :scope
+        module_eval(<<-RUBY, "(__AR_DELEGATOR_PROPERTY_SET_ADD__)", 1)
+          def add_scope(theme)
+            if theme.is_a?(Array)
+              theme.each {|s| add_scope(s)}
+            end
+            scope.add(theme.__getobj__)
+          end
+RUBY
+#       elsif options[:add] && (options[:add] == :subject_identifier || options[:add] == :subject_locator)
+#         module_eval(<<-RUBY, "(__AR_DELEGATOR_PROPERTY_SET_ADD__)", 1)
+#           def add_#{prop.to_s.singularize}(*args, &block)
+#             puts "adding something to #{prop}: #{"#"}{args.inspect}"
+#             obj.#{prop}.add(*args, &block)
+#           end
+# RUBY
+#         aka_property("add_#{prop.to_s.singularize}", options[:aka].map{|a| "add_#{a}"})
+#         aka_property("add_#{prop.to_s.singularize}", options[:aka].map{|a| "a#{a}"})
+      elsif options[:add]
+        module_eval(<<-RUBY, "(__AR_DELEGATOR_PROPERTY_SET_ADD__)", 1)
+          def add_#{prop.to_s.singularize}(*args, &block)
+            #{prop}.add(*args, &block)
+          end
+RUBY
+        aka_property("add_#{prop.to_s.singularize}", options[:aka].map{|a| "add_#{a}"})
+        aka_property("add_#{prop.to_s.singularize}", options[:aka].map{|a| "a#{a}"})
+      end
+
+      if options[:remove] && options[:remove] == :scope
+        module_eval(<<-RUBY, "(__AR_DELEGATOR_PROPERTY_SET_REMOVE__)", 1)
+          def remove_scope(theme)
+            scope.remove(theme)
+          end
+RUBY
+      elsif options[:remove]
+        module_eval(<<-RUBY, "(__AR_DELEGATOR_PROPERTY_SET_REMOVE__)", 1)
+          def remove_#{prop.to_s.singularize}(*args, &block)
+            #{prop}.remove(*args, &block)
+          end
+RUBY
+        aka_property("remove_#{prop.to_s.singularize}", options[:aka].map{|a| "remove_#{a}"})
+        aka_property("remove_#{prop.to_s.singularize}", options[:aka].map{|a| "r#{a}"})
+      end
+
+      # TODO: aliases for property_set.add as add_property
+
+      aka_property(prop, options[:aka]) if options[:aka]
+    end
+
+    private
+    def parse_args(args, arg_defs)
+      a = {}
+      a = args.pop if args.last.is_a? Hash
+      # We are finished if there are no more parameters or we have no arg_def.
+      # Special case: non optional parameters must have been in the Hash, just a hash is also allowed.
+      return a if args.size == 0 || arg_defs == nil
+
+      # we have some args
+      if args.size == arg_defs.size # all are given
+        return args2hash(a, args,arg_defs)
+      elsif args.size == arg_defs.reject { |d| d[:optional]}
+        return args2hash(a, args, arg_defs.reject {|d| d[:optional]})
+      end
+      #warn("Functions with more than one optional parameter are not supported. This will only work if the left out ones are the last.")
+      return args2hash(a, args,arg_defs)
+    end
+
+    def args2hash(a, args, arg_defs)
+      arg_defs.zip(args) do |argd,arg|
+        a[argd[:name]] = arg
+      end
+
+      return a
+    end
+
+    def enhance_args_hash(a, arg_defs)
+      #puts "enhance_args: #{a.inspect} ---\n#{arg_defs.inspect}"
+      return a if a.empty?
+      arg_defs.each do |argd|
+        #puts "enhancing #{argd[:name]}, which is a #{a[argd[:name]].class}"
+        if argd[:type] == :Topic 
+         if a[argd[:name]].is_a? String
+            a[argd[:name]] = topic_map._topic_by_locator!(a[argd[:name]])
+         elsif a[argd[:name]].is_a?(RTM::Topic)
+            a[argd[:name]] = a[argd[:name]].__getobj__
+         end
+        end
+        if argd[:type] == :Locator || (argd[:type].respond_to?(:include?) && argd[:type].include?(:Locator))
+          a[argd[:name]] = a[argd[:name]].to_s
+        end
+      end
+      a
+    end
+
+    public
+    def self.property(prop, options={})
+      module_eval(<<-EOS, "(__AR_DELEGATOR_PROPERTY__)", 1)
+        def #{prop}
+          #{options[:wrap]? "#{options[:type]}.wrap":""}( __getobj__.#{prop})
+        end
+      EOS
+
+      if options[:rw]
+        case options[:type]
+        when :Topic
+          module_eval(<<-EOS, "(__AR_DELEGATOR_PROPERTY2__)", 1)
+            def #{prop}=(obj)
+              obj = topic_map.topic_by_locator!(obj) unless obj.is_a? #{options[:type]}
+              __getobj__.#{prop} = obj.__getobj__
+              __getobj__.save
+            end
+          EOS
+        when :TopicMap
+          module_eval(<<-EOS, "(__AR_DELEGATOR_PROPERTY2__)", 1)
+            def #{prop}=(obj)
+              obj = RTM.create obj.to_s unless obj.is_a? #{options[:type]}
+              __getobj__.#{prop} = obj.__getobj__
+              __getobj__.save
+            end
+          EOS
+        when :String, :Locator
+          module_eval(<<-EOS, "(__AR_DELEGATOR_PROPERTY2__)", 1)
+            def #{prop}=(obj)
+              __getobj__.#{prop} = obj.to_s
+              __getobj__.save
+            end
+          EOS
+        else
+          raise "Don't know how to do wrapping for #{options[:type]}"
+        end
+        
+      end
+
+      aka_property(prop, options[:aka]) if options[:aka]
+    end
+
+    def self.aka_property(prop, aka)
+      aka = [aka].flatten
+      aka.each do |a|
+        #puts "generating alias #{a} for #{prop}"
+        module_eval(<<-EOS, "(__AR_DELEGATOR_AKA_PROPERTY__)", 1)
+          alias :#{a} :#{prop}
+        EOS
+      end
+    end
+
+    def self.equality(eqfields, options={})
+      field_condition = eqfields.map {|f| "self.#{f} == o.#{f}" }.join(" && ")
+      module_eval(<<-EOS, "(__AR_EQUALITY__)", 1)
+        def ==(o)
+          #puts "hoho: #{"#"}{self.inspect} vs. #{"#"}{o.inspect}"
+          return false unless o
+          #{eqfields.map{|x| "#puts '#{x}'; puts self.#{x}.inspect;puts o.#{x}.inspect\n"}}
+          # puts '#{field_condition}'
+          return true if #{field_condition}
+          false
+        end
+      EOS
+    end
+    def eql?(o)
+      return false unless o
+      return true if self.class == o.class && self.id == o.id
+      false
+    end
+    def hash
+      return self.id.hash
+    end
+    
+    def self.wrapper_cache
+      module_eval(<<-EOS, "(__AR_WRAPPER_CACHE__)", 1)
+        def self.wrap(obj)
+          return nil unless obj
+          raise "Double wrapping" if obj.respond_to?(:__getobj__)
+          t = self.wrapped(obj)
+          if t
+            t.__setobj__(obj)
+            return t
+          end
+          self.new(obj)
+        end
+
+        def self.wrapped(unwrapped_obj)
+          @@wrapped ||= {}
+          return @@wrapped[unwrapped_obj.id] if unwrapped_obj.respond_to? :id
+          @@wrapped[unwrapped_obj]
+        end
+        def self.reset_wrapped
+          @@wrapped = {}
+        end
+        def initialize(*args)
+          super
+          @@wrapped ||= {}
+          @@wrapped[self.id]=self
+        end
+      EOS
+    end
+
+    alias :i :id
+    delegate :reload
+  end
+end