rtm 0.1.6 → 0.2

data/lib/rtm/axes/topics.rb

@@ -0,0 +1,280 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module RTM::Axes
+  module Topics
+
+    def self.extended(k)
+      k.extend ArrayProxy
+    end
+
+    def result
+      self.map{|i| i.construct}
+    end
+    alias :tmapi :result
+
+    # ---- characteristics-axis ----------------------------------------------#
+    
+    # Returns all Names and Occurrences of these Topics.
+    # If an identifier is given, only those Names and Occurrences are returned,
+    # whose type or supertypes include the identifier.
+    #
+    # Identifier may be a topic reference.
+    #
+    # The result may be empty.
+    #
+    # :call-seq:
+    #   characteristics -> Array of Names and Occurrences
+    #   characteristics(identifier) -> Array of Names and Occurrences
+    #
+    def characteristics(type=:any)
+      _res = self.inject([]){|all,containee| all << containee.send(:characteristics,type)}.flatten
+      ### NO UNIQUE NEEDED
+      _res = _res.extend(Characteristics)
+      _res
+    end
+
+    # ---- indicators-axis ---------------------------------------------------#
+    
+    # Returns all indicators (subject identifiers) of these Topics.
+    #
+    # The result may be empty.
+    #
+    # :call-seq:
+    #   indicators -> Array of Strings
+    #
+    def indicators
+      #self = Array of TopicProxies
+      #containee: RTM::Axes::Topic
+      #send -> Array of Strings
+      self.inject([]){|all,containee| all << containee.send(:indicators)}.flatten
+      ### NO UNIQUE NEEDED
+    end
+
+    # ---- item-axis ---------------------------------------------------------#
+    
+    # Returns one item identifier for each of these Topics, only if
+    # if the Topic has an item identifier.
+    #
+    # The result may be an empty Array.
+    # 
+    # :call-seq:
+    #   item -> Array of Strings
+    #
+    def item
+      #self = Array of TopicProxies
+      #containee: RTM::Axes::Topic
+      #send -> Array of (String or nil)s
+      _res = self.inject([]){|all,containee| all << containee.send(:item)}.flatten
+      _res = _res.select{|i| i}
+      ### NO UNIQUE NEEDED
+    end
+
+    # ---- locators-axis -----------------------------------------------------#
+    
+    # Returns all subject locators of these Topics.
+    #
+    # The result may be empty.
+    #
+    # :call-seq:
+    #   locators -> Array of Strings
+    #
+    def locators
+      self.inject([]){|all,containee| all << containee.send(:locators)}.flatten
+      ### NO UNIQUE NEEDED
+    end
+
+    # ---- players-axis ------------------------------------------------------#
+    
+    # Returns all Associations in which these Topics play a Role.
+    #
+    # The optional
+    # identifier specifies the type of the Roles to be considered.
+    # The identifier may be a topic reference.
+    #
+    # Multiple instances of the same Association are possible.
+    # The result may be empty.
+    #
+    # :call-seq:
+    #   reverse_players -> Array of Associations
+    #   reverse_players(identifier) -> Array of Associations
+    #
+    def reverse_players(type=:any)
+      _res = self.inject([]){|all,containee| all << containee.send(:reverse_players,type)}.flatten
+      ### NO UNIQUE ###
+      _res = _res.extend(Associations)
+      _res
+    end
+
+    # ---- reifier-axis ------------------------------------------------------#
+    
+    # Returns the Constructs which are reified by one of these Topics
+    # only if such Constructs exist.
+    #
+    # :call-seq:
+    #   reifier -> Array of Associations, Names and Occurrences
+    #
+    def reifier
+      _res = self.inject([]){|all,containee| all << containee.send(:reifier)}.flatten
+      _res = _res.select{|i| i} #reject nil
+      ### NO UNIQUE NEEDED
+      _res = _res.extend(AssocsNamesOccs)
+      _res
+    end
+
+    # ---- roles-axis --------------------------------------------------------#
+    
+    # Returns all Associations that have Roles that have one of
+    # these Topics as Roletype. Multiple instances of the same
+    # Association are possible.
+    #
+    # The result may be empty.
+    #
+    # :call-seq:
+    #   reverse_roles -> Array of Associations
+    #
+    def reverse_roles
+      _res = self.inject([]){|all,containee| all << containee.send(:reverse_roles)}.flatten
+      ### NO UNIQUE ###
+      _res = _res.extend(Associations)
+      _res
+    end
+
+    # ---- scope-axis --------------------------------------------------------#
+    
+    # Returns all Associations, Names and Occurrences that include at least one of these
+    # Topics (themes) in their scope.
+    #
+    # The result may be empty.
+    #
+    # :call-seq:
+    #   reverse_scope -> Array of Names, Associations and Occurrences
+    #
+    def reverse_scope
+      _res = self.inject([]){|all,containee| all << containee.send(:reverse_scope)}.flatten
+      ### FLAG UNIQUE ###
+      _res = _res.map{|i| i.construct}.uniq.map{|i| i.axes}
+       ###             ###
+      _res = _res.extend(AssocsNamesOccs)
+      _res
+    end
+
+    # ---- supertypes-axis ---------------------------------------------------#
+    
+    # Returns all supertypes of all of these Topics. The result includes 
+    # all direct supertypes
+    # and the supertypes of these direct supertypes.
+    #
+    # The result may be an empty Array.
+    #
+    # :call-seq:
+    #   supertypes -> Array of Topics
+    #
+    def supertypes
+      _res = self.define_helper(:supertypes)
+      #_res = self.inject([]){|all,containee| all << containee.send(:supertypes)}.flatten
+      ### FLAG UNIQUE ###
+      _res = _res.map{|i| i.construct}.uniq.map{|i| i.axes}
+      ###             ###
+      _res = _res.extend(Topics)
+      _res
+    end
+
+    # Returns all subtypes of all of these Topics. The result includes the direct subtypes
+    # and the subtypes of these direct subtypes.
+    #
+    # The result may be an empty Array.
+    #
+    # :call-seq:
+    #   subtypes -> Array of Topics
+    #
+    def subtypes
+      _res = self.inject([]){|all,containee| all << containee.send(:subtypes)}.flatten
+       ### FLAG UNIQUE ###
+      _res = _res.map{|i| i.construct}.uniq.map{|i| i.axes}
+       ###             ###
+      _res = _res.extend(Topics)
+      _res
+    end
+    
+    alias reverse_subtypes supertypes
+    alias reverse_supertypes subtypes
+
+    # ---- traverse-axis ---------------------------------------------------#
+    
+    # First computes all Associations where these Topics play a Role.
+    # There, the optional identifier filters the Associations for their type.
+    # 
+    # Returns all Players of all Roles in these Associations.
+    # Each Topic is deducted ones from the returned Array.
+    # The result may be empty.
+    #
+    # The identifier may be a topic reference.
+    #
+    # :call-seq:
+    #   traverse(identifier) -> Array of Topics
+    #
+    def traverse(type=:any)
+      _res = self.inject([]){|all,containee| all << containee.send(:traverse,type)}.flatten
+      ### NO UNIQUE ###
+      _res = _res.extend(Topics)
+      _res
+    end
+    
+    # Always returns an empty Array
+    #
+    # :call-seq:
+    #   reverse_traverse -> Array of Topics
+    #
+    def reverse_traverse
+      _res = [] #HARDCODED
+      _res.extend(Topics)
+    end
+
+    # ---- types-axis --------------------------------------------------------#
+    
+    # Returns the Topics these Topics are instances of. Calls
+    # the TMAPI getTypes method.
+    #
+    # The result may be empty.
+    #
+    # :call-seq:
+    #   types -> Array of Topics
+    #
+    def types
+      #self = Array of TopicProxies
+      #containee: RTM::Axes::Topic
+      #send -> Array of TopicProxies
+      #uniq -> Topics in Array, call unique on Array
+      #convert to TopicProxies again
+      #extend result-Array
+      _res = self.inject([]){|all,containee| all << containee.send(:types)}.flatten
+       ### FLAG UNIQUE ###
+      _res = _res.map{|i| i.construct}.uniq.map{|i| i.axes}
+       ###             ###
+      _res.extend(Topics)
+      _res
+    end
+    
+    # Returns the Topics which are instances of these Topics.
+    # Uses the TMAPI TypeInstanceIndex.
+    #
+    # The result may be empty.
+    #
+    # :call-seq:
+    #   instances -> Array of Topics
+    #
+    def instances
+      _res = self.inject([]){|all,containee| all << containee.send(:instances)}.flatten
+       ### FLAG UNIQUE ###
+      _res = _res.map{|i| i.construct}.uniq.map{|i| i.axes}
+       ###             ###
+      _res.extend(Topics)
+      _res
+    end
+    
+    alias reverse_types instances
+    alias reverse_instances types
+
+  end  
+end

