rtm 0.1.1 → 0.1.3

data/lib/activetopicmaps.rb

@@ -75,17 +75,30 @@ module ActiveTopicMaps
 #          EOS
 #      end
 
-      def name(name, type="")
+      def name(name, type=nil)
+        type ||= name
         prop_getter(name, type, "-")
         prop_setter(name, type, "-")
       end
-
+      
+      def names(name, type=nil)
+        type ||= name.singularize
+        prop_getters(name, type, "-")
+        prop_adderremover(name, type, "-")
+      end
+      
       def occurrence(name, type=nil)
         type ||= name
         prop_getter(name, type)
         prop_setter(name, type)
       end
-
+      
+      def occurrences(name, type=nil)
+        type ||= name.singularize
+        prop_getters(name, type)
+        prop_adderremover(name, type)
+      end
+      
       def prop_getter(name, type, prefix="")
         self.class_eval <<-EOS
         def #{name}
@@ -94,6 +107,14 @@ module ActiveTopicMaps
         EOS
       end
 
+      def prop_getters(name, type, prefix="")
+        self.class_eval <<-EOS
+        def #{name}
+          @#{name} ||= @topic["#{prefix}#{type}"].map{|n| n.value}
+        end
+        EOS
+      end
+      
       def prop_setter(name, type, prefix="")
         self.class_eval <<-EOS
         def #{name}=(name)
@@ -107,7 +128,18 @@ module ActiveTopicMaps
         EOS
       end
       
-      def binassoc(name, rt1, at, rt2, klass)
+      def prop_adderremover(name, type, prefix="")
+        self.class_eval <<-EOS
+        def add_#{name.singularize}(name)
+          @topic["#{prefix}#{type}"] = name
+        end
+        def remove_#{name.singularize}(name)
+          @topic["#{prefix}#{type}"].each {|item| item.remove if item.value == name}
+        end
+        EOS
+      end
+            
+      def has_many(name, rt1, at, rt2, klass)
           eval(<<-EOS)
           class RTM::AR::Topic
           index_property_set :#{name}, :type => :Topic, :rule => {
@@ -138,7 +170,12 @@ module ActiveTopicMaps
       end
       
       def create(ref)
-        self.new(@tm.get!(ref))
+        t = @tm.get!(ref)
+        if @psi
+          @ty ||= @tm.get!(@psi)
+          t.add_type @ty unless t.types.include? @ty
+        end
+        self.new(t)
       end
       alias get! create
       
@@ -147,6 +184,16 @@ module ActiveTopicMaps
         self.new(t) if t
       end
       alias get find
+      
+      def find_by_type(ref=nil)
+        ref ||= @psi
+        ty = @tm.get(ref)
+        ty.instances.map {|t| self.new(t)}
+      end
+      
+      def psi(ref)
+        @psi = ref
+      end
     end
   end
 end
@@ -157,6 +204,7 @@ end
 #
 #class Person < ActiveTopicMaps::Base
 #  topic_map "urn:/base"
+#  psi "person"
 #
 #  name :name
 #  occurrence :age
@@ -172,6 +220,7 @@ end
 #  include ActiveTopicMaps::Topic
 #
 #  topic_map "urn:/base"
+#  psi "country"
 #
 #  acts_as_topic
 #
@@ -179,7 +228,7 @@ end
 #  occurrence :population
 #  occurrence :size
 #
-#  binassoc :inhabitants, "country", "country-inhabitant", "inhabitant", :Person
+#  has_many :inhabitants, "country", "country-inhabitant", "inhabitant", :Person
 #
 #  def to_s
 #    "There is a country called #{name} with #{population} inhabitants and a size of #{size} km^2.\n" +

data/lib/rtm.rb

@@ -1,5 +1,5 @@
 # RTM: Ruby Topic Maps.
-# Copyright (c) 2007 Benjamin Bock.
+# Copyright (c) 2007-2008 Benjamin Bock.
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -35,12 +35,27 @@
 module RTM
 
 end
