rtm 0.1.0 → 0.1.1

data/lib/rtm/backend/active_record/tm_set_delegator.rb

@@ -0,0 +1,195 @@
+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
+            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
+end

data/lib/rtm/backend/active_record/tmdm.rb

@@ -291,4 +291,3 @@ module RTM::AR
     end
   end
 end
-  

data/lib/rtm/backend/active_record/topic.rb

@@ -0,0 +1,153 @@
+module RTM::AR
+  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 characteristics
+      topic_names.to_a + occurrences.to_a
+    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
+    
+    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
+
+    def counterparts
+      self.roles.map{|sr| sr.parent.roles.reject{|r| r.id==sr.id}}
+    end
+    def counterplayers
+      self.counterparts.map{|r| r.player}
+    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
+end

data/lib/rtm/backend/active_record/topic_map.rb

@@ -0,0 +1,285 @@
+module RTM::AR
+  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
+end