data/lib/rtm/{backward_compatibility.rb → deprecated/index_property_set.rb}

@@ -1,3 +1,6 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
 class RTM::AR::Topic
   extend RTM::AR::TraverseAssociations
   def self.index_property_set(*args)

data/lib/rtm/engine.rb

@@ -0,0 +1,101 @@
+module RTM
+  class Engine
+    include RTM::TopicMapSystem
+
+    def self.abstract?
+      self == Engine
+    end
+
+    def self.inherited(subclass)
+      Engine.add(subclass) # this MUST be Engine and not self! Otherwise every intermediate class in the inheritance chain will have it's own list
+    end
+    
+    def self.add(engine)
+      @engines ||= []
+      @engines << engine
+    end
+    
+    def self.identifier(i=nil)
+      if i
+        # setter / declaration
+        @identifier = i
+      else
+        # getter
+        @identifier
+      end
+    end
+    
+    def self.all
+      @engines ||= []
+      @engines.reject!{|e| e.abstract?} # this needs to be done here because in the inherited hook the method is not yet available.
+      @engines
+    end
+    
+    def self.list
+      all.map{|e| e.identifier}
+    end
+    
+    def self.[](identifier)
+      all.find {|e| e.identifier == identifier}
+    end
+    
+    def self.load(engine_name)
+      if Object.const_defined?("Gem") && rtmgem = Gem.loaded_specs["rtm"]
+        require "rtm/#{engine_name}"
+      else
+        engine_path = File.expand_path(File.join(File.dirname(__FILE__), "../../../rtm-#{engine_name}/lib"))
+        if File.directory?(engine_path)
+          $LOAD_PATH.unshift engine_path
+          require "rtm/#{engine_name}"
+        end
+      end
+      self[engine_name]
+    end
+
+    def self.load!(engine_name=nil)
+      engine_name = self.detect unless engine_name
+      unless list.include?(engine_name)
+        warn("Requested engine '#{engine_name}' not loaded. Trying to autoload it.")
+        engine = load(engine_name)
+        if list.include?(engine_name)
+          warn("Autoloading '#{engine_name}' was successful")
+        else
+          raise "Autoloading '#{engine_name}' failed. Make sure rtm-#{engine_name} exists and is installed or require it manually."
+        end
+      end
+      engine || load(engine_name)
+    end
+    
+    def self.detect(preferred=nil)
+      if preferred # return the users preference, if given
+        implementation = preferred
+      elsif engine_name = ENV['RTM_IMPLEMENTATION'] # inspect system environment
+        implementation = engine_name.to_sym
+      elsif engine_name = ENV['RTM_ENGINE'] # inspect system environment (alternative)
+        implementation = engine_name.to_sym
+      elsif implementation = self.list.first # check if one is already loaded
+        warn("No engine implementation was specified for RTM.connect. Using the first already loaded engine (#{implementation.inspect}).")
+      else
+        implementation = self.default # use hardcoded default
+        warn("No engine implementation was specified for RTM.connect. Choosing default (#{implementation.inspect}).")
+        implementation
+      end
+      implementation
+    end
+
+    def self.default
+      if RUBY_PLATFORM =~ /java/
+        :ontopia
+      else
+        :activerecord
+      end
+    end
+
+    attr_reader :connections
+
+    def initialize(params={})
+      @params = params
+    end
+
+  end
+end

