rtm 0.1.6 → 0.2

data/lib/rtm/psi.rb

@@ -1,3 +1,6 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
 module RTM
   PSI = {}
   PSI[:type_instance] = "http://psi.topicmaps.org/iso13250/model/type-instance"
@@ -20,10 +23,21 @@ module RTM
   #PSI[:XTMxx] = "http://www.topicmaps.org/xtm/"
   #PSI[:XS] = "http://www.w3.org/2001/XMLSchema"
   #PSI[:DC] = "http://purl.org/dc/elements/1.1/"
+  PSI[:Float] = "http://www.w3.org/2001/XMLSchema#float"
+  PSI[:Double] = "http://www.w3.org/2001/XMLSchema#double"
+  PSI[:Long] = "http://www.w3.org/2001/XMLSchema#long"
+  PSI[:Integer] = "http://www.w3.org/2001/XMLSchema#integer"
+  PSI[:Int] = "http://www.w3.org/2001/XMLSchema#int"
+  PSI[:Decimal] = "http://www.w3.org/2001/XMLSchema#decimal"
+  PSI[:Date] = "http://www.w3.org/2001/XMLSchema#date"
+  PSI[:DateTime] = "http://www.w3.org/2001/XMLSchema#dateTime"
+  PSI[:Time] = "http://www.w3.org/2001/XMLSchema#time"
 
   PSI[:XTM] = "http://psi.topicmaps.org/iso13250/glossary/XTM"
   PSI[:association] = "http://psi.topicmaps.org/iso13250/glossary/association"
+  PSI[:role] = "http://psi.topicmaps.org/iso13250/glossary/association-role"
   PSI[:association_role] = "http://psi.topicmaps.org/iso13250/glossary/association-role"
+  PSI[:role_type] = "http://psi.topicmaps.org/iso13250/glossary/association-role-type"
   PSI[:association_role_type] = "http://psi.topicmaps.org/iso13250/glossary/association-role-type"
   PSI[:association_type] = "http://psi.topicmaps.org/iso13250/glossary/association-type"
   PSI[:information_resource] = "http://psi.topicmaps.org/iso13250/glossary/information-resource"
@@ -41,14 +55,36 @@ module RTM
   PSI[:subject_locator] = "http://psi.topicmaps.org/iso13250/glossary/subject-locator"
   PSI[:topic] = "http://psi.topicmaps.org/iso13250/glossary/topic"
   PSI[:topic_map] = "http://psi.topicmaps.org/iso13250/glossary/topic-map"
+  PSI[:construct] = "http://psi.topicmaps.org/iso13250/glossary/topic-map-construct"
   PSI[:topic_map_construct] = "http://psi.topicmaps.org/iso13250/glossary/topic-map-construct"
   PSI[:Topic_Maps] = "http://psi.topicmaps.org/iso13250/glossary/Topic-Maps"
   PSI[:topic_name] = "http://psi.topicmaps.org/iso13250/glossary/topic-name"
   PSI[:topic_name_type] = "http://psi.topicmaps.org/iso13250/glossary/topic-name-type"
   PSI[:topic_type] = "http://psi.topicmaps.org/iso13250/glossary/topic-type"
   PSI[:unconstrained_scope] = "http://psi.topicmaps.org/iso13250/glossary/unconstrained-scope"
+  PSI[:variant] = "http://psi.topicmaps.org/iso13250/glossary/variant-name"
   PSI[:variant_name] = "http://psi.topicmaps.org/iso13250/glossary/variant-name"
 
