rtm-activerecord 0.2.0

data/lib/rtm/activerecord/tm_set_delegator.rb

@@ -0,0 +1,226 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::AR
+  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
+            puts
+            puts "trying to add SI to a topic"
+            tbi = @parent.topic_map._item_identifier(obj)
+            if tbi && tmc=tbi.construct
+              puts "something with this II exists"
+              if tmc.class.name =~ /::Topic$/
+                puts "it exists as a topic"
+                puts tmc == @parent.__getobj__
+                return @parent if tmc == @parent.__getobj__
+                
+                puts "trying to merge"
+                puts "BEFORE"
+                begin
+                result = Topic.wrap(tmc).merge(@parent)
+                rescue Exception => e
+                  puts e.inspect
+                  raise e
+                end
+                puts "AFTER"
+                puts "done merging, now adding SI"
+                
+                #result = @parent.merge(Topic.wrap(tmc))
+                # 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)
+                puts "done adding SI, now reloading"
+                result.reload
+                puts "done reloading"
+                return result
+              else
+                warn("This subject identifier IRI already belongs to another topic map construct (not a topic)")
+              end
+            end
+            puts "checking for existing SI"
+            # check for existing subject identifier
+            tbsi = @parent.topic_map._subject_identifier(obj.to_s)
+            if tbsi
+              puts "SI exists"
+              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
+      when :Topic
+        obj = @parent.topic_map.get!(obj).__getobj__
+      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.__getobj__)
+      #@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
+        Constructs.wrap(res)
+      else
+        Construct.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
+
+    def ==(x)
+      self.to_a == x.to_a
+    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
+end

data/lib/rtm/activerecord/tmdm.rb

