rtm-activerecord 0.2.0

data/lib/rtm/activerecord/io/to_jtm.rb

@@ -0,0 +1,141 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::AR::IO
+  # JTM Export.
+  # Each Topic Maps Construct gets a to_jtm method.
+ module TOJTM
+
+    module TopicMap
+      # returns the JTM representation of this topic map
+      def to_jtm_hash(*a)
+        j={}
+        #j['base_locator'] = base_locator, # with absolute item_identifiers its not needed
+        j['reifier'] = reifier.to_jtm_ref if reifier
+        j['item_identifiers'] = item_identifiers.map{|i| i.reference} unless item_identifiers.empty?
+        j['topics'] = topics.map{|i| i.to_jtm_hash} unless topics.empty?
+        j['associations'] = associations.map{|i| i.to_jtm_hash} unless associations.empty?
+        j
+      end
+      def to_jtm(*a)
+        to_jtm_hash.to_json(*a)
+      end
+      alias :to_json :to_jtm
+    end
+
+    module Topic
+      # returns the JTM representation of this topic
+      def to_jtm_hash(*a)
+        j={}
+        j['item_identifiers'] = item_identifiers.map{|i| i.reference} unless item_identifiers.empty?
+        j['subject_identifiers'] = subject_identifiers.map{|i| i.reference} unless subject_identifiers.empty?
+        unless j['item_identifiers'] || j['subject_identifiers']
+          j['item_identifiers'] = [to_jtm_ref]
+        end
+        j['subject_locators'] = subject_locators.map{|i| i.reference} unless subject_locators.empty?
+        j['names'] = names.map{|i| i.to_jtm_hash} unless names.empty?
+        j['occurrences'] = occurrences.map{|i| i.to_jtm_hash} unless occurrences.empty?
+        j
+      end
+      def to_jtm(*a)
+        to_jtm_hash.to_json(*a)
+      end
+      alias :to_json :to_jtm
+      
+      def to_jtm_ref
+        if subject_identifiers.first
+          return subject_identifiers.first.reference
+        end
+        if item_identifiers.first
+          return item_identifiers.first.reference
+        end
+        "t#{id}"
+      end
+    end
+
+    module Association
+      # returns the JTM representation of this association
+      def to_jtm_hash(*a)
+        j={}
+        j['reifier'] = reifier.to_jtm_ref if reifier
+        j['item_identifiers'] = item_identifiers.map{|i| i.reference} unless item_identifiers.empty?
+        j['type'] = type.to_jtm_ref if type
+        j['scope'] = scope.map{|i| i.to_jtm_hash} unless scope.empty?
+        j['roles'] = roles.map{|i| i.to_jtm_hash} unless roles.empty?
+        j
+      end
+      def to_jtm(*a)
+        to_jtm_hash.to_json(*a)
+      end
+      alias :to_json :to_jtm
+
+    end
+
+    module TopicName
+      def to_jtm_hash(*a)
+        j={}
+        j['reifier'] = reifier.to_jtm_ref if reifier
+        j['item_identifiers'] = item_identifiers.map{|i| i.reference} unless item_identifiers.empty?
+        j['value'] = value if value
+        j['type'] = type.to_jtm_ref if type
+        j['scope'] = scope.map{|i| i.to_jtm_hash} unless scope.empty?
+        j['variants'] = variants.map{|i| i.to_jtm_hash} unless variants.empty?
+        j
+      end
+      def to_jtm(*a)
+        to_jtm_hash.to_json(*a)
+      end
+      alias :to_json :to_jtm
+    end
+
+    module Occurrence
+      def to_jtm_hash(*a)
+        j={}
+        j['reifier'] = reifier.to_jtm_ref if reifier
+        j['item_identifiers'] = item_identifiers.map{|i| i.reference} unless item_identifiers.empty?
+        j['value'] = value if value
+        j['datatype'] = datatype if datatype
+        j['type'] = type.to_jtm_ref if type
+        j['scope'] = scope.map{|i| i.to_jtm_hash} unless scope.empty?
+        j
+      end
+      def to_jtm(*a)
+        to_jtm_hash.to_json(*a)
+      end
+      alias :to_json :to_jtm
+    end
+
+    module AssociationRole
+      def to_jtm_hash(*a)
+        j={}
+        j['reifier'] = reifier.to_jtm_ref if reifier
+        j['item_identifiers'] = item_identifiers.map{|i| i.reference} unless item_identifiers.empty?
+        j['player'] = player.to_jtm_ref if player
+        j['type'] = type.to_jtm_ref if type
+        j
+      end
+      def to_jtm(*a)
+        to_jtm_hash.to_json(*a)
+      end
+      alias :to_json :to_jtm
+    end
+
+    module Variant
+      def to_jtm_hash(*a)
+        j={}
+        j['reifier'] = reifier.to_jtm_ref if reifier
+        j['item_identifiers'] = item_identifiers.map{|i| i.reference} unless item_identifiers.empty?
+        j['value'] = value if value
+        j['scope'] = scope.map{|i| i.to_jtm_hash} unless scope.empty?
+        j
+      end
+      def to_jtm(*a)
+        to_jtm_hash.to_json(*a)
+      end
+      alias :to_json :to_jtm
+    end
+  
+    RTM::AR.register_extension self 
+  end
+end
+  