+  PSI[:subject_representation] = "http://psi.topicmapslab.de/subject-representation"
+  PSI[:represented_subject] = "http://psi.topicmapslab.de/represented-subject"
+
+  # languages
+  # PSI[:] = "http://psi.oasis-open.org/iso/639/#"
+  PSI[:language] = "http://psi.oasis-open.org/iso/639/#language"
+  PSI[:language_group] = "http://psi.oasis-open.org/iso/639/#language-group"
+  PSI[:code_a2] = "http://psi.oasis-open.org/iso/639/#code-a2"
+  PSI[:code_a3b] = "http://psi.oasis-open.org/iso/639/#code-a3b"
+  PSI[:code_a3t] = "http://psi.oasis-open.org/iso/639/#code-a3t"
+  PSI[:multiple_languages] = "http://psi.oasis-open.org/iso/639/#mul"
+  #PSI[:czech] = "http://psi.oasis-open.org/iso/639/#ces"
+  #PSI[:dutch] = "http://psi.oasis-open.org/iso/639/#nld"
+  #PSI[:english] = "http://psi.oasis-open.org/iso/639/#eng"
+  #PSI[:french] = "http://psi.oasis-open.org/iso/639/#fra"
+  #PSI[:german] = "http://psi.oasis-open.org/iso/639/#deu"
+  #PSI[:italien] = "http://psi.oasis-open.org/iso/639/#ita"
+  #PSI[:japanese] = "http://psi.oasis-open.org/iso/639/#jpn"
+
+
   PSI1 = {}
   PSI1[:XTM] = "http://www.topicmaps.org/xtm/1.0/core.xtm"
   PSI1[:topic] = "http://www.topicmaps.org/xtm/1.0/core.xtm#topic"
@@ -67,7 +103,8 @@ module RTM
   PREFIX[:tm] = "http://psi.topicmaps.org/iso13250/model/" # This is the namespace for the concepts defined by TMDM.
   PREFIX[:glossary] = "http://psi.topicmaps.org/iso13250/glossary/"
   PREFIX[:xsd] = "http://www.w3.org/2001/XMLSchema#" # This is the namespace for the XML Schema Datatypes.
-  PREFIX[:tmql] = "http://psi.topicmaps.org/tmql/1.0/" # Under this prefix the concepts of TMQL itself are located.
-  PREFIX[:fn] = "http://psi.topicmaps.org/tmql/1.0/functions"  # Under this prefix user-callable functions of the predefined TMQL environment are located.
+  PREFIX[:tmql] = "http://psi.topicmaps.org/tmql/1.0/" # Under this prefix the concepts of Axes itself are located.
+  PREFIX[:fn] = "http://psi.topicmaps.org/tmql/1.0/functions"  # Under this prefix user-callable functions of the predefined Axes environment are located.
   PREFIX[:xtm1] = "http://www.topicmaps.org/xtm/1.0/core.xtm#"
+  PREFIX[:language] = "http://psi.oasis-open.org/iso/639/#" # This is the namespace for the languae PSIs
 end

data/lib/rtm/sugar.rb

@@ -0,0 +1,47 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::Sugar;end
+
+require 'rtm/sugar/topic/topic_ref'
+require 'rtm/sugar/topic/hash_access'
+require 'rtm/sugar/topic/characteristics'
+require 'rtm/sugar/topic/counterparts'
+require 'rtm/sugar/topic/scoped'
+require 'rtm/sugar/topic/typed'
+require 'rtm/sugar/topic/best_name'
+RTM::Topic.register_extension(RTM::Sugar::Topic::TopicRef)
+RTM::Topic.register_extension(RTM::Sugar::Topic::HashAccess)
+RTM::Topic.register_extension(RTM::Sugar::Topic::Characteristics)
+RTM::Topic.register_extension(RTM::Sugar::Topic::Counterparts)
+RTM::Topic.register_extension(RTM::Sugar::Topic::Scoped)
+RTM::Topic.register_extension(RTM::Sugar::Topic::Typed)
+RTM::Topic.register_extension(RTM::Sugar::Topic::BestName)
+
+require "rtm/sugar/association/hash_access"
+RTM::Association.register_extension(RTM::Sugar::Association::HashAccess)
+
+require "rtm/sugar/role/counterparts"
+RTM::Role.register_extension(RTM::Sugar::Role::Counterparts)
+
+require "time"
+require "rtm/sugar/occurrence/dynamic_value"
+require "rtm/sugar/occurrence/external"
+RTM::Occurrence.register_extension(RTM::Sugar::Occurrence::DynamicValue)
+RTM::Occurrence.register_extension(RTM::Sugar::Occurrence::External)
+
+require "rtm/sugar/typed/types"
+RTM::Typed.register_extension(RTM::Sugar::Typed::Types)
+
+require 'rtm/sugar/reifiable/reifier'
+RTM::Reifiable.register_extension(RTM::Sugar::Reifiable::CreateReifier)
+
+require 'rtm/sugar/topic_map/query_cache'
+require 'rtm/sugar/topic_map/themes'
+module RTM::TopicMap
+  include RTM::Reifiable
+  @query_cache = nil #disables query caching
+end
+RTM::TopicMap.register_extension(RTM::Sugar::TopicMap::QueryCache)
+RTM::TopicMap.register_extension(RTM::Sugar::TopicMap::Themes)
+

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

