rtm 0.1.6 → 0.2.0

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,18 @@ 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[: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 +52,33 @@ 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"
 
+  # 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 +97,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,34 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::Topic
+  require 'rtm/sugar/topic/topic_ref'
+  include Sugar::Topic::TopicRef
+  require 'rtm/sugar/topic/hash_access'
+  include RTM::Sugar::Topic::HashAccess
+  require 'rtm/sugar/topic/characteristics'
+  include Sugar::Topic::Characteristics
+  require 'rtm/sugar/topic/counterparts'
+  include Sugar::Topic::Counterparts
+  require 'rtm/sugar/topic/scoped'
+  include Sugar::Topic::Scoped
+  require 'rtm/sugar/topic/typed'
+  include Sugar::Topic::Typed
+end
+module RTM::Association
+  require "rtm/sugar/association/hash_access"
+  include Sugar::Association::HashAccess
+end
+module RTM::Role
+  require "rtm/sugar/role/counterparts"
+  include Sugar::Role::Counterparts
+end
+module RTM::Occurrence
+  require "rtm/sugar/occurrence/dynamic_value"
+  include Sugar::Occurrence::DynamicValue
+end
+module RTM::Typed
+  require "rtm/sugar/typed/types"
+  include Sugar::Typed::Types
+end
+

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 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 or 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, String-Reference or Locator.
+      # 
+      # :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,75 @@
+# Copyright: Copyright 2010 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module Sugar::Occurrence
+  module DynamicValue
+    # Returns the value of this occurrence cast as appropriate Ruby type.
+    def dynamic_value
+      case self.datatype.to_external_form # first_oc.datatype is actually of type Locator
+        when RTM::PSI[:Decimal]
+          self.value.to_f
+        when RTM::PSI[:Double]
+          self.value.to_f
+        when RTM::PSI[:Int]
+          self.value.to_i
+        when RTM::PSI[:Integer]
+          self.value.to_i
+        when RTM::PSI[:Float]
+          self.value.to_f
+        when RTM::PSI[:Long]
+          self.value.to_i
+        # Date, ... missing
+        else
+          self.value
+      end
+    end
+    
+    class NoDatatypeHandlerAvailableException < Exception
+      def initialize(value)
+        super "Cannot map #{value} to an occurrence value+datatype. Maybe you need to add a handler for your Ruby object type."
+      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
+
+module Sugar::Topic::Characteristics
+  #
+  # Weird. create_occurrence has an options hash, and we don't have one. We should unify the syntax. What is the right thing to do?
+  #
+  def dynamic_create_occurrence(type,value,datatype,scope = nil)
+    if !datatype # well, let's choose one
+      case value
+        when Integer
+          datatype = RTM::PSI[:Integer]
+          use_value = value.to_s
+        when Float
+          datatype = RTM::PSI[:Double]
+          use_value = value.to_xsd_double
+        when String
+          datatype = RTM::PSI[:String]
+          use_value = value
+        else
+          raise Sugar::Occurrence::DynamicValue::NoDatatypeHandlerAvailableException.new(value)
+      end
+    else
+      use_value = value
+    end
+    
+    create_occurrence(type,use_value,:datatype => datatype, :scope => scope)
+  end
+end

data/lib/rtm/{pimp_my_api.rb → sugar/occurrence/externalize.rb}

@@ -1,3 +1,6 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
 module RTM
   # Some useful or maybe not so useful stuff which I don't know how to put else.
   module PimpMyApi

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

@@ -1,51 +1,138 @@
-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 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). The identfier may be a Topic or Topic-Reference.
+    #
+    # :call-seq:
+    #   counterparts -> Array of Roles
+    #   counterparts({:otype => identifier}) -> Array of Roles
+    #
+    def counterparts(filter={})
+      _roles = parent.roles.reject{|r| r.id==self.id}
+      return filter[:otype] ? _roles.select{|r| r.type == topic_map.get(filter[:otype]) } : _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 or 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

data/lib/rtm/sugar/topic/characteristics.rb