data/lib/rtm/extensions.rb

@@ -1,5 +1,8 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
 module RTM
-  # Register a module as extension.
+  # Register a module as extension to RTM.
   # 
   # Example:
   # module MyExtension
@@ -11,9 +14,66 @@ module RTM
   #   RTM.register_extension(self)
   # end
   #
-  def self.register_extension(plugin_mod)
-    plugin_mod.constants.each do |const|
-      const_get(const).send(:include, plugin_mod.const_get(const) ) if const_defined?(const)
+  def self.register_extension(module_with_modules)
+    # puts "[RTMEXT] registering extension #{module_with_modules}"
+    module_with_modules.constants.each do |sub_module|
+      self.const_get(sub_module).register_extension(module_with_modules.const_get(sub_module)) if self.const_defined?(sub_module)
     end
   end
-end
+
+  # Extend a module or class with this method to make it a receiver for RTM extensions.
+  # E.g. MyModule.extend(Extendable) or MyClass.extend(Extendable).
+  #
+  # A extension can then be registered using
+  # MyModule.register_extension(MyExtension)
+  #
+  # The module will then keep track of all modules or classes it's included in.
+  # These modules and classes are called implementations here.
+  # If an extension is added later, the implementations will also be updated which would not be the case if normal includes were used.
+  module Extendable
+    # Register a module as an extension to an Entity in RTM.
+    # An entity may be e.g. RTM::TopicMap, RTM::Topic or any Module which was extended with RTM::Extendable
+    #
+    # Besides normal ruby inclusion of the module, this module keeps track of its implementations which are also updated in this method.
+    def register_extension(mod)
+      include mod
+      return unless @implementations
+      @implementations.each do |impl|
+        next if impl.ancestors.include?(mod)
+        impl.send(:include, mod)
+      end
+    end
+
+    # A standard Ruby hook to be notified about inclusions of this module.
+    # This normally eliminates the need to register a module as implementa
+    def included(klass)
+      # super
+      # puts "[RTMEXT] including #{self} into #{klass} in #{caller(1).first}"
+      register_implementation(klass)
+      klass.class_eval do
+        def self.included(klass2)
+          # puts "[RTMIMPLEXT] #{self} was included into #{klass2} in #{caller(1).first}"
+          # self.ancestors.select {|anc| anc.respond_to?(:register_implementation)}.each{|anc| anc.register_implementation(klass2) }
+          self.ancestors.find {|anc| anc.respond_to?(:register_implementation)}.register_implementation(klass2)
+        end
+      end
+    end
+
+    # Register an implementation to this module.
+    # Registred implementations will be updated if later any extensions are added.
+    # This method should normally be called from the included hook.
+    # Due to Ruby's restrictions on calling protected methods from other modules extending the very same module Extendable,
+    # this method must be public.
+    def register_implementation(klass)
+      # super if self.class.superclass.respond_to?(:register_implementation)
+      @implementations ||= []
+      @implementations << klass
+    end
+  end
+  [
+    TopicMapSystem, Construct, Reifiable,
+    DatatypeAware, Scoped, Typed,
+    TopicMap, Topic, Name, Occurrence, Variant, Association, Role,
+    Locator, ItemIdentifier, SubjectIdentifier, SubjectLocator
+  ].each{|mod| mod.extend(Extendable)}
+end