@@ -0,0 +1,46 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::Sugar
+  module Association
+    # This module implements methods for Hash-like access in Associations.
+    module HashAccess
+
+      # Returns all Roles of this Association. 
+      #
+      # If type is given, returns the Roles of this Association
+      # whose Role type match type.
+      # Type may be a topic reference.
+      #
+      # The result may be empty.
+      #
+      # :call-seq:
+      #   [] -> Array of Roles
+      #   [type] -> Array of Roles
+      #
+      def [](type=:any)
+        return getRoles.to_a if type == :any
+        return getRoles.to_a unless type
+        type = topic_map.get(type)
+        if type
+          return getRoles(type).to_a
+        else
+          return []
+        end
+      end
+      
+      
+      # Creates a new Role in this Association where type specifies the
+      # Role type and player the associated Role player.
+      # Type and player may each be a topic reference.
+      # 
+      # :call-seq:
+      #   [type]= player
+      #
+      # TODO Issue #919
+      def []=(type,player)
+   		  create_role(type,player)
+      end
+    end
+  end
+end

data/lib/rtm/sugar/occurrence/dynamic_value.rb

@@ -0,0 +1,58 @@
+# Copyright: Copyright 2010 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::Sugar::Occurrence
+  module DynamicValue
+
+    # Given the occurrence's datatype this method returns the value of this
+    # occurrence cast as appropriate Ruby type.
+    #
+    # :call-seq:
+    #   dynamic_value -> Object
+    #
+    def dynamic_value
+      value = self.value # a String
+      case self.datatype.reference
+      when RTM::PSI[:IRI]
+        return topic_map.create_locator(value)
+      when RTM::PSI[:Decimal]
+        return value.to_f
+      when RTM::PSI[:Double]
+        return value.to_f
+      when RTM::PSI[:Int]
+        return value.to_i
+      when RTM::PSI[:Integer]
+        return value.to_i
+      when RTM::PSI[:Float]
+        return value.to_f
+      when RTM::PSI[:Long]
+        return value.to_i
+      when RTM::PSI[:Date]
+        return Date.parse(value)
+      when RTM::PSI[:DateTime]
+        return DateTime.parse(value)
+      when RTM::PSI[:Time]
+        return Time.parse(value)
+      else
+        return value
+      end
+    end
+
+  end
+end
+
+class Float
+  def to_xsd_double
+    s = self.to_s
+    
+    case s
+    when "Infinity"
+      "INF"
+    when "-Infinity"
+      "-INF"
+    else
+      s
+    end
+  end
+end
+

data/lib/rtm/sugar/occurrence/external.rb

@@ -0,0 +1,53 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::Sugar::Occurrence
+  module External
+    
+    # Creates an association out of this occurrence which represents the
+    # occurrence information in relation to the parent topic.
+    # 
+    # The association is of type "http://psi.topicmapslab.de/subject-representation".
+    # It includes two roles. The parent topic plays the role of type
+    # "http://psi.topicmapslab.de/represented-subject". The topic with the
+    # subject locator created from the occurrence value plays the role
+    # of a type the same as the occurrence type.
+    #
+    # The subject locator will be resolved using the get-method of RTM::TopicMap,
+    # that means if the occurrence value is stored as String and is not a valid uri
+    # the base_iri of the topic map is used to create one.
+    #
+    # The occurrence datatype may be xsd:anyURI as well as xsd:String.
+    # The occurrence value must be a valid URL.
+    #
+    # Example: Creates an association out of the occurrence with value
+    # "http://www.leipzig.de" and type "webpage" of the topic Leipzig:
+    # * association type: subject_representation
+    # * role 1: Leipzig plays the role "represented_subject"
+    # * role 2: topic with subject locator "http://www.leipzig.de" plays the role "webpage"
+    #
+    # :call-seq:
+    #   externalize -> Association
+    #
+    def externalize
+      topic_map.create_association(RTM::PSI[:subject_representation], RTM::PSI[:represented_subject] => parent, self.type => "=#{self.value}")
+    end
+
+    # Executes externalize and removes this occurrence from the topic map afterwards
+    #
+    # :call-seq:
+    #   externalize!
+    #
+    def externalize!(*args)
+      association = externalize(*args)
+      remove
+      return association
+    end
+
+    # Returns true, if the datatype of this occurrence equals xsd:anyURI.
+    def external?
+      return self.datatype.reference == RTM::PSI[:IRI] ? true : false
+    end
+
+  end
+end