-require 'rubygems'
-gem 'activerecord'
-old_verbose=$VERBOSE
-$VERBOSE=false
-require 'active_record'
-$VERBOSE=old_verbose
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__))) 
+
+unless defined? ActiveRecord
+  active_record_path = File.dirname(__FILE__) + "/../../activerecord/lib"
+  if File.exist?(active_record_path)
+    $:.unshift active_record_path
+    old_verbose=$VERBOSE
+    $VERBOSE=false
+    require 'active_record'
+    $VERBOSE=old_verbose
+  else
+    require 'rubygems'
+    gem 'activerecord'
+    old_verbose=$VERBOSE
+    $VERBOSE=false
+    require 'active_record'
+    $VERBOSE=old_verbose
+  end
+end
 
 require 'rtm/core_ext'
 require 'rtm/helpers'
@@ -54,7 +69,11 @@ require 'rtm/io/to_string'
 require 'rtm/io/to_xtm2'
 require 'rtm/io/to_yaml'
 require 'rtm/io/from_xtm2'
-require 'rtm/io/from_xtm2_libxml.rb'
+begin
+  require 'rtm/io/from_xtm2_libxml.rb'
+rescue Exception
+  warn("LibXML could not be loaded, only (slow) REXML import available")
+end
 #require 'rtm/io/from_xtm2_hpricot'
 require 'rtm/merging/merging'
 require 'rtm/pimp_my_api'

data/lib/rtm/backend/active_record.rb

@@ -5,30 +5,34 @@ class Class
     rtm_old_const_missing(const_name)
   end
 end
-class Array
-    alias :rtm_old_method_missing :method_missing
-    def method_missing(method_name, *args)
-      if size > 0 && first.respond_to?(method_name) && (![:__getobj__, :__setobj__].include?(method_name))
-        inject([]) {|all,single| all << single.send(method_name, *args)}
-      else
-        rtm_old_method_missing(method_name, *args)
-      end
-    end
-    
-    alias :rtm_old_respond_to? :respond_to?
-    def respond_to?(method_name, *args)
-      resp = rtm_old_respond_to?(method_name, *args)
-      return resp if resp # i.e. if true
-      # check for special calls we don't want to pass
-      return false if [:__getobj__, :__setobj__].include?(method_name)
-      # ... and ask first child otherwise
-      @obj && @obj.size > 0 && first.respond_to?(method_name, *args)
-    end
-    
-    def compact_empty
-      compact.reject{|e| e.empty?}
-    end
-end
+# The following methods allow automatic +map+ping on arrays to their containees properties.
+# However this is a dirt hack and did no longer work in ActiveRecord 2.1.0.
+# This should be fixed some time later.
+# 
+#class Array
+#    alias :rtm_old_method_missing :method_missing
+#    def method_missing(method_name, *args)
+#      if size > 0 && first.respond_to?(method_name) && (![:__getobj__, :__setobj__].include?(method_name))
+#        inject([]) {|all,single| all << single.send(method_name, *args)}
+#      else
+#        rtm_old_method_missing(method_name, *args)
+#      end
+#    end
+#    
+#    alias :rtm_old_respond_to? :respond_to?
+#    def respond_to?(method_name, *args)
+#      resp = rtm_old_respond_to?(method_name, *args)
+#      return resp if resp # i.e. if true
+#      # check for special calls we don't want to pass
+#      return false if [:__getobj__, :__setobj__].include?(method_name)
+#      # ... and ask first child otherwise
+#      @obj && @obj.size > 0 && first.respond_to?(method_name, *args)
+#    end
+#    
+#    def compact_empty
+#      compact.reject{|e| e.empty?}
+#    end
+#end
 class ActiveRecord::Associations::AssociationProxy
   # this is needed to prevent the associations from being instantly loaded
   alias :rtm_old_respond_to? :respond_to?
@@ -45,6 +49,7 @@ module RTM::AR
   require 'rtm/backend/active_record/tm_set_delegator'
   require 'rtm/backend/active_record/tm_construct'
   require 'rtm/backend/active_record/topic_map'
+  require 'rtm/backend/active_record/traverse_associations'
   require 'rtm/backend/active_record/topic'
   require 'rtm/backend/active_record/association_and_role'
   require 'rtm/backend/active_record/name_variant_occurrence'

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

