rtm 0.1.0 → 0.1.1

data/lib/rtm/backend/active_record.rb

@@ -41,1354 +41,13 @@ end
 module RTM::AR
   require 'uri'
   require 'rtm/backend/active_record/tmdm'
-
-  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
-      module_eval(<<-EOS, "(__TMDELEGATOR__)", 1)
-        def #{sym}(*args, &block)
-          __getobj__.send(:#{to}, *args, &block)
-        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}
-          TopicMapConstruct.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
-             #puts args.inspect
-             # TODO enhance/fix condition transform code
-             a = {}.merge(args.first)
-             if a[:type] && !a[:ttype]
-               a[:ttype] = a[:type]
-               a.delete(:type)
-             end
-             a.each do |k,v|
-               if v.respond_to?(:__getobj__)
-                 a[(k.to_s + "_id").to_sym] = v.id
-               end
-             end
-             #{options[:type]}s.wrap(__getobj__.#{prop}.find(:all, :conditions=> a), self, :#{options[:type]})
-           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)
-            arg_defs = #{ (options[:create_args] || nil ).inspect}
-
-            a = parse_args(args, arg_defs)
-
-            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?
-              obj = #{options[:type]}.wrap( __getobj__.#{options[:create]}s.new(a) )
-              yield obj
-              obj.save
-            else
-              obj = #{options[:type]}.wrap( __getobj__.#{options[:create]}s.create(a) )
-            end
-            obj
-          end
-        EOS
-
-        if options[:create_aka]
-          aka_property("create_#{options[:create]}", options[:create_aka])
-        end
-      end
-      
-      if 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]
-        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.index_property_set(prop, options={})
-      r = options[:rule]
-      module_eval(<<-EOS, "(__AR_DELEGATOR_INDEX_PROPERTY_SET__)", 1)
-        def direct_#{prop}_roles
-          # prefetch typing topics
-          rtype = @ips_#{prop}_rtype ||= self.topic_map.get("#{r[:role_type]}")
-          atype = @ips_#{prop}_atype ||= self.topic_map.get("#{r[:association_type]}")
-          otype = @ips_#{prop}_otype ||= self.topic_map.get("#{r[:other_role_type]}")
-          # return nothing if any of the typing topics does not exist
-          return [] unless rtype && atype && otype
-          # we do that only here and not earlier because some might me nil
-          rtype = rtype.id
-          atype = atype.id
-          otype = otype.id
-          self.__getobj__.roles.map{|r|
-            r.ttype_id != nil &&
-              r.ttype_id == rtype &&
-              r.parent.roles.size == #{r[:association_arity]} &&
-              r.parent != nil &&
-              r.parent.ttype_id == atype &&
-              (r2 = r.parent.roles.select{|r2| r2.ttype_id != nil &&
-                r2.ttype_id == otype}.first) &&
-              r2}.select{|r2| r2}.map{|r2| AssociationRole.wrap(r2)}
-        end
-        def direct_#{prop}
-          direct_#{prop}_roles.map{|r2| r2.player}.uniq
-        end
-      EOS
-      
-      if r[:transitive]
-        module_eval(<<-EOS, "(__AR_DELEGATOR_INDEX_PROPERTY_SET2__)", 1)
-          def #{prop}
-            d = todo = self.direct_#{prop}
-            while todo.size > 0
-              todo = todo.map{|dt| dt.direct_#{prop}}.flatten.uniq - d
-              d += todo
-            end
-            d
-            #d2 = self.direct_#{prop}.map {|dt| dt.#{prop}}.flatten
-            #(d+d2).uniq
-          end
-        EOS
-      else
-        if r[:infer]
-          module_eval(<<-EOS, "(__AR_DELEGATOR_INDEX_PROPERTY_SET3__)", 1)
-            def #{prop}
-              (self.direct_#{prop} + self.#{r[:infer]}.map{|d2| d2.direct_#{prop}}).flatten.uniq
-            end
-          EOS
-        elsif r[:infer_other]
-          module_eval(<<-EOS, "(__AR_DELEGATOR_INDEX_PROPERTY_SET4__)", 1)
-            def #{prop}
-              d = self.direct_#{prop}
-              (d + d.map{|d2| d2.#{r[:infer_other]}}).flatten.uniq
-            end
-          EOS
-        end
-      end
-      if r[:add]
-        module_eval(<<-EOS, "(__AR_DELEGATOR_INDEX_PROPERTY_SET5__)", 1)
-          def add_#{r[:add]}(t)
-            a = self.topic_map.create_association("#{r[:association_type]}")
-            a.create_role self, "#{r[:role_type]}"
-            a.create_role t, "#{r[:other_role_type]}"
-            a
-            # TODO add_x in index_property_set needs to trigger reload of the topics somewhere
-          end
-          def remove_#{r[:add]}(t)
-            direct_#{prop}_roles.select{|r| r.player == t}.each{|r| r.parent.remove}
-            # TODO remove_x in index_property_set needs to trigger reload of the topics somewhere
-          end
-        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)
-          return false unless o
-          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
-
-  class TMSetDelegator < TMDelegator
-    include Enumerable
-    #    attr_reader :content_class_name
-    def initialize(obj,parent,type)
-      @obj = obj
-      @parent = parent
-      @type = type
-    end
-
-    # This class method wraps a Set completely while the instance method wraps one single contained object
-    def self.wrap(obj, parent=nil, type=nil)
-      return nil unless obj
-      raise "Double wrapping" if obj.respond_to?(:__getobj__)
-      self.new(obj, parent, type)
-    end
-
-    def add(obj)
-      return unless obj
-
-      old = @obj.detect { |x| x == obj } # can't that be done easier?
-      if old
-        old.merge obj
-      else
-        if obj.respond_to? :__getobj__
-          @obj << obj.__getobj__
-        else
-          case @type
-          when :Topic
-            @obj << @parent.topic_map.get!(obj).__getobj__
-            @parent.__getobj__.reload
-
-          when :ItemIdentifier
-            if @parent.class.name.to_s =~ /::Topic$/
-              tbi = @parent.topic_map._item_identifier(obj)
-              if tbi && tmc=tbi.topic_map_construct
-                if tmc.class.name =~ /::Topic$/
-                  return @parent if tmc == @parent.__getobj__
-                  result = Topic.wrap(tmc).merge @parent
-                  return result
-                else
-                  raise "Duplicate Item Identifier"
-                end
-              end
-              tbsi = @parent.topic_map._subject_identifier(obj.to_s)
-              if tbsi
-                if t=tbsi.topic
-                  return @parent if t == @parent.__getobj__
-                  result = Topic.wrap(t).merge @parent
-                  # after merging, we still need to add the II
-                  result.__getobj__.item_identifiers.create(:reference => obj.to_s, :topic_map_id => @parent.topic_map.__getobj__.id)
-                  return result
-                end
-              end
-            end
-            result = @obj << @parent.topic_map._item_identifier!(obj.to_s)
-            return result
-
-          when :SubjectIdentifier
-            # check for existing item identifier
-            tbi = @parent.topic_map._item_identifier(obj)
-            if tbi && tmc=tbi.topic_map_construct
-              if tmc.class.name =~ /::Topic$/
-                return @parent if tmc == @parent.__getobj__
-                result = Topic.wrap(tmc).merge @parent
-                # after merging, we still need to add the SI
-                result.__getobj__.subject_identifiers.create(:reference => obj.to_s, :topic_map_id => @parent.topic_map.__getobj__.id)
-                return result
-              else
-                warn("This subject identifier IRI already belongs to another topic map construct (not a topic)")
-              end
-            end
-            # check for existing subject identifier
-            tbsi = @parent.topic_map._subject_identifier(obj.to_s)
-            if tbsi
-              if true && t=tbsi.topic #the single = is intentional, the "true &&" just makes netbeans not raise a warning
-                return @parent if t == @parent.__getobj__
-                result = Topic.wrap(t).merge @parent
-                return result
-              end
-            end
-            @obj.create(:reference => obj.to_s, :topic_map_id => @parent.topic_map.__getobj__.id)
-
-          when :SubjectLocator
-            tbsl = @parent.topic_map._subject_locator(obj.to_s)
-            if tbsl
-              if true && t=tbsl.topic #the single = is intentional, the "true &&" just makes netbeans not raise a warning
-                return @parent if t == @parent.__getobj__
-                result = Topic.wrap(t).merge @parent
-                return result
-              end
-            end
-            @obj.create(:reference => obj.to_s, :topic_map_id => @parent.topic_map.__getobj__.id)
-
-          end
-        end
-      end
-    end
-    alias :<< :add
-    
-    def add_all(objs)
-      return unless objs
-      objs.each {|obj| add(obj)}
-      true
-    end
-
-    def each(&b)
-      @obj.each { |e| yield wrap(e)}
-    end
-
-    def size
-      @obj.size
-    end
-    alias :length :size
-    
-    def empty?
-      @obj.empty?
-    end
-
-    def delete(obj)
-      obj = obj.__getobj__ if obj.respond_to? :__getobj__
-      case @type
-      when :ItemIdentifier, :SubjectIdentifier, :SubjectLocator
-        obj = @obj.find_by_reference(@parent.topic_map.resolve(obj.to_s)) if obj.is_a? String
-      end
-      @obj.delete(obj)
-      # item_identifiers: remove also from topicMap
-      #removed_event obj if respond_to? :removed_event
-    end
-    alias :remove :delete
-
-    def include?(obj)
-      return @obj.include?(obj)
-      #@obj.each { |e| return true if e == obj } # T#ODO support for get
-      #false
-    end
-
-    def first
-      wrap(@obj.entries.first)
-    end
-    def last
-      wrap(@obj.entries.last)
-    end
-
-    def to_s
-      "[#{@obj.entries.map { |e| wrap(e).to_s }.join(", ") }]"
-    end
-    def [](i)
-      wrap(@obj[i])
-    end
-
-    def content_class
-      #      @content_class ||= RTM.const_get(@content_class_name)
-      @content_class ||= RTM.const_get("#{@content_class_name}MemImpl")
-    end
-    
-    def find(*args)
-      res = @obj.find(*args)
-      if res.respond_to? :each
-        TopicMapConstructs.wrap(res)
-      else
-        TopicMapConstruct.wrap(res)
-      end
-    end
-    
-    def &(other)
-      @obj.to_a & other.to_a
-    end
-    
-    alias :old_method_missing :method_missing
-    def method_missing(method_name, *args)
-      if @obj.size > 0 && first.respond_to?(method_name) && (![:__getobj__, :__setobj__].include?(method_name))
-        a = []
-        inject(a) {|all,single| all << single.send(method_name, *args)}
-        a
-      else
-        old_method_missing(method_name, *args)
-      end
-    end
-    
-    alias :old_respond_to? :respond_to?
-    def respond_to?(method_name)
-      resp = old_respond_to?(method_name)
-      return resp if resp # i.e. if true
-      return false if [:__getobj__, :__setobj__].include?(method_name)
-      # ... and ask first child otherwise
-      @obj.size > 0 && first.respond_to?(method_name)
-    end
-
-    # TMSetDelegator#to_a doesn't help as thought, but maybe we come back to that l8r...
-    #def to_a
-    #  @obj.map {|o| wrap(o)}
-    #end
-  end
-
-  class TopicMapConstruct < TMDelegator
-    include RTM::TopicMapConstruct
-
-    def self.abstract_class?
-      self == TopicMapConstruct
-    end
-    property_set :item_identifiers, :aka => [:ii, :iid, :source_locators], :type => :ItemIdentifier, :wrap => true,
-      #:create => :item_identifier, :create_aka => :cii
-      :add => true, :remove => true
-
-    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::TopicName"
-        TopicName.wrap(obj)
-      when "RTM::AR::TMDM::Occurrence"
-        Occurrence.wrap(obj)
-      when "RTM::AR::TMDM::Association"
-        Association.wrap(obj)
-      when "RTM::AR::TMDM::AssociationRole"
-        AssociationRole.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
-        TopicMapConstructs.wrap(res)
-      else
-        TopicMapConstruct.wrap(res)
-      end
-    end
-  end
-
-  class Reifiable < TopicMapConstruct
-    include RTM::Reifiable
-
-    def self.abstract_class?
-      self == Reifiable
-    end
-    property :reifier, :type => :Topic, :rw => :true, :wrap => true
-  end
-
-  class TopicMap < Reifiable
-    include RTM::TopicMap
-    wrapper_cache
-    property_set :topics, :aka => :t, :type => :Topic, :wrap => true,
-      :create => :topic,  :create_aka => :ct
-     
-    property_set :associations, :aka => [:a, :assocs], :type => :Association, :wrap => true,
-      :create => :association, :create_aka => :ca,
-      :create_args => [{:name => :type, :type => :Topic}]
-
-
-    delegate :base_locator
-
-    property_set :association_types, :aka => :at, :type => :Topic, :wrap => true
-    property_set :association_role_types, :aka => [:role_types,:art,:rt], :type => :Topic, :wrap => true
-    property_set :topic_name_types, :aka => [:name_types,:tnt,:nt], :type => :Topic, :wrap => true
-    property_set :occurrence_types, :aka => :ot, :type => :Topic, :wrap => true
-    
-    property_set :topic_names, :aka => [:names,:n], :type => :TopicName, :wrap => :true
-    property_set :occurrences, :aka => :o, :type => :Occurrence, :wrap => :true
-    property_set :association_roles, :aka => [:roles, :r], :type => :AssociationRole, :wrap => :true
-
-    def types
-      topics.select{|t| t.instances.size > 0}
-    end
-    alias :topic_types :types
-    def fast_types
-      
-    end
-    
-    # This fetches all topics who have no topic-instances (but they might be types for associations etc.).
-    # See indivduals
-    def non_types
-      topics.select{|t| t.instances.size == 0}
-    end
-    
-    # This fetches all topics which are not type for something else (including topics, associations etc.).
-    # See non_types
-    def individuals
-      non_types.select{|t| t.associations_typed.size==0 && t.roles_typed.size==0 && t.names_typed.size==0 && t.occurrences_typed.size==0}
-    end
-    def instances
-      topics.select{|t| t.types.size > 0}
-    end
-    def non_instances
-      topics.reject{|t| t.types.size > 0}
-    end
-    def internal_occurrences
-      occurrences.select{|o| o.datatype != RTM::PSI[:IRI]}
-    end
-    def external_occurrences
-      occurrences.select{|o| o.datatype == RTM::PSI[:IRI]}
-    end
-    
-    def self.create(base_locator, params={})
-      tm = self.wrap(TMDM::TopicMap.find_or_create_by_base_locator(base_locator))
-      yield tm if block_given?
-      tm
-    end
-
-    def self.topic_maps
-      TopicMaps.wrap(TMDM::TopicMap.find(:all))
-    end
-
-    # Resolves an IRI or fragment relative to the base_locator of this topic_map or an optional given alternative_base_locator
-    # 
-    # Absolute IRIs are taken as is.
-    # 
-    # Relative IRIs:
-    # If the base_locator is a directory (ends with "/") it is appended like a file, i.e. directly
-    # If the base_locator is a file it is appended as a fragment (with # in between)
-    def resolve(obj,alternative_base_locator=nil)
-      uri = obj.to_s
-# TODO     uri = URI.decode(obj.to_s) # this InvalidURIError somethimes :(
-      begin
-        uri_uri = URI.parse(uri)
-      rescue URI::InvalidComponentError => ice
-        warn "Catched an URI::InvalidComponentError for URI: #{uri}, message was \"#{ice.message}\"\n" +
-          "Will continue using the UNRESOLVED IRI, claiming it is absolute."
-        return uri
-      end
-      if uri_uri.absolute?
-        return uri_uri.to_s
-      end
-      
-      uri = uri[1..-1] if uri[0] == "#"[0]
-      bl = alternative_base_locator || base_locator
-      if bl[-1,1] == "/"
-        return bl + uri
-      else
-        return bl + "#" + uri
-      end
-    end
-    
-    #private
-    
-    def _item_identifier(iid)
-      __getobj__.locators.find_by_reference(resolve(iid)) # doesn't work :( --> , :include => [ :topic_map_construct ])
-    end
-    def _item_identifier!(iid)
-      __getobj__.locators.find_or_create_by_reference(resolve(iid)) # doesn't work :( --> , :include => [ :topic_map_construct ])
-    end
-    
-    def _subject_identifier(iid)
-      __getobj__.subject_identifiers.find_by_reference(iid, :include => :topic)
-    end
-    def _subject_identifier!(iid)
-      __getobj__.subject_identifiers.find_or_create_by_reference(iid, :include => :topic)
-    end
-    
-    def _subject_locator(iid)
-      __getobj__.subject_locators.find_by_reference(iid, :include => :topic)
-    end
-    def _subject_locator!(iid)
-      __getobj__.subject_locators.find_or_create_by_reference(iid, :include => :topic)
-    end
-    
-    
-    # internal helper for by_item_identifier, doesn't wrap result
-    def _by_item_identifier(iid)
-      ii = __getobj__.locators.find_by_reference(resolve(iid)) #, :include => [ :topic_map_construct ])
-      return ii.topic_map_construct if ii
-      nil
-    end
-    def _topic_by_item_identifier(iid)
-      t = _by_item_identifier(iid)
-      return nil unless t
-      return t if t.class.name =~ /::Topic$/ # only return something if the thing is a topic
-      nil
-    end
-    
-    # internal helper for topic_by_item_identifier!, doesn't wrap result
-    def _topic_by_item_identifier!(iid)
-      ii = __getobj__.locators.find_or_create_by_reference(resolve(iid))#, :include => [ :topic_map_construct ])
-      return ii.topic_map_construct if ii.topic_map_construct && ii.topic_map_construct_type =~ /::Topic$/
-      top2 = _topic_by_subject_identifier(resolve(iid))
-      if top2
-        ii.topic_map_construct = top2
-      else
-        ii.topic_map_construct = create_topic.__getobj__
-      end
-      ii.save
-      ii.topic_map_construct
-    end        
-    # internal helper for topic_by_subject_identifier, doesn't wrap result
-    def _topic_by_subject_identifier(sid)
-      si = __getobj__.subject_identifiers.find_by_reference(sid, :include => [ :topic ])
-      return si.topic if si
-      nil
-    end
-    # internal helper for topic_by_subject_identifier!, doesn't wrap result
-    def _topic_by_subject_identifier!(sid)
-      si =  __getobj__.subject_identifiers.find_or_create_by_reference(sid, :include => [ :topic ])
-      return si.topic if si.topic
-      begin
-      top2 = _by_item_identifier(sid)
-      rescue ActiveRecord::RecordNotFound => rnf
-        si.topic = create_topic.__getobj__
-      else
-        if top2 && top2.respond_to?(:subject_identifiers)
-          si.topic = top2
-        else
-          si.topic = create_topic.__getobj__
-        end
-      end
-      si.save
-      si.topic
-    end
-
-    # internal helper for topic_by_subject_locator, doesn't wrap result
-    def _topic_by_subject_locator(slo)
-      sl = __getobj__.subject_locators.find_by_reference(RTM::LocatorHelpers.slo2iri(slo)) #, :include => [ :topic ])
-      return sl.topic if sl
-      nil
-    end
-
-    # internal helper for topic_by_subject_locator!, doesn't wrap result
-    def _topic_by_subject_locator!(slo)
-      sl = __getobj__.subject_locators.find_or_create_by_reference(RTM::LocatorHelpers.slo2iri(slo), :include => [ :topic ])
-      return sl.topic if sl.topic
-      sl.topic = create_topic.__getobj__
-      sl.save
-      sl.topic
-    end
-    def _topic_by_locator(iri)
-      raise "Locator may not be nil" unless iri
-      if RTM::LocatorHelpers.is_a_slo?(iri)
-        _topic_by_subject_locator(iri)
-      elsif URI.parse(iri).absolute?
-        _topic_by_subject_identifier(iri)
-      else
-        _topic_by_item_identifier(iri)
-      end
-    end
-
-    def _topic_by_locator!(iri)
-      raise "Locator may not be nil" unless iri
-      if RTM::LocatorHelpers.is_a_slo?(iri)
-        _topic_by_subject_locator!(iri)
-      elsif URI.parse(iri).absolute?
-        _topic_by_subject_identifier!(iri)
-      else
-        _topic_by_item_identifier!(iri)
-      end
-    end
-
-    public
-    # returns an item identifier from the topic_map if it exists
-    def item_identifier(iid)
-      ItemIdentifier.wrap(_item_identifier(iid))
-    end
-    # returns an item identififier from the topic_map or creates it if it doesn't exist
-    def item_identifier!(iid)
-      ItemIdentifier.wrap(_item_identifier!(iid))
-    end
-    alias :create_locator :item_identifier!
-    # Returns a topic map construct by it's item identifier or nil if not found.
-    # It's the equivalent to TMAPI's TopicMapObjectIndex.getTopicMapObjectBySourceLocator
-    def by_item_identifier(iid)
-      TopicMapConstruct.wrap(_by_item_identifier(iid))
-    end
-    # Returns a topic by it's item identifier. The topic will be created if not found.
-    def topic_by_item_identifier!(iid)
-      Topic.wrap(_topic_by_item_identifier!(iid))
-    end
-    # Returns a topic by it's subject identifier or nil if not found.
-    # It's the equivalent to TMAPI's TopicsIndex.getTopicBySubjectIdentifier.
-    def topic_by_subject_identifier(sid)
-      Topic.wrap(_topic_by_subject_identifier(sid))
-    end
-    # returns a topic by it's subject identifier. The topic will be created if not found.
-    def topic_by_subject_identifier!(sid)
-      Topic.wrap(_topic_by_subject_identifier!(sid))
-    end
-    # Returns a topic by it's subject locator or nil if not found.
-    # It's the equivalent to TMAPI's TopicsIndex.getTopicBySubjectLocator
-    def topic_by_subject_locator(slo)
-      Topic.wrap(_topic_by_subject_locator(slo))
-    end
-    # returns a topic by it's subject locator. The topic will be created if not found.
-    def topic_by_subject_locator!(slo)
-      Topic.wrap(_topic_by_subject_locator!(slo))
-    end
-    
-    # Gets a topic from this topic map using its (relative) item identifier,
-    # its (absolute) subject identifier or its (absolute and by "=" prepended) subject locator)
-    #
-    # Returns nil if the Topic does not exist.
-    #
-    def topic_by_locator(iri)
-      return iri if iri.is_a? Topic
-#      @tblc ||= {}
-#      t = @tblc[iri]
-#      return t if t
-      t = Topic.wrap(_topic_by_locator(iri))
-#      @tblc[iri] = t if t
-#      t
-    end
-    alias :get :topic_by_locator
-
-    # Gets a topic from this topic map using its (relative) item identifier,
-    # its (absolute) subject identifier or its (absolute and by "=" prepended) subject locator)
-    #
-    # If there is no topic with this item identifier, subject identifier or subject locator, it is created.
-    # 
-    def topic_by_locator!(iri)
-      return iri if iri.is_a? Topic
-#      @tblc ||= {}
-#      t = @tblc[iri]
-#      return t if t
-      t = Topic.wrap(_topic_by_locator!(iri))
-#      @tblc[iri] = t
-#      t
-    end
-    alias :get! :topic_by_locator!
-    
-    # I am not sure if this is at all correct. TMDM doesn't say a word about it
-    # and the approach to compare topic maps is CXTM. I chose this because we 
-    # should (at least at the time of writing) have only one topic with a given
-    # base locator in RTM. If you don't like it, drop me a mail and explain why
-    # and propose something better.
-    equality [:base_locator]
-  end
-
-  class Topic < TopicMapConstruct
-    include RTM::Topic
-    wrapper_cache
-
-    parent :topic_map
-    property_set :subject_identifiers, :aka => [:si,:sid], :type => :SubjectIdentifier, :wrap => true,
-      #:create => :subject_identifier, :create_aka => [:csi,:csid],
-      #:create_args => [{:name => :reference, :type => :String}]
-      :add => true, :remove => true
-    property_set :subject_locators, :aka => [:sl,:slo], :type => :SubjectLocator, :wrap => true,
-      #:create => :subject_locator, :create_aka => [:csl, :cslo],
-      #:create_args => [{:name => :reference, :type => :String}]
-      :add => true, :remove => true
-
-    property :reified, :computable => true, :type => :Reifiable, :wrap => true
-
-    property_set :topic_names, :aka => [:n, :names], :type => :TopicName, :wrap => true,
-      :create => :topic_name, :create_aka => [:create_name, :cn], 
-      :create_args => [ {:name => :value, :type => :String}, {:name => :type, :type => :Topic, :optional => true}, {:name => :scope, :type => :Collection} ]
-
-    property_set :occurrences, :aka => :o, :type => :Occurrence, :wrap => true,
-      :create => :occurrence, :create_aka => :co,
-      :create_args => [ {:name => :value, :type => [:String, :Locator]}, {:name => :type, :type => :Topic}, {:name => :scope, :type => :Collection} ]
-
-    def internal_occurrences
-      occurrences.select{|o| o.datatype != RTM::PSI[:IRI]}
-    end
-    def external_occurrences
-      occurrences.select{|o| o.datatype == RTM::PSI[:IRI]}
-    end
-    
-    property_set :roles, :aka => [:r, :roles_played, :association_roles], :computable => true, :type => :AssociationRole, :wrap => true
-
-    property_set :associations, :aka => [:a, :associations_played], :type => :Association, :wrap => true
-
-    property_set :scoped_objects, :type => :TopicMapConstruct, :wrap => true
-    property_set :scoped_associations, :type => :Association, :wrap => true
-    property_set :scoped_topic_names, :aka => :scoped_names, :type => :TopicName, :wrap => true
-    property_set :scoped_variants, :type => :Variant, :wrap => true
-    property_set :scoped_occurrences, :type => :Occurrence, :wrap => true
-
-    property_set :associations_typed, :aka => :at, :type => :Association, :wrap => true
-    property_set :association_roles_typed, :aka => [:roles_typed,:art,:rt], :type => :AssociationRole, :wrap => true
-    property_set :topic_names_typed, :aka => [:names_typed,:tnt,:nt], :type => :TopicName, :wrap => true
-    property_set :occurrences_typed, :aka => :ot, :type => :Occurrence, :wrap => true
-    
-    # maybe these pairs could be declared each with a single statement and a reversible option
-    index_property_set :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,
-    }
-    index_property_set :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,
-    }
-    index_property_set :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,
-    }
-    index_property_set :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,
-    }
-    
-    def [](topicref)
-      topicref =~ /^(-\s*)?(.+)?$/
-      if $1
-        nametype = $2 || RTM::PSI[:name_type]
-        names.select{|n| n.type == topic_map.get(nametype)}
-      else
-        raise "No occurrence type given" unless $2 and !$2.empty?
-        occurrences.select{|o| o.type == topic_map.get($2)}
-      end
-    end
-    
-    def []=(topicref, value)
-      topicref =~ /^(-\s*)?(.+)?$/
-      if $1
-        nametype = $2 || topic_map.get!(RTM::PSI[:name_type])
-        n = create_name(value, nametype)
-        n
-      else
-        raise "No occurrence type given" unless $2
-        o = create_occurrence(value, $2)
-        o
-      end
-    end
-
-    # class:Topic equality, http://www.isotopicmaps.org/sam/sam-model/#d0e1029
-    #
-    # This method is all crap. These ActiveRecord Arrays can't be intersected,
-    # so I map the identifiers to their reference which seems long winded.
-    # Still I find it better than using their ID in the long.
-    # 
-    def ==(o)
-      return false unless o
-      # Two topic items are equal if they have:
-      # * at least one equal string in their [subject identifiers] properties,
-      # -> test if intersection are > 0
-      my_si = self.subject_identifiers.map{|si| si.reference}
-      ot_si = o.subject_identifiers.map{|si| si.reference}
-      return true if ( my_si & ot_si).size > 0 
-
-      # * at least one equal string in their [item identifiers] properties,
-      my_ii = self.item_identifiers.map{|ii| ii.reference}
-      ot_ii = o.item_identifiers.map{|ii| ii.reference}
-      return true if (my_ii & ot_ii).size > 0 
-
-      # * at least one equal string in their [subject locators] properties,
-      my_sl = self.subject_locators.map{|sl| sl.reference}
-      ot_sl = o.subject_locators.map{|sl| sl.reference}
-      return true if (my_sl & ot_sl).size > 0 
-
-      # * an equal string in the [subject identifiers] property of the one topic item and the [item identifiers] property of the other, or
-      return true if (my_si & ot_ii).size > 0 
-      return true if (my_ii & ot_si).size > 0 
-
-      # * the same information item in their [reified] properties.
-      return true if self.reified != nil && o.reified != nil && (self.reified == o.reified)
-      # ... otherwise
-      false
-    end
-  end
-
-  class Association < Reifiable
-    include RTM::Association
-    wrapper_cache
-
-    parent :topic_map
-    property :type, :aka => [:ty,:t], :rw => true, :type => :Topic, :wrap => true
-    property_set :scope, :type => :Topic, :wrap => true
-    property_set :roles, :aka => [:r, :association_roles],  :type => :AssociationRole, :wrap => true,
-      :create => :role, :create_aka => [:cr, :create_association_role],
-      :create_args => [ {:name => :player, :type => :Topic}, {:name => :type, :type => :Topic}]
-    
-    property_set :role_players, :aka => [:players, :rp, :pl], :type => :Topic, :wrap => true
-    property_set :role_types, :aka => [:types, :rt], :type => :Topic, :wrap => true
-    
-    equality [:scope, :type, :roles]
-  end
-
-  class AssociationRole < Reifiable
-    include RTM::AssociationRole
-    wrapper_cache
-
-    parent :association
-    property :player, :aka => [:pl,:topic], :rw => true, :type => :Topic, :wrap => true
-    property :type, :aka => [:ty,:t], :rw => true, :type => :Topic, :wrap => true
-
-    def counterparts
-      self.parent.roles.reject{|r| r.id==self.id}
-    end
-    def counterplayers
-      self.counterparts.map{|r| r.player}
-    end
-    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.parent.roles.reject{|r| r.id==self.id}.first
-    end
-    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.parent.roles.reject{|r| r.id==self.id}.first.player
-    end
-    def peers
-      self.counterpart.player.roles.select{|r| r.type == cp.type}.counterpart
-    end
-    def peerplayers
-      self.peers.map{|r| r.player}
-    end
-    
-    equality [:type, :player, :parent]
-  end
-
-  class TopicName < Reifiable
-    include RTM::TopicName
-    wrapper_cache
-
-    parent :topic
-    property :type, :aka => [:ty,:t], :rw => true, :type => :Topic, :wrap => true
-    property_set :scope, :type => :Topic, :wrap => true
-
-    property_set :variants, :aka => :v, :type => :Variant, :wrap => true,
-      :create => :variant, :create_aka => :cv,
-      :create_args => [ {:name => :value, :type => [:String, :Locator]}, {:name => :scope, :type => :Collection}]
-
-    property :value, :rw => true, :type => :String
-
-    equality [:value, :type, :scope, :parent]
-  end
-
-  class Occurrence < Reifiable
-    include RTM::Occurrence
-    wrapper_cache
-
-    parent :topic
-    property :value, :rw => true, :type => :String
-    property :datatype, :rw => true, :type => :String
-
-    property_set :scope, :type => :Topic, :wrap => true
-    property :type, :aka => [:ty,:t], :rw => true, :type => :Topic, :wrap => true
-
-    equality [:value, :datatype, :scope, :type, :parent]
-  end
-
-  class Variant < Reifiable
-    include RTM::Variant
-    wrapper_cache
-
-    parent :topic_name, :aka => :name
-    property :value, :rw => true, :type => :String
-    property :datatype, :rw => true, :type => :Locator #, :wrap => true
-    property_set :scope, :type => :Topic, :wrap => true
-
-    equality [:value, :datatype, :scope, :parent]
-
-  end
-
-  class Locator < TMDelegator
-    include RTM::Locator
-
-    delegate :+
-    delegate :-
-    #delegate :==
-    delegate :id
-
-    delegate :get
-    delegate :hash
-    delegate :resolve_relative
-    delegate :to_s, :to => :reference
-    delegate :to_uri
-    delegate :uri
-    delegate :reference, :rw => true, :save => true
-    alias :value :reference
-    alias :value= :reference=
-
-    equality [:reference]
-
-    def self.wrap(obj)
-      return nil unless obj
-      raise "Double wrapping" if obj.respond_to?(:__getobj__)
-      case obj.class.name
-      when "RTM::AR::TMDM::ItemIdentifier"
-        ItemIdentifier.wrap(obj)
-      when "RTM::AR::TMDM::SubjectIdentifier"
-        SubjectIdentifier.wrap(obj)
-      when "RTM::AR::TMDM::SubjectLocator"
-        SubjectLocator.wrap(obj)
-      else
-        raise "Can't wrap object. Class for wrapping #{obj.class} unknown (object: #{obj})"
-      end
-    end
-    
-    
-  end
-  
-  
-  class ItemIdentifier < Locator
-    include RTM::ItemIdentifier
-    wrapper_cache
-    property :topic_map_construct, :type => :TopicMapConstruct, :wrap => true
-  end
-  class SubjectIdentifier < Locator
-    include RTM::SubjectIdentifier
-    wrapper_cache
-    property :topic, :type => :Topic, :wrap => true
-  end
-  class SubjectLocator < Locator
-    include RTM::SubjectLocator
-    wrapper_cache
-    property :topic, :type => :Topic, :wrap => true    
-  end
-  class Topics < TMSetDelegator
-    def wrap(obj)
-      Topic.wrap(obj)
-    end
-  end
-  class TopicMapConstructs < TMSetDelegator
-    def wrap(obj)
-      TopicMapConstruct.wrap(obj)
-    end
-  end
-  class Associations < TMSetDelegator
-    def wrap(obj)
-      Association.wrap(obj)
-    end
-  end
-  class TopicNames < TMSetDelegator
-    def wrap(obj)
-      TopicName.wrap(obj)
-    end
-  end
-  class Occurrences < TMSetDelegator
-    def wrap(obj)
-      Occurrence.wrap(obj)
-    end
-  end
-  class AssociationRoles < TMSetDelegator
-    def wrap(obj)
-      AssociationRole.wrap(obj)
-    end
-  end
-  class Reifiables < TMSetDelegator
-    def wrap(obj)
-      TopicMapConstruct.wrap(obj)
-    end
-  end
-  class Variants < TMSetDelegator
-    def wrap(obj)
-      Variant.wrap(obj)
-    end
-  end
-  class TopicMaps < TMSetDelegator
-    def [](obj)
-      # support for getting topic_map by base_locator
-      if obj.is_a? String
-        # return wrap(__getobj__.find { |tm| tm.base_locator == obj })
-        return wrap(TMDM::TopicMap.find_by_base_locator(obj))
-      end
-      # normal index retrieval
-      super
-    end
-
-    def wrap(obj)
-      TopicMap.wrap(obj)
-    end
-  end
-  class Locators < TMSetDelegator
-    def [](obj)
-      # support for getting locators by reference
-      if obj.is_a? String
-        return wrap(__getobj__.find { |tm| tm.reference == obj })
-      end
-      # normal index retrieval
-      super
-    end
-    def wrap(obj)
-      return nil unless obj
-      return obj if obj.respond_to? :__getobj__
-      case obj.class.name
-      when "RTM::AR::TMDM::ItemIdentifier"
-        ItemIdentifier.wrap(obj)
-      when "RTM::AR::TMDM::SubjectIdentifier"
-        SubjectIdentifier.wrap(obj)
-      when "RTM::AR::TMDM::SubjectLocator"
-        SubjectLocator.wrap(obj)        
-      else
-        Locator.wrap(obj)
-      end
-    end      
-  end
-  
-  class ItemIdentifiers < Locators
-    def wrap(obj)
-      ItemIdentifier.wrap(obj)
-    end      
-  end
-  class SubjectIdentifiers < Locators
-    def wrap(obj)
-      SubjectIdentifier.wrap(obj)
-    end      
-    
-  end
-  class SubjectLocators < Locators
-    def wrap(obj)
-      SubjectLocator.wrap(obj)
-    end
-  end
-
+  require 'rtm/backend/active_record/tm_delegator'
+  require 'rtm/backend/active_record/tm_set_delegator'
+  require 'rtm/backend/active_record/tm_construct'
+  require 'rtm/backend/active_record/topic_map'
+  require 'rtm/backend/active_record/topic'
+  require 'rtm/backend/active_record/association_and_role'
+  require 'rtm/backend/active_record/name_variant_occurrence'
+  require 'rtm/backend/active_record/locators'
+  require 'rtm/backend/active_record/set_wrapper'
 end
-