data/lib/rtm/sugar/reifiable/reifier.rb

@@ -0,0 +1,21 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::Sugar::Reifiable
+  module CreateReifier
+
+    # Returns the reifier (a topic) of this Reifiable.
+    # If there is no current reifier, then a reifier will be generated.
+    # This reifier did not exist in the topic map before.
+    #
+    # :call-seq:
+    #   reifier! -> Topic
+    #
+    def reifier!
+      self.reifier ||= self.topic_map.create_topic
+    end
+    alias :create_reifier :reifier!
+    
+  end
+end
+ 

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

@@ -1,51 +1,144 @@
-module RTM::Sugar
-  module Role
-    module Counterparts
-      # This method fetches all roles from the parent association of this role, except itself (i.e. current role).
-      # A filter-hash may be used to filter for the type of the other role (:otype =>topic_reference).
-      # Examples:
-      # this_role.counterparts # returns all
-      # this_role.counterparts(:otype => some_topic) # returns only other roles which have type some_topic
-      # this_role.counterparts(:otype => "some_reference") # as above, looking up the reference first
-      def counterparts(filter={})
-        self.parent.roles.reject{|r| r.id==self.id}.
-                    select{|r| filter[:otype] ? r.type == self.topic_map.get(filter[:otype]) : true}
-      end
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
 
