rtm 0.1.6 → 0.2.0

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

@@ -1,87 +0,0 @@
-module RTM::AR
-  module TraverseAssociations
-    # defines methods to traverse a specific assocation for all topics
-    def define_association(prop, options={})
-      r = options[:rule]
-      module_eval(<<-EOS, "(__AR_DELEGATOR_DEFINE_ASSOCIATION__)", 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_DEFINE_ASSOCIATION2__)", 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] && r[:infer_other] # this part is not testet at all!
-          module_eval(<<-EOS, "(__AR_DELEGATOR_DEFINE_ASSOCIATION3a__)", 1)
-            def #{prop}
-              dps = (self + self.#{r[:infer]}).flatten.uniq
-              dcps = dps.map{|d2| d2.direct_#{prop}}
-              (dcps + dcps.map{|d2| d2.#{r[:infer_other]}}).flatten.uniq
-            end
-          EOS
-        elsif r[:infer]
-          module_eval(<<-EOS, "(__AR_DELEGATOR_DEFINE_ASSOCIATION3__)", 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_DEFINE_ASSOCIATION4__)", 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_DEFINE_ASSOCIATION_ADD_REMOVE__)", 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 define_association 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 define_association needs to trigger reload of the topics somewhere
-          end
-        EOS
-      end
-    end
-  end
-end

data/lib/rtm/base.rb

@@ -1,92 +0,0 @@
-module RTM
-  def self.create(base_locator)
-    AR::TopicMap.create(base_locator)
-  end
-  
-  def self.topic_maps
-    AR::TopicMap.topic_maps
-  end
-  
-  def self.[](*args)
-    if args.size == 0
-      return AR::TopicMap.topic_maps
-    end
-    AR::TopicMap.topic_maps[*args]
-  end
-  module TopicMapConstruct
-    def find(*args)
-      RTM::AR.const_get(name.split("::").last).find(*args)
-    end
-  end
-  module Reifiable
-  end
-  
-  module TopicMap
-    extend TopicMapConstruct
-  end
-  
-  module Topic
-    extend TopicMapConstruct
-
-  end
-
-  module Association
-    extend TopicMapConstruct
-
-  end
-
-  module AssociationRole
-    extend TopicMapConstruct
-
-  end
-
-  module TopicName
-    extend TopicMapConstruct
-
-  end
-
-  module Variant
-    extend TopicMapConstruct
-
-  end
-
-  module Occurrence
-    extend TopicMapConstruct
-
-  end
-  
-  module Locator
-    
-  end
-  
-  module ItemIdentifier
-    extend Locator  
-  end
-  
-  module SubjectIdentifier
-    extend Locator
-  end
-  
-  module SubjectLocator
-    extend Locator
-  end
-  
-#  module Topics  
-#  end
-#  module Associations
-#  end
-#  module TopicNames
-#  end
-#  module Occurrences
-#  end
-#  module AssociationRoles
-#  end
-#  module Reifiables
-#  end
-#  module Variants
-#  end
-#  module TopicMaps
-#  end
-#  module Locators
-#  end
-end

data/lib/rtm/connect.rb

@@ -1,92 +0,0 @@
-require 'active_record'
-require 'rtm/backend/active_record/001_initial_schema'
-module RTM
-  
-  # Assignes a logger to active record (or STDOUT as default) which outputs
-  # the sql statements.
-  def self.log(to=STDOUT)
-    ActiveRecord::Base.logger = Logger.new(to)
-    ActiveRecord::Base.colorize_logging = false if PLATFORM =~ /mswin/
-  end
-  # This function generates the database schema using the default
-  # ActiveRecord connection.
-  def self.generate_database
-    RTM::AR::TMDM::InitialSchema.migrate(:up)
-  end
-  
-  # Connects to the sqlite3 database given in the path or to
-  # a default database if no path is given.
-  def self.connect_sqlite3(dbname="tmdm.sqlite3")
-    ActiveRecord::Base.establish_connection(
-      :adapter => platform_specific_adapter("sqlite3"),
-      :database  => dbname
-    )
-  end
-  
-  # Connects to the sqlite2 database given in the path or to
-  # a default database if no path is given.
-  def self.connect_sqlite(dbname="tmdm.sqlite2")
-    ActiveRecord::Base.establish_connection(
-      :adapter => platform_specific_adapter("sqlite"),
-      :database  => dbname
-    )
-  end  
-  # Connects to a mysql database. Parameters are
-  # either
-  # database, username, password, host
-  # or
-  # only a keyword hash with these parameters.
-  def self.connect_mysql(database="rtm_development", username=nil, password=nil, host="localhost")
-    if database.is_a? Hash
-      return ActiveRecord::Base.establish_connection(database)
-    end
-    ActiveRecord::Base.establish_connection(
-      :adapter => platform_specific_adapter("mysql"),
-      :database => database,
-      :username => username,
-      :password => password,
-      :host => host
-    )
-  end
-  
-  # Connects to a in-memory database. No parameters required.
-  # Schema will automatically be generated.
-  def self.connect_memory
-    ActiveRecord::Base.establish_connection(
-      :adapter => platform_specific_adapter("sqlite3"),
-      :database  => ":memory:"
-    )
-    no_output do
-      generate_database
-    end
-    true
-  end
-  
-  # Connects to a in-memory sqlite2 database, as connect_memory does with sqlite3
-  def self.connect_memory2
-    ActiveRecord::Base.establish_connection(
-      :adapter => platform_specific_adapter("sqlite"),
-      :database  => ":memory:"
-    )
-    no_output do
-      generate_database
-    end
-    true
-  end
-  
-  # Connects Active Record to a database or in Memory database if no parameters given.
-  def self.connect(*args)
-    if args.size == 0
-      return connect_memory
-    end
-    ActiveRecord::Base.establish_connection(*args)
-  end
-
-  private
-  def self.platform_specific_adapter(adapter)
-    if PLATFORM && PLATFORM =~ /java/
-      return "jdbc#{adapter}"
-    end
-    return adapter
-  end
-end

data/lib/rtm/core_ext.rb

@@ -1,6 +0,0 @@
-# already defined in active support
-#class Symbol
-#  def to_proc
-#    Proc.new { |obj, *args| obj.send(self, *args) }
-#  end
-#end

data/lib/rtm/io/from_xtm2.rb

@@ -1,263 +0,0 @@
-# Ruby Topic Maps (RTM) http://rtm.rubyforge.org/
-
-module RTM
-  def self.from_xtm2(*args)
-    RTM::IO::FROMXTM2.from_xtm2(*args)
-  end
-end
-module RTM::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 FROMXTM2
-    require 'rexml/document'
-    require 'rexml/parsers/sax2parser'
-    require 'rexml/sax2listener'
-    #require 'jrexml'
-    XTM2DEBUG = false
-    
-    # Reads XTM2 from source (io object).
-    # Example: RTM::IO::FROMXTM2.from_xtm2(File.open(file_name),"http://rtm.rubyforge.org/topicmaps/tm1/")
-    # supported options:
-    # :strip_whitespace (defaults to false, may be set to true),
-    # :deprefix (defaults to nil, may be set to a string (or regex) which will be removed from the beginning of an (unresolved) item_identifier if it is there.
-    def self.from_xtm2(source, base_locator, target=nil,options={})
-      tm = RTM.create(base_locator) unless target
-      list = XTM2Listener.new(base_locator, target || tm, options)
-      parser = REXML::Parsers::SAX2Parser.new(source)
-      parser.listen(list)
-      parser.parse
-      true
-    end
-    
-    class XTM2Listener
-      include REXML::SAX2Listener
-      def initialize(base_locator, target,options={})
-        @base_locator = base_locator
-        @target = target
-        @targets = []
-        @path = []
-        @options=options
-      end
-      
-      private
-      def resolve(iri)
-        warn("resolving nil iri can have unexpected results") unless iri
-        # TODO handle %HH sequences, here or in backend/active_record.rb
-        if @options[:deprefix]
-          iri = iri.gsub(/^#{@options[:deprefix]}/,'')
-        end
-        @target.resolve(iri, @base_locator)
-      end
-      
-      public
-      def start_element(uri, name, qname, attrs)
-        return unless uri == "http://www.topicmaps.org/xtm/"
-        a = attrs #Hash[* attrs.flatten]
-        #puts "Start of tag #{name} - attrs: #{a.inspect}"
-
-        case name
-        when "topic"
-           @topic = @targets.last.topic_by_item_identifier! resolve(a["id"])
-           @targets.push @topic
-        when "association"
-          assoc = nil
-          if a["reifier"]
-            ref = @targets.last.topic_map.topic_by_item_identifier! resolve(a["reifier"])
-            raise "The topic reifiing this association already reifies something else: #{ref}." if ref.reified && !ref.reified.is_a?(RTM::Association)
-            if ref.reified
-              assoc = ref.reified
-            else
-              assoc = @targets.last.create_association
-              assoc.reifier = ref
-            end
-          end
-          assoc ||= @targets.last.create_association
-          @targets.push assoc
-        when "role"
-          if a["reifier"]
-            ref = @targets.last.topic_map.topic_by_item_identifier! resolve(a["reifier"])
-            raise "The topic reifiing this association role already reifies something else: #{ref}." if ref.reified && !ref.reified.is_a?(RTM::AssociationRole)
-            if ref.reified
-              role = ref.reified
-            else
-              role = @targets.last.create_role
-              role.reifier = ref
-            end
-          end
-          role ||= @targets.last.create_role
-          @targets.push role
-        when "name"
-          if a["reifier"]
-            ref = @targets.last.topic_map.topic_by_item_identifier! resolve(a["reifier"])
-            raise "The topic reifiing this topic name already reifies something else: #{ref}." if ref.reified && !ref.reified.is_a?(RTM::TopicName)
-            if ref.reified
-              tname = ref.reified
-            else
-              tname = @targets.last.create_name
-              tname.reifier = ref
-            end
-          end
-          tname ||= @targets.last.create_name
-          @targets.push tname
-        when "value"
-          # this is handled in text()
-        when "variant"
-          if a["reifier"]
-            ref = @targets.last.topic_map.topic_by_item_identifier! resolve(a["reifier"])
-            raise "The topic reifiing this topic variant already reifies something else: #{ref}." if ref.reified && !ref.reified.is_a?(RTM::Variant)
-            if ref.reified
-              variant = ref.reified
-            else
-              variant = @targets.last.create_variant
-              variant.reifier = ref
-            end
-          end
-          variant ||= @targets.last.create_variant
-          @targets.push variant
-        when "scope"
-          # nothing to be done here :)
-        when "instanceOf"
-          # nothing to be done here :)
-        when "type"
-          # nothing to be done here :)
-        when "occurrence"
-          if a["reifier"]
-            ref = @targets.last.topic_map.topic_by_item_identifier! resolve(a["reifier"])
-            raise "The topic reifiing this topic occurrence already reifies something else: #{ref}." if ref.reified && !ref.reified.is_a?(RTM::Occurrence)
-            if ref.reified
-              occur = ref.reified
-            else
-              occur = @targets.last.create_occurrence
-              occur.reifier = ref
-            end
-          end
-          occur ||= @targets.last.create_occurrence
-          @targets.push occur
-        when "resourceData"
-          occur_or_variant = @targets.last
-          if a["datatype"]
-            occur_or_variant.datatype = a["datatype"]
-            # special handling is done in tag_end
-          else
-            occur_or_variant.datatype = RTM::PSI[:String]
-          end
-        when "topicRef"
-          case @path.last
-          when "scope"
-            @targets.last.scope << a["href"]
-          when "instanceOf"
-            assoc = @targets.last.topic_map.create_association :type => RTM::PSI[:type_instance]
-            assoc.create_role @targets.last, RTM::PSI[:instance]
-            assoc.create_role a["href"], RTM::PSI[:type]
-          when "type"
-            @targets.last.type = a["href"]
-          when "role"
-            @targets.last.player = a["href"]
-          end
-        when "resourceRef"
-          occurrence = @targets.last
-          occurrence.datatype = RTM::PSI[:IRI]
-          occurrence.value = a["href"]
-        when "subjectLocator"
-            @targets.last.subject_locators << a["href"]
-        when "subjectIdentifier"
-            @targets.last.subject_identifiers << a["href"]
-        when "itemIdentity"
-            @targets.last.item_identifiers << resolve(a["href"])
-        when "topicMap"
-            # check where we are
-            raise "unexpected element topicMap" unless @path.empty?
-            # check version
-            raise "Sorry, only XTM 2.0 is supported" if a["version"] != "2.0"
-            
-            # reifier. if target topic map is already reified we have to merge, if not create topic
-            if a["reifier"]
-              if @target.reifier # TODO this might be no topic here. In this case something should be raised!
-                @target.reifier.item_identifiers << resolve(a["reifier"])
-              else
-                @target.topic_by_item_identifier! resolve(a["reifier"])
-              end
-            end
-            @targets.push @target
-        when "mergeMap"
-          # TODO mergeMap
-          warn "mergeMap is not supported yet!"
-        else
-          warn "Unhandled element: #{name}"
-        end
-
-        @path.push name
-      end
-
-      # Called when the end tag is reached.  In the case of <tag/>, tag_end
-      # will be called immidiately after tag_start
-      # @p the name of the tag
-      def end_element(uri, name, qname)
-        return unless uri == "http://www.topicmaps.org/xtm/"
-        #puts "end of tag: #{name}"
-
-        old_name = @path.pop
-        raise "Tag_end did not match: expected: #{old_name}, got: #{name}." unless old_name == name
-        case name
-        when "topicMap", "topic", "association", "role", "name", "variant", "occurrence"
-          @targets.pop
-        when "resourceData"
-          occur = @targets.last
-#          puts "finalizing occurrence #{occur.inspect}"
-          if occur.datatype == RTM::PSI[:IRI]
-            occur.value = resolve(occur.value)
-          elsif occur.datatype == RTM::PSI[:anyType]
-            # TODO Content must be canonicalized according to http://www.isotopicmaps.org/sam/sam-xtm/#sect-xml-canonicalization
-            warn("Content canonicalization is not yet implemented!")
-          end
-#          puts "leaving finalizing occurrence"
-        end
-#        puts "after case"
-      end
-      # Called when text is encountered in the document
-      # @p text the text content.
-      def characters(text)
-        if @options[:strip_whitespace]
-          text.strip!
-          return if text.empty?
-        end
-        case @path.last
-        when "value", "resourceData"
-          if @targets.last.value
-            @targets.last.value += text
-          else
-            @targets.last.value = text
-          end
-        else
-          puts "Found text but don't know that to do: #{text}" unless text.strip.empty?
-        end
-      end
-
-      def cdata content
-        if @options[:strip_whitespace]
-          content.strip!
-          return if content.empty?
-        end
-        case @path.last
-        when "value", "resourceData"
-          if @targets.last.value
-            @targets.last.value += content
-          else
-            @targets.last.value = content
-          end
-        else
-          puts "Found cdata but don't know that to do: #{content}" unless content.strip.empty?
-        end
-      end
-
-      def xmldecl version, encoding, standalone
-        warn "XML Version 1.0 expected. Not sure if we can handle this, but we will try." unless version == "1.0"
-        warn "Be aware there is no encoding manipulation done, everything gets in as-is." if encoding
-        # what about standalone?
-      end
-      
-    end
-
-  end
-end