data/lib/rtm/activerecord/io/to_string.rb

@@ -0,0 +1,130 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::AR:IO
+  # Each Topic Maps Construct gets a custom to_s method which supports optional :short or :long output.
+  module TOSTRING
+
+    module TopicMap
+      # Returns different String representations. Try :short (default), :long, :super (original)
+      def to_s(style=:short)
+        case style
+        when :short
+          "#<RTM::TopicMap id=#{id} base_locator=\"#{base_locator}\">"
+        when :long
+          r = " #{reifier.to_s(:short)}" if reifier
+          i = " iids=#{item_identifiers.to_s}" unless item_identifiers.empty?
+          "#<RTM::TopicMap id=#{id} base_locator=\"#{base_locator}\"#{r}#{i} topics:#{topics.size} associations:#{associations.size}>"
+        else
+          super() # these () are needed, otherwise the own parameters are passed in
+        end
+      end    
+    end
+
+    module Topic
+      # Returns different String representations. Try :short (default), :long or something else for the original method.
+      # :name returns one (random) name for the Topic or an empty string if the topic has no name
+      def to_s(style=:short)
+        case style
+        when :short
+          ssid = " sids=#{subject_identifiers.to_s}" unless subject_identifiers.empty?
+          sslo = " slos=#{subject_locators.to_s}" unless subject_locators.empty?
+          siid = " iids=#{item_identifiers.to_s}" unless item_identifiers.empty?
+          "#<RTM::Topic id=#{id}#{ssid}#{sslo}#{siid}>"
+        when :long
+          ssid = " sids=#{subject_identifiers.to_s}" unless subject_identifiers.empty?
+          sslo = " slos=#{subject_locators.to_s}" unless subject_locators.empty?
+          siid = " iids=#{item_identifiers.to_s}" unless item_identifiers.empty?
+          "#<RTM::Topic id=#{id}#{ssid}#{sslo}#{siid} names:#{names.size} occurrences:#{occurrences.size}>"
+        when :name
+          return names.first.to_s(:short) if names.first
+          return ""
+        else
+          super() # these () are needed, otherwise the own parameters are passed in
+        end
+      end    
+    end
+
+    module Association
+      def to_s(style=:short)
+        case style
+        when :short
+          r = " #{reifier.to_s(:short)}" if reifier
+          i = " iids=#{item_identifiers.to_s}" unless item_identifiers.empty?
+          "#<RTM::Association id=#{id}#{i}#{r}>"
+        when :long
+          r = " #{reifier.to_s(:short)}" if reifier
+          i = " iids=#{item_identifiers.to_s}" unless item_identifiers.empty?
+          "#<RTM::Association id=#{id}#{i}#{r} type=#{type.to_s(:short)} roles=[#{roles.entries.map { |ar| ar.to_s }.join(", ")}]>"
+        else
+          super() # these () are needed, otherwise the own parameters are passed in
+        end
+      end
+    end
+
+    module AssociationRole
+      def to_s(style=:short)
+        case style
+        when :short
+          r = " #{reifier.to_s(:short)}" if reifier
+          i = " iids=#{item_identifiers.to_s}" unless item_identifiers.empty?
+          "#<RTM::AssociationRole id=#{id}#{i}#{r}>"
+        when :long
+          r = " #{reifier.to_s(:short)}" if reifier
+          i = " iids=#{item_identifiers.to_s}" unless item_identifiers.empty?
+          "#<RTM::Association id=#{id}#{i}#{r} type=#{type.to_s(:short)} player=#{player.to_s(:short)}>"
+        else
+          super() # these () are needed, otherwise the own parameters are passed in
+        end
+      end
+    end
+
+    module TopicName
+      def to_s(style=:short)
+        case style
+        when :short
+          value
+        when :long
+          r = " #{reifier.to_s(:short)}" if reifier
+          i = " iids=#{item_identifiers.to_s}" unless item_identifiers.empty?
+          "#<RTM::TopicName id=#{id}#{i}#{r} type=#{type.to_s(:short)} value=#{value} variants:#{variants.size}>"
+        else
+          super() # these () are needed, otherwise the own parameters are passed in
+        end
+      end
+    end
+
+    module Occurrence
+      def to_s(style=:short)
+        case style
+        when :short
+          value
+        when :long
+          r = " #{reifier.to_s(:short)}" if reifier
+          i = " iids=#{item_identifiers.to_s}" unless item_identifiers.empty?
+          "#<RTM::Occurrence id=#{id}#{i}#{r} type=#{type.to_s(:short)} value=#{value} datatype=#{datatype}>"
+        else
+          super() # these () are needed, otherwise the own parameters are passed in
+        end
+      end
+    end
+
+    module Variant
+      def to_s(style=:short)
+        case style
+        when :short
+          value
+        when :long
+          r = " #{reifier.to_s(:short)}" if reifier
+          i = " iids=#{item_identifiers.to_s}" unless item_identifiers.empty?
+          "#<RTM::Variant id=#{id}#{i}#{r} value=#{value} scope=[scope.to_s]>"
+        else
+          super() # these () are needed, otherwise the own parameters are passed in
+        end
+      end
+    end
+  
+    RTM::AR.register_extension self 
+  end
+end
+  