-      # This methods fetches all players of the parent association of this role, except the player of itself.
-      # It accepts a filter-hash like the counterparts-method.
-      def counterplayers(*args)
-        self.counterparts(*args).map{|r| r.player}
-      end
+module RTM::Sugar::Role
+	module Counterparts
+    
+    # Returns all roles from the parent association of this role,
+    # except itself.
+    #
+    # A filter-hash may be used to filter for the type of the other roles
+    # (:otype) or the player of the other roles (:oplayer).
+    #
+    #  The identfiers may be topic references.
+    #
+    # :call-seq:
+    #   counterparts -> Array of Roles
+    #   counterparts({:otype => identifier}) -> Array of Roles
+    #
+    def counterparts(filter={})
+      _roles = parent.roles.reject{|r| r.id==self.id}
+      otype = filter[:otype]
+      _roles = _roles.select{|r| r.type == topic_map.get(otype)} if otype && otype != :any
+      oplayer = filter[:oplayer]
+      _roles = _roles.select{|r| r.player == topic_map.get(oplayer)} if oplayer && oplayer != :any
+      return _roles
+    end
+
+    # Returns the other role, if the parent association is binary.
+    #
+    # :call-seq:
+    #   counterpart -> Role
+    #
+    def counterpart
+      n = 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
+      counterparts.first
+    end
+
+    # Returns all players of the parent Association of this Role,
+    # except the player of itself.
+    #
+    # A filter-hash may be used to filter for the type of the other Roles
+    # (:otype). The identifier may be a topic reference.
+    #
+    # :call-seq:
+    #   counterplayers -> Array of Topics
+    #   counterplayers({:otype => identifier}) -> Array of Topics
+    #
+    def counterplayers(filter={})
+      counterparts(filter).map{|r| r.player}
+    end
+   
+    # Returns the player of the other role, if the parent association is binary.
+    #
+    # :call-seq:
+    #   counterplayer -> Topic
+    #
+    def counterplayer
+      n = parent.roles.size
+      raise "Association must be unary or binary to use counterplayer method. Please use counterplayers for n-ary associations (n>2)." if n > 2
+      return nil if n == 1
+      counterparts.first.player
+    end
+    
+    # Returns the Roles of other binary Associations for which the following
+    # applies:
+    #
+    # - this Role and all returned Roles must share a counterplayer.
+    #
+    # - if :rtype is set to :strict, the type of the returned Roles must equal
+    # the type of this Role
+    #
+    # - if :atype is set to :strict, the type of the parent Associaton of this Role must be equal
+    # to the type of the parent Associations of the other Roles
+    #
+    # - if :otype is set to :strict, the type of the Roles the shared counterplayers play (counterparts)
+    # must equal
+    #
+    # - if :arity is set to :strict, the size of the parent Associations must
+    # equal the size of the other associations involved
+    #
+    # Example: Returns all employee-roles of a company, if self is a Role an employee plays in an
+    # "firm-employee"-Association.
+    # 
+    # Default: peers(:arity => :strict, :atype => :strict, :otype => :strict, :rtype => :strict)
+    #
+    # The result may be empty. Esp. if the parent Association includes only this Role, an empty Array is returned.
+    #
+    # :call-seq:
+    #   peers -> Array of Roles
+    #   peers(:arity => :strict) -> Array of Roles
+    #   peers(:rtype => :strict, :atype => strict, :otype => :loose) -> Array of Roles
+    #   etc.
+    #
+    def peers(params = {})
+      default_hash = {:arity => :strict, :atype => :strict, :otype => :strict, :rtype => :strict}
+      raise("peers: argument has to be a Hash") unless params.is_a? Hash
+      params.reject!{|k,v| ![:strict,:loose].include?(v)}
+      params = default_hash.merge(params)
+#      puts "\narity = " + (params[:arity] == :strict ? "strict" : "loose")
+#      puts "atype = " + (params[:atype] == :strict ? "strict" : "loose")
+#      puts "otype = " + (params[:otype] == :strict ? "strict" : "loose")
+#      puts "rtype = " + (params[:rtype] == :strict ? "strict" : "loose")
+      n = self.parent.roles.size
+      return [] if n == 1
+      atype = self.parent.type # association type
+      rtype = self.type #role type
+      c_parts = self.counterparts # other roles in the association of this player
+      _roles = []
+      c_parts.each do |c_part|
+        otype = c_part.type # type of the other role in the association
+        c_player = c_part.player
+        if params[:otype] == :loose
+          other_roles = c_player.roles.to_a
+        else
+          if params[:atype] == :strict
+            other_roles = c_player.roles(otype,atype).to_a
+          else 
+            other_roles = c_player.roles(otype).to_a
+          end
+        end
+        other_roles = other_roles.select{|r| r.parent.roles.size == n} if params[:arity] == :strict #same n-ary
+        other_roles = other_roles.map{|r| r.counterparts}.flatten # other roles in these associations
+        other_roles = other_roles.select{|r| r.type == rtype} if params[:rtype] == :strict
+        other_roles = other_roles.reject{|r| r == self} # reject self
+        _roles = _roles + other_roles
+      end 
+      return _roles
+    end
 
-      # Fetches the other role, if the parent association is binary.
-      def counterpart
-        n = self.parent.roles.size
-        raise "Association must be unary or binary to use counterpart method. Please use counterparts for n-ary associations." if n > 2
-        return nil if n == 1
-        self.counterparts.first
-      end
-      
-      # Fetches the player of the other role, if the parent association is binary.
-      def counterplayer
-        n = self.parent.roles.size
-        raise "Association must be unary or binary to use counterplayer method. Please use counterplayers for n-ary associations." if n > 2
-        return nil if n == 1
-        self.counterparts.first.player
-      end
-      
-      # Fetches all roles of the (binary) parent associations which play the same role in the same with the counterplayer
-      # TODO: filter not only otype but also atype and rtype.
-      def peers
-        cp = self.counterpart
-        cp.player.roles.select{|r| r.type == cp.type}.map{|r| r.counterpart}
-      end
-      # Fetches all players of roles being in the same association with another topic as self
-      # Example: current_role is a role of player "me" and type "employee"
-      # current_role.peerplayers # returns all employees of my company (including me)
-      def peerplayers
-        self.peers.map{|r| r.player}
-      end
+    # Returns all players of the peers of this Role.
+    #
+    # Example: Returns all employees of a company except the
+    # player of itself.
+    #
+    # :call-seq:
+    #   peerplayers -> Array of Topics
+    #
+    def peerplayers
+      peers.map{|r| r.player}
     end
   end
 end