@@ -0,0 +1,309 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+old_verbose=$VERBOSE
+$VERBOSE=false
+require 'active_record'
+$VERBOSE=old_verbose
+
+module RTM::AR
+  # The Active Record TMDM backend
+  module TMDM
+    # Moves all fields in a collection to another owner (for classes using belongs_to in AR::Base class)
+    module Movable
+      # Takes a list of [field,from, to] arguments.
+      # RTM::AR::TMDM::ItemIdentifier.move_all(
+      #      ["construct_id", other.__getobj__.id, self.__getobj__.id],
+      #      ["construct_type", other.__getobj__.class.name, self.__getobj__.class.name]
+      #    )
+      # or
+      # RTM::AR::TMDM::Variant.move_all(["name_id", other.__getobj__.id, self.__getobj__.id])
+
+      # 
+      def move_all(*args)
+        raise "All parameters must have a size of 3: [field_name, from, to]" unless args.all?{|a| a.size == 3}
+        set_part = ""
+        where_part = ""
+        args.each do |field, from, to|
+          set_part += ", " unless set_part.empty?
+          where_part += " and " unless where_part.empty?
+          from = "'#{from}'" unless from.is_a? Numeric
+          to = "'#{to}'" unless to.is_a? Numeric
+          where_part += "#{field} = #{from}"
+          set_part += "#{field} = #{to}"
+        end
+        #puts "setpart: #{set_part.inspect}\nwherepart: #{where_part.inspect}"
+        res = self.update_all(set_part, where_part)
+        #puts "result: #{res.inspect}"
+      end
+    end
+
+    class Construct < ActiveRecord::Base
+      self.store_full_sti_class = false 
+      extend Movable
+      class << self
+        def abstract_class?
+          self == Construct
+        end
+        def alias_ar_relation(new,old)
+          alias_method new, old
+          alias_method "#{new}=", "#{old}="
+        end
+        alias :alias_belongs_to  :alias_ar_relation
+        alias :alias_has_many :alias_ar_relation
+        def belongs_to_with_alias(name, synonym)
+          belongs_to name
+          alias_belongs_to synonym, name
+        end
+        def has_many_with_alias(name, synonym, *args)
+          has_many name, *args
+          alias_has_many synonym, name
+        end
+        def belongs_to_parent(parent)
+          belongs_to parent
+          alias_belongs_to :parent, parent
+        end
+        def this_is_a_typed_object
+          belongs_to :ttype, :class_name => "Topic", :foreign_key => :ttype_id
+          module_eval(<<-EOS, "(__RTM_AR_TMDM_TYPED_OBJECT__)", 1)
+          def type=(ptype)
+            self.ttype=ptype
+          end
+          def type
+            self.ttype
+          end
+          EOS
+        end
+      end
+      has_many :item_identifiers, :as => :construct, :dependent => :destroy
+      def topic_map
+        parent.topic_map
+      end
+      def move_to(new_parent)
+        self.parent = new_parent
+      end
+
+    end
+    class Reifiable < Construct
+      def self.abstract_class?
+        self == Reifiable
+      end
+      has_one :reifier, :class_name => "Topic", :as => :reified
+    end
+    class ScopedObject < Reifiable
+      def self.abstract_class?
+        self == ScopedObject
+      end
+      has_many :scoped_objects_topics, :as => :scoped_object, :dependent => :destroy
+      has_many :scope, :through => :scoped_objects_topics, :source => :topic
+#      def scope
+#        self.scoped_objects_topics.map { |sot| sot.topic }
+#      end
+#      def add_scoping_topic(topic) # this is not ruby-ish but at least it works, would need a complete association proxy instead...
+#        sot = ScopedObjectsTopic.create :topic => topic, :scoped_object => self
+#        self
+#        #      sot = ScopedObjectsTopic.new :topic => topic, :scoped_object => self
+#        #      self.scoped_objects_topics << sot
+#        #      self
+#      end
+#      def remove_scoping_topic(topic) # this is not ruby-ish but at least it works, would need a complete association proxy instead...
+#        self.scoped_objects_topics.select { |sot| sot.topic == topic }.destroy
+#        self
+#      end
+    end
+    class ScopedObjectsTopic < ActiveRecord::Base
+      self.store_full_sti_class = false 
+      extend Movable
+      belongs_to :topic, :class_name => 'RTM::AR::TMDM::Topic'
+      belongs_to :scoped_object, :polymorphic => true
+      belongs_to :association, :class_name => 'RTM::AR::TMDM::Association', :foreign_key => "scoped_object_id"
+      belongs_to :name, :class_name => 'RTM::AR::TMDM::Name', :foreign_key => "scoped_object_id"
+      belongs_to :variant, :class_name => 'RTM::AR::TMDM::Variant', :foreign_key => "scoped_object_id"
+      belongs_to :occurrence, :class_name => 'RTM::AR::TMDM::Occurrence', :foreign_key => "scoped_object_id"
+    end
+  
+    class Locator < ActiveRecord::Base
+      self.store_full_sti_class = false 
+      extend Movable
+      class << self
+        def abstract_class?
+          self == Locator
+        end
+      end
+      belongs_to :topic_map
+    end
+
+    class ItemIdentifier < Locator
+      belongs_to :construct, :polymorphic => true
+      def to_s
+        self.reference
+      end
+      def move_to(new_tmc)
+        #puts "\n\nmoving\n\t#{self.inspect}\n\nto\n\t#{new_tmc.inspect}"
+        #self.update_all "construct_id = #{new_tmc.id}, construct_type = '#{new_tmc.class.name}'", 
+        #puts "changing id"
+        #puts self.construct_id = new_tmc.id
+        #puts "changing type"
+        #puts self.construct_type = new_tmc.class.name
+        self.construct = new_tmc
+        #puts "saving"
+        self.save
+        #
+        # das geht!!!
+        #self.class.update( self.id, "construct_id" => new_tmc.id)
+      end
+    end
+    class SubjectLocator < Locator
+      belongs_to :topic
+      def to_s
+        self.reference
+      end
+    end
+    class SubjectIdentifier < Locator
+      belongs_to :topic
+      def to_s
+        self.reference
+      end
+    end
+    # http://www.isotopicmaps.org/sam/sam-model/#d0e736
+    class Topic < Construct
+      belongs_to :reified, :polymorphic => true
+      belongs_to_parent :topic_map
+      has_many :subject_locators, :dependent => :destroy
+      has_many :subject_identifiers, :dependent => :destroy
+      has_many :occurrences, :dependent => :destroy
+      has_many_with_alias :names, :topic_names, :dependent => :destroy
+      has_many_with_alias :roles, :association_roles, :include => :association
+      has_many :associations, :through => :roles, :dependent => :destroy
+      #has_many :played_types, :through => :association_roles, :source => :type
+      
+      has_many :typed_associations, :class_name => "Association", :foreign_key => :ttype_id
+      has_many :typed_roles, :class_name => "Role", :foreign_key => :ttype_id
+      has_many :typed_names, :class_name => "Name", :foreign_key => :ttype_id
+      has_many :typed_occurrences, :class_name => "Occurrence", :foreign_key => :ttype_id
+    
+      has_many :scoped_objects_topics
+      has_many :scoped_associations, :through => :scoped_objects_topics, :source => :association,
+        :conditions => "scoped_objects_topics.scoped_object_type = 'RTM::AR::TMDM::Association'"
+      has_many :scoped_names, :through => :scoped_objects_topics, :source => :name,
+        :conditions => "scoped_objects_topics.scoped_object_type = 'RTM::AR::TMDM::Name'"
+      has_many :scoped_variants, :through => :scoped_objects_topics, :source => :variant,
+        :conditions => "scoped_objects_topics.scoped_object_type = 'RTM::AR::TMDM::Variant'"
+      has_many :scoped_occurrences, :through => :scoped_objects_topics, :source => :occurrence,
+        :conditions => "scoped_objects_topics.scoped_object_type = 'RTM::AR::TMDM::Occurrence'"
+
+#      def scoped_objects
+#        self.scoped_objects_topics.collect { |a| a.scoped_object } # temporary hack polymorphic has_many_through
+#      end
+      def scoped
+        scoped_associations + scoped_names + scoped_variants + scoped_occurrences
+      end
+
+      def typed
+        typed_associations + typed_roles + typed_names + typed_occurrences
+      end
+
+    end
+
+    class Role < Reifiable
+      belongs_to_parent :association
+      belongs_to_with_alias :topic, :player
+      this_is_a_typed_object
+    end
+
+    class Name < ScopedObject
+      belongs_to_parent :topic
+      this_is_a_typed_object
+      has_many :variants, :dependent => :destroy
+    end
+
+    class Association < ScopedObject
+      belongs_to_parent :topic_map
+      this_is_a_typed_object
+      has_many_with_alias :roles, :roles, :dependent => :destroy
+      def create_role(rplayer, ttype)
+        Role.create :parent => self, :player => rplayer, :ttype => ttype
+      end
+      alias :create_association_role :create_role
+      has_many :players, :through => :roles, :source => :topic
+      has_many :types, :through => :roles, :source => :ttype
+    end
+    
+    class AssociationCache < Construct
+      set_table_name "associations_cache"
+      belongs_to_parent :topic_map
+      this_is_a_typed_object
+      has_many_with_alias :roles, :association_roles
+      belongs_to :role1, :class_name => "RTM::AR::TMDM::Role", :foreign_key => "role1_id"
+      belongs_to :player1, :class_name => "RTM::AR::TMDM::Topic", :foreign_key => "player1_id"
+      belongs_to :type1, :class_name => "RTM::AR::TMDM::Topic", :foreign_key => "type1_id"
+      belongs_to :role2, :class_name => "RTM::AR::TMDM::Role", :foreign_key => "role2_id"
+      belongs_to :player2, :class_name => "RTM::AR::TMDM::Topic", :foreign_key => "player2_id"
+      belongs_to :type2, :class_name => "RTM::AR::TMDM::Topic", :foreign_key => "type2_id"
+      # rolecount -> rcnt
+    end
+
+    class Occurrence < ScopedObject
+      belongs_to_parent :topic
+      this_is_a_typed_object
+    end
+
+    class Variant < ScopedObject
+      belongs_to_parent :name
+      def topic_map
+        parent.topic_map
+      end
+    end
+
+    class TopicMap < Reifiable
+      # real properties
+      has_many :topics, :dependent => :destroy, :include => [:subject_identifiers, :subject_locators]
+      has_many :associations, :dependent => :destroy, :include => :roles
+      
+      # access to subproperties
+      has_many :locators, :class_name => "ItemIdentifier", :dependent => :destroy
+      has_many :subject_locators, :dependent => :destroy
+      has_many :subject_identifiers, :dependent => :destroy
+
+      has_many :names, :through => :topics
+      alias :topic_names :names
+      
+      has_many :occurrences, :through => :topics
+      has_many :roles, :through => :associations
+      alias :association_roles :roles
+      
+      %w[association role name occurrence].each do |m|
+        module_eval(<<-EOS, "(__AR_DELEGATOR_INDEX_PROPERTY_SET__)", 1)
+          def #{m}_types
+            topics.select{|t| t.#{m}s_typed.size > 0}
+          end
+        EOS
+      end
+      
+      #typing
+#      has_many :association_types, :class_name => "Association", :foreign_key => :ttype_id
+#      has_many :role_types, :class_name => "Role", :foreign_key => :ttype_id
+#      has_many :name_types, :class_name => "Name", :foreign_key => :ttype_id
+#      has_many :occurrence_types, :class_name => "Occurrence", :foreign_key => :ttype_id
+
+#      has_many :association_types, :aka => :at, :type => :Topic, :wrap => true
+#      has_many :role_types, :aka => [:association_role_types,:art,:rt], :type => :Topic, :wrap => true
+#      has_many :name_types, :aka => [:name_types,:tnt,:nt], :type => :Topic, :wrap => true
+#      has_many :occurrence_types, :aka => :ot, :type => :Topic, :wrap => true
+
+      
+      def topic_map
+        self
+      end
+
+#      # Creates a new Locator in this TopicMap
+#      def create_locator(reference, notation=nil)
+#        if notation
+#          ItemIdentifier.create :reference => reference, :notation => notation
+#        else
+#          ItemIdentifier.create :reference => reference # is there a better way to preserve the database default notation if none given?
+#        end
+#      end
+    end
+  end
+end