data/lib/rtm/activerecord/io/to_xtm1.rb

@@ -0,0 +1,162 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::AR::IO
+  # XTM1 Export
+  module TOXTM1
+    require 'rexml/document'
+    def self.scope(scope)
+      res = REXML::Element.new('scope')
+      scope.each do |s|
+        res << s.to_xtm_ref
+      end
+      res
+    end
+    def self.type(type)
+      res = REXML::Element.new('type')
+      res << type.to_xtm_ref
+      res
+    end
+    def self.value(datatype, value)
+      if datatype == RTM::PSI[:IRI]
+        res = REXML::Element.new 'resourceRef'
+        res.add_attribute('href', value)
+      else
+        res = REXML::Element.new 'resourceData'
+        res.add_attribute('datatype', datatype) if datatype
+        res.text = value
+      end
+      res
+    end
+    def self.locator(loc, tagname = "itemIdentity")
+      x = REXML::Element.new(tagname)
+      x.add_attribute('href',loc.to_s) # loc could be Locator or String, to_s serves both
+      x
+    end
+
+    module TopicMap
+      # returns the XTM 2.0 representation of this topic map as an REXML::Document, ready for outputting
+      def to_xtm1
+        # topicMap = element topicMap { reifiable, version, mergeMap*,
+        #                               (topic | association)* }
+        doc = REXML::Document.new
+        doc << REXML::XMLDecl.new
+        x = doc.add_element 'topicMap', {'xmlns' => 'http://www.topicmaps.org/xtm/', 'version' => '2.0'}
+        x.add_attribute('reifier', reifier.xtm1_id) if reifier
+        x << REXML::Comment.new("Topics count: #{topics.size}")
+        x << REXML::Comment.new("Associations count: #{associations.size}")
+        item_identifiers.each { |ii| x << TOXTM1.locator(ii) } # itemIdentity
+        # mergeMap not used
+        topics.each { |t| x << t.to_xtm1 }
+        associations.each { |a| x << a.to_xtm1 }
+        doc
+        x
+      end
+    end
+
+    module Topic
+      # this is a helper-method for the to_xtm1 amd to_xtm1_ref methods
+      def xtm1_id
+        "t#{id}"
+      end
+      # returns the XTM 2.0 representation of this topic as an REXML::Element
+      def to_xtm1
+        #topic = element topic { id,
+        #                    (itemIdentity | subjectLocator | subjectIdentifier)*,
+        #                    instanceOf?, (name | occurrence)* }
+        x = REXML::Element.new('topic')
+        x.add_attribute('id', xtm1_id )
+        item_identifiers.each { |ii| x << TOXTM1.locator(ii) } # itemIdentity
+        subject_identifiers.each { |si| x << TOXTM1.locator(si, "subjectIdentifier") } # subjectIdentifier
+        if item_identifiers.empty? && subject_identifiers.empty?
+          TOXTM1.locator(xtm1_id) # itemIdentity
+        end
+        subject_locators.each { |sl| x << TOXTM1.locator(sl, "subjectLocator") } # subjectLocator
+        # I guess we won't create instanceOf-Elements but instead type-instance associations.
+        names.each { |n| x << n.to_xtm1 }
+        occurrences.each { |o| x << o.to_xtm1 }
+        x
+      end
+      # returns the an (internal) XTM 2.0 reference to this topic
+      def to_xtm1_ref
+        x = REXML::Element.new 'topicRef'
+        x.add_attribute('href', "##{xtm1_id}")
+        x
+      end
+    end
+
+    module Association
+      # returns the XTM 2.0 representation of this association as an REXML::Element
+      def to_xtm1
+        warn("TOXTM1: Warning: outputting invalid Association #{self}") unless valid?
+        # association = element association { reifiable, type, scope?, role+ }
+        x = REXML::Element.new 'association'
+        x.add_attribute('reifier', reifier.xtm1_id) if reifier
+        item_identifiers.each { |ii| x << TOXTM1.ii(ii) } # itemIdentity
+        x << TOXTM1.type(type) if type
+        x << TOXTM1.scope(scope) unless scope.empty?
+        roles.each { |r| x << r.to_xtm1 }
+        x
+      end
+    end
+
+    module TopicName
+      def to_xtm1
+        warn("TOXTM1: Warning: outputting invalid TopicName #{self}") unless valid?
+        # name = element name { reifiable, type?, scope?, value, variant* }
+        x = REXML::Element.new 'name'
+        x.add_attribute('reifier', reifier.xtm1_id) if reifier
+        item_identifiers.each { |ii| x << TOXTM1.ii(ii) } # itemIdentity
+        x << TOXTM1.type(type) if type
+        x << TOXTM1.scope(scope) unless scope.empty?
+        (x << REXML::Element.new('value')).text = value # adds the value within a value-element
+        variants.each { |v| x << v.to_xtm1 }
+        x
+      end
+    end
+
+    module Occurrence
+      def to_xtm1
+        warn("TOXTM1: Warning: outputting invalid Occurrence #{self}") unless valid?
+        # occurrence = element occurrence { reifiable,
+        #   type, scope?, ( resourceRef | resourceData ) }
+        x = REXML::Element.new 'occurrence'
+        x.add_attribute('reifier', reifier.xtm1_id) if reifier
+        item_identifiers.each { |ii| x << TOXTM1.ii(ii) } # itemIdentity
+        x << TOXTM1.type(type) if type
+        x << TOXTM1.scope(scope) unless scope.empty?
+        x << TOXTM1.value(datatype, value)
+        x
+      end
+    end
+
+    module AssociationRole
+      def to_xtm1
+        warn("TOXTM1: Warning: outputting invalid AssociationRole #{self}") unless valid?
+        # role = element role { reifiable, type, topicRef }
+        x = REXML::Element.new 'role'
+        x.add_attribute('reifier', reifier.xtm1_id) if reifier
+        item_identifiers.each { |ii| x << TOXTM1.ii(ii) } # itemIdentity
+        x << TOXTM1.type(type) if type
+        x << player.to_xtm1_ref if player
+        x
+      end
+    end
+
+    module Variant
+      def to_xtm1
+        warn("TOXTM1: Warning: outputting invalid Variant #{self}") unless valid?
+        # variant = element variant { reifiable, scope, (resourceRef | resourceData) }
+        x = REXML::Element.new 'variant'
+        x.add_attribute('reifier', reifier.xtm1_id) if reifier
+        item_identifiers.each { |ii| x << TOXTM1.ii(ii) } # itemIdentity
+        x << TOXTM1.scope(scope)
+        x << TOXTM1.value(datatype, value)
+        x
+      end
+    end
+  
+    RTM::AR.register_extension self 
+  end
+end
+  