@@ -1,15 +1,129 @@
-module RTM::Sugar
-  module Topic
-    module Characteristics
-      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      
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module Sugar::Topic::Characteristics
+  
+  # Returns all Occurrences of this Topic whose Datatype is not IRI
+  #
+  # :call-seq:
+  #   internal_occurrences -> Set of Occurrences
+  #
+  def internal_occurrences
+    occurrences.select{|x| x.getDatatype.toExternalForm != RTM::PSI[:IRI]}
+  end
+  
+  # Returns all Occurrences of this Topic whose Datatype is IRI
+  #
+  # :call-seq:
+  #   external_occurrences -> Set of Occurrences
+  #
+  def external_occurrences
+    occurrences.select{|y| y.getDatatype.toExternalForm == RTM::PSI[:IRI]}
+  end
+  
+  # Returns the Names of this Topic which may be filtered for their type,
+  # value and/or scope.
+  #
+  # If scope is set to :ucs, Names which exist in the unconstrained scope
+  # are selected. If scope is set to :any (default), scope does not constrain
+  # the Names-Array. Else, only the Names which exist in the given scope
+  # are selected.
+  #
+  # Returns an empty Array if no Names match or if the Name type
+  # or scope does not exist.
+  #
+  # :call-seq:
+  #   names_by -> Array of Names
+  #   names_by(:type => identifier) -> Array of Names
+  #   names_by(:value => string) -> Array of Names
+  #   names_by(:scope => identifier) -> Array of Names
+  #   names_by(:type => identifier, :value => string) -> Array of Names
+  #   names_by(:type => identifier, :value => string, :scope => identifier) -> Array of Names
+  #   and so on
+  #
+  def names_by(args = {})
+    raise("names_by: arguments must be a Hash") unless args.is_a?(Hash)
+    default_hash = {:type => :any, :value => :any, :scope => :any}   
+    args = default_hash.merge(args)
+    #filter for type
+    _names = args[:type] == :any ? names : names(args[:type])
+    _names = self.filter_by(_names,args)
+    # return Array
+    return _names.to_a
+  end
+  
+  # Returns Occurrences of this Topic which may be filtered for their type,
+  # value, datatype and/or scope.
+  #
+  # If scope is set to :ucs, Occurrences which exist in the unconstrained scope
+  # are selected. If scope is set to :any (default), scope does not constrain
+  # the Occurrence-Array. Else, only the Occurrences which exist in the given scope
+  # are selected.
+  #
+  # Returns an empty Array if no Occurrences match or if the Occurrence type or
+  # scope does not exist.
+  #
+  # :call-seq:
+  #   occurrence_by -> Array of Occurrences
+  #   occurrences_by(:type => argument) -> Array of Occurrences
+  #   occurrences_by(:value => argument) -> Array of Occurrences
+  #   occurrences_by(:scope => argument) -> Array of Occurrences
+  #   occurrences_by(:datatype => argument) -> Array of Occurrences
+  #   occurrences_by(:type => argument1, :value => argument2) -> Array of Occurrences
+  #   occurrences_by(:type => argument1, :value => argument2, :scope => argument3, :datatype => argument4) -> Array of Occurrences
+  #   and so on
+  #
+  def occurrences_by(args = {})
+    raise("occurrences_by: arguments must be a Hash") unless args.is_a?(Hash)
+    default_hash = {:type => :any, :value => :any, :scope => :any, :datatype => :any}
+    args = default_hash.merge(args)
+    #filter for type
+    _occurrences = args[:type] == :any ? occurrences : occurrences(args[:type])
+    _occurrences = self.filter_by(_occurrences,args)
+    #filter for datatype
+    _occurrences = _occurrences.select{|o| o.datatype == args[:datatype]} unless args[:datatype] == :any
+    return _occurrences.to_a
+  end
+  
+ protected
+  def filter_by(_characteristics,args)
+    #filter for value
+    unless args[:value] == :any
+      _characteristics = args[:value].is_a?(Array) ? _characteristics.select{|o| args[:value].any?{|v| o.value == v}} : _characteristics.select{|o| o.value == args[:value]}
+    end
+    #filter for scope
+    case args[:scope]
+      when :any
+      when :ucs, []
+        _characteristics = _characteristics.select{|o| o.scope.empty?}
+      else
+        _scope = topic_map.get(args[:scope])
+        _characteristics = _scope.is_a?(Array) ? _characteristics.select{|o| _scope.any?{|theme| o.scope.include?(theme)}} : _characteristics.select{|o| o.scope.include?(_scope)}
     end
+    _characteristics
   end
+  
+  # Returns the Occurrences and Names of this Topic which have the specified type as
+  # Occurrence/Name type. Additionally, scope may constrain the the selection.
+  #
+  # If scope is set to :ucs, Occurrences/Names which exist in the unconstrained scope
+  # are selected. If scope is set to :any (default), scope does not constrain
+  # the Occurrence/Names-Array. Else, only the Occurrences/Names which exist in the given scope
+  # are selected.
+  #
+  # Returns an empty Array if no Occurrences or Names match or if the Occurrence/Name type or
+  # scope does not exist.
+  #
+  # :call-seq:
+  #    characteristics_by -> Array of Occurrences and Names
+  #
+#  def characteristics_by(args = {})
+#    raise("characteristics_by: arguments must be a Hash") unless args.is_a?(Hash)
+#    default_hash = {:type => :any, :value => :any, :scope => :any, :datatype => :any}
+#    args = default_hash.merge(args)
+#    _names = names_by(args) if args[:datatype].include(:any) || args[:datatype] == RTM::PSI[:String] || args[:datatype] == topic_map.create_locator(RTM::PSI[:String])
+#    _occurrences = occurrences_by(args)
+#    
+#  end
+  
 end