@@ -24,31 +24,10 @@ module RTM::AR
     property :player, :aka => [:pl,:topic], :rw => true, :type => :Topic, :wrap => true
     property :type, :aka => [:ty,:t], :rw => true, :type => :Topic, :wrap => true
 
-    def counterparts
-      self.parent.roles.reject{|r| r.id==self.id}
-    end
-    def counterplayers
-      self.counterparts.map{|r| r.player}
-    end
-    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.parent.roles.reject{|r| r.id==self.id}.first
-    end
-    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.parent.roles.reject{|r| r.id==self.id}.first.player
-    end
-    def peers
-      self.counterpart.player.roles.select{|r| r.type == cp.type}.counterpart
-    end
-    def peerplayers
-      self.peers.map{|r| r.player}
-    end
+    require 'rtm/sugar/role/counterparts'
+    include RTM::Sugar::Role::Counterparts
     
     equality [:type, :player, :parent]
   end
+  Role = AssociationRole
 end

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

@@ -16,6 +16,8 @@ module RTM::AR
     delegate :reference, :rw => true, :save => true
     alias :value :reference
     alias :value= :reference=
+    alias :v :reference
+    alias :v= :reference=
 
     equality [:reference]
 

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

@@ -7,21 +7,22 @@ module RTM::AR
     property :type, :aka => [:ty,:t], :rw => true, :type => :Topic, :wrap => true
     property_set :scope, :type => :Topic, :wrap => true
 
-    property_set :variants, :aka => :v, :type => :Variant, :wrap => true,
+    property_set :variants, :aka => :vs, :type => :Variant, :wrap => true,
       :create => :variant, :create_aka => :cv,
       :create_args => [ {:name => :value, :type => [:String, :Locator]}, {:name => :scope, :type => :Collection}]
 
-    property :value, :rw => true, :type => :String
+    property :value, :rw => true, :type => :String, :aka => :v
 
     equality [:value, :type, :scope, :parent]
   end
+  Name = TopicName
 
   class Variant < Reifiable
     include RTM::Variant
     wrapper_cache
 
     parent :topic_name, :aka => :name
-    property :value, :rw => true, :type => :String
+    property :value, :rw => true, :type => :String, :aka => :v
     property :datatype, :rw => true, :type => :Locator #, :wrap => true
     property_set :scope, :type => :Topic, :wrap => true
 
@@ -33,7 +34,7 @@ module RTM::AR
     wrapper_cache
 
     parent :topic
-    property :value, :rw => true, :type => :String
+    property :value, :rw => true, :type => :String, :aka => :v
     property :datatype, :rw => true, :type => :String
 
     property_set :scope, :type => :Topic, :wrap => true

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

@@ -291,81 +291,6 @@ RUBY
       end
     end
 
-    def self.index_property_set(prop, options={})
-      r = options[:rule]
-      module_eval(<<-EOS, "(__AR_DELEGATOR_INDEX_PROPERTY_SET__)", 1)
-        def direct_#{prop}_roles
-          # prefetch typing topics
-          rtype = @ips_#{prop}_rtype ||= self.topic_map.get("#{r[:role_type]}")
-          atype = @ips_#{prop}_atype ||= self.topic_map.get("#{r[:association_type]}")
-          otype = @ips_#{prop}_otype ||= self.topic_map.get("#{r[:other_role_type]}")
-          # return nothing if any of the typing topics does not exist
-          return [] unless rtype && atype && otype
-          # we do that only here and not earlier because some might me nil
-          rtype = rtype.id
-          atype = atype.id
-          otype = otype.id
-          self.__getobj__.roles.map{|r|
-            r.ttype_id != nil &&
-              r.ttype_id == rtype &&
-              r.parent.roles.size == #{r[:association_arity]} &&
-              r.parent != nil &&
-              r.parent.ttype_id == atype &&
-              (r2 = r.parent.roles.select{|r2| r2.ttype_id != nil &&
-                r2.ttype_id == otype}.first) &&
-              r2}.select{|r2| r2}.map{|r2| AssociationRole.wrap(r2)}
-        end
-        def direct_#{prop}
-          direct_#{prop}_roles.map{|r2| r2.player}.uniq
-        end
-      EOS
-      
-      if r[:transitive]
-        module_eval(<<-EOS, "(__AR_DELEGATOR_INDEX_PROPERTY_SET2__)", 1)
-          def #{prop}
-            d = todo = self.direct_#{prop}
-            while todo.size > 0
-              todo = todo.map{|dt| dt.direct_#{prop}}.flatten.uniq - d
-              d += todo
-            end
-            d
-            #d2 = self.direct_#{prop}.map {|dt| dt.#{prop}}.flatten
-            #(d+d2).uniq
-          end
-        EOS
-      else
-        if r[:infer]
-          module_eval(<<-EOS, "(__AR_DELEGATOR_INDEX_PROPERTY_SET3__)", 1)
-            def #{prop}
-              (self.direct_#{prop} + self.#{r[:infer]}.map{|d2| d2.direct_#{prop}}).flatten.uniq
-            end
-          EOS
-        elsif r[:infer_other]
-          module_eval(<<-EOS, "(__AR_DELEGATOR_INDEX_PROPERTY_SET4__)", 1)
-            def #{prop}
-              d = self.direct_#{prop}
-              (d + d.map{|d2| d2.#{r[:infer_other]}}).flatten.uniq
-            end
-          EOS
-        end
-      end
-      if r[:add]
-        module_eval(<<-EOS, "(__AR_DELEGATOR_INDEX_PROPERTY_SET5__)", 1)
-          def add_#{r[:add]}(t)
-            a = self.topic_map.create_association("#{r[:association_type]}")
-            a.create_role self, "#{r[:role_type]}"
-            a.create_role t, "#{r[:other_role_type]}"
-            a
-            # TODO add_x in index_property_set needs to trigger reload of the topics somewhere
-          end
-          def remove_#{r[:add]}(t)
-            direct_#{prop}_roles.select{|r| r.player == t}.each{|r| r.parent.remove}
-            # TODO remove_x in index_property_set needs to trigger reload of the topics somewhere
-          end
-        EOS
-      end
-    end
-
     def self.equality(eqfields, options={})
       field_condition = eqfields.map {|f| "self.#{f} == o.#{f}" }.join(" && ")
       module_eval(<<-EOS, "(__AR_EQUALITY__)", 1)

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

@@ -36,6 +36,7 @@ module RTM::AR
     end
 
     class TopicMapConstruct < ActiveRecord::Base
+      self.store_full_sti_class = false 
       extend Movable
       class << self
         def abstract_class?
@@ -108,6 +109,7 @@ module RTM::AR
 #      end
     end
     class ScopedObjectsTopic < ActiveRecord::Base
+      self.store_full_sti_class = false 
       extend Movable
       belongs_to :topic
       belongs_to :scoped_object, :polymorphic => true
@@ -118,6 +120,7 @@ module RTM::AR
     end
   
     class Locator < ActiveRecord::Base
+      self.store_full_sti_class = false 
       extend Movable
       class << self
         def abstract_class?
@@ -253,8 +256,10 @@ module RTM::AR
       has_many :subject_identifiers, :dependent => :destroy
 
       has_many :topic_names, :through => :topics
+      alias :names :topic_names
       has_many :occurrences, :through => :topics
       has_many :association_roles, :through => :associations
+      alias :roles :association_roles
       
       %w[association association_role topic_name occurrence].each do |m|
         module_eval(<<-EOS, "(__AR_DELEGATOR_INDEX_PROPERTY_SET__)", 1)

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

@@ -23,16 +23,6 @@ module RTM::AR
       :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
@@ -48,72 +38,16 @@ module RTM::AR
     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
+    require 'rtm/sugar/topic/characteristics'
+    include RTM::Sugar::Topic::Characteristics
+    require 'rtm/sugar/topic/counterparts'
+    include RTM::Sugar::Topic::Counterparts
+    require 'rtm/sugar/topic/identifier_direct'
+    include RTM::Sugar::Topic::IdentifierDirect
+    require 'rtm/sugar/topic/hash_access'
+    include RTM::Sugar::Topic::HashAccess
+    require 'rtm/sugar/topic/predefined_associations'
+    include RTM::Sugar::Topic::PredefinedAssociations
 
     # class:Topic equality, http://www.isotopicmaps.org/sam/sam-model/#d0e1029
     #