data/lib/rtm/activerecord/io/to_xtm2.rb

@@ -0,0 +1,163 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::AR::IO
+  # XTM2 Export.
+  # Each Topic Maps Construct gets a to_xtm2 method.
+  # The result is a REXML::Element except for TopicMap where it is a REXML::Document.
+  module TOXTM2
+    require 'rexml/document'
+    def self.scope(scope)
+      res = REXML::Element.new('scope')
+      scope.each do |s|
+        res << s.to_xtm2_ref
+      end
+      res
+    end
+    def self.type(type)
+      res = REXML::Element.new('type')
+      res << type.to_xtm2_ref
+      res
+    end
+    def self.value(datatype, value)
+      if datatype == RTM::PSI[:IRI]
+        res = REXML::Element.new 'resourceRef'
+        res.add_attribute('href', value)
+      else
+        res = REXML::Element.new 'resourceData'
+        res.add_attribute('datatype', datatype) if datatype
+        res.text = value
+      end
+      res
+    end
+    def self.locator(loc, tagname = "itemIdentity")
+      x = REXML::Element.new(tagname)
+      x.add_attribute('href',loc.to_s) # loc could be Locator or String, to_s serves both
+      x
+    end
+
+    module TopicMap
+      # returns the XTM 2.0 representation of this topic map as an REXML::Document, ready for outputting
+      def to_xtm2
+        # topicMap = element topicMap { reifiable, version, mergeMap*,
+        #                               (topic | association)* }
+        doc = REXML::Document.new
+        doc << REXML::XMLDecl.new
+        x = doc.add_element 'topicMap', {'xmlns' => 'http://www.topicmaps.org/xtm/', 'version' => '2.0'}
+        x.add_attribute('reifier', reifier.xtm2_id) if reifier
+        x << REXML::Comment.new("Topics count: #{topics.size}")
+        x << REXML::Comment.new("Associations count: #{associations.size}")
+        item_identifiers.each { |ii| x << TOXTM2.locator(ii) } # itemIdentity
+        # mergeMap not used
+        topics.each { |t| x << t.to_xtm2 }
+        associations.each { |a| x << a.to_xtm2 }
+        doc
+      end
+    end
+
+    module Topic
+      # this is a helper-method for the to_xtm2 amd to_xtm2_ref methods
+      def xtm2_id
+        "t#{id}"
+      end
+      # returns the XTM 2.0 representation of this topic as an REXML::Element
+      def to_xtm2
+        #topic = element topic { id,
+        #                    (itemIdentity | subjectLocator | subjectIdentifier)*,
+        #                    instanceOf?, (name | occurrence)* }
+        x = REXML::Element.new('topic')
+        x.add_attribute('id', xtm2_id )
+        item_identifiers.each { |ii| x << TOXTM2.locator(ii) } # itemIdentity
+        subject_identifiers.each { |si| x << TOXTM2.locator(si, "subjectIdentifier") } # subjectIdentifier
+        if item_identifiers.empty? && subject_identifiers.empty?
+          TOXTM2.locator(xtm2_id) # itemIdentity
+        end
+        subject_locators.each { |sl| x << TOXTM2.locator(sl, "subjectLocator") } # subjectLocator
+        # I guess we won't create instanceOf-Elements but instead type-instance associations.
+        names.each { |n| x << n.to_xtm2 }
+        occurrences.each { |o| x << o.to_xtm2 }
+        x
+      end
+      # returns the an (internal) XTM 2.0 reference to this topic
+      def to_xtm2_ref
+        x = REXML::Element.new 'topicRef'
+        x.add_attribute('href', "##{xtm2_id}")
+        x
+      end
+    end
+
+    module Association
+      # returns the XTM 2.0 representation of this association as an REXML::Element
+      def to_xtm2
+        warn("TOXTM2: Warning: outputting invalid Association #{self}") unless valid?
+        # association = element association { reifiable, type, scope?, role+ }
+        x = REXML::Element.new 'association'
+        x.add_attribute('reifier', reifier.xtm2_id) if reifier
+        item_identifiers.each { |ii| x << TOXTM2.locator(ii) } # itemIdentity
+        x << TOXTM2.type(type) if type
+        x << TOXTM2.scope(scope) unless scope.empty?
+        roles.each { |r| x << r.to_xtm2 }
+        x
+      end
+    end
+
+    module TopicName
+      def to_xtm2
+        warn("TOXTM2: Warning: outputting invalid TopicName #{self}") unless valid?
+        # name = element name { reifiable, type?, scope?, value, variant* }
+        x = REXML::Element.new 'name'
+        x.add_attribute('reifier', reifier.xtm2_id) if reifier
+        item_identifiers.each { |ii| x << TOXTM2.locator(ii) } # itemIdentity
+        x << TOXTM2.type(type) if type
+        x << TOXTM2.scope(scope) unless scope.empty?
+        (x << REXML::Element.new('value')).text = value # adds the value within a value-element
+        variants.each { |v| x << v.to_xtm2 }
+        x
+      end
+    end
+
+    module Occurrence
+      def to_xtm2
+        warn("TOXTM2: Warning: outputting invalid Occurrence #{self}") unless valid?
+        # occurrence = element occurrence { reifiable,
+        #   type, scope?, ( resourceRef | resourceData ) }
+        x = REXML::Element.new 'occurrence'
+        x.add_attribute('reifier', reifier.xtm2_id) if reifier
+        item_identifiers.each { |ii| x << TOXTM2.locator(ii) } # itemIdentity
+        x << TOXTM2.type(type) if type
+        x << TOXTM2.scope(scope) unless scope.empty?
+        x << TOXTM2.value(datatype, value)
+        x
+      end
+    end
+
+    module AssociationRole
+      def to_xtm2
+        warn("TOXTM2: Warning: outputting invalid AssociationRole #{self}") unless valid?
+        # role = element role { reifiable, type, topicRef }
+        x = REXML::Element.new 'role'
+        x.add_attribute('reifier', reifier.xtm2_id) if reifier
+        item_identifiers.each { |ii| x << TOXTM2.locator(ii) } # itemIdentity
+        x << TOXTM2.type(type) if type
+        x << player.to_xtm2_ref if player
+        x
+      end
+    end
+
+    module Variant
+      def to_xtm2
+        warn("TOXTM2: Warning: outputting invalid Variant #{self}") unless valid?
+        # variant = element variant { reifiable, scope, (resourceRef | resourceData) }
+        x = REXML::Element.new 'variant'
+        x.add_attribute('reifier', reifier.xtm2_id) if reifier
+        item_identifiers.each { |ii| x << TOXTM2.locator(ii) } # itemIdentity
+        x << TOXTM2.scope(scope)
+        x << TOXTM2.value(datatype, value)
+        x
+      end
+    end
+  
+    RTM::AR.register_extension self 
+  end
+end
+