semantic_naming 2.0.6 → 2.1.0

data/lib/ontology_graph/class_node.rb

@@ -0,0 +1,71 @@
+module OntologyGraph
+  
+  # Helper class that contains a node in the internal RDFS/OWL class graph
+  class ClassNode
+    
+    attr_accessor :subclasses, :superclasses, :uri, :flags
+    
+    # Create a new unconnected node with the given uri
+    def initialize(uri)
+      @uri = uri
+      @subclasses = []
+      @superclasses = []
+    end
+    
+    # Add the given class as a subclass
+    def add_subclass(klass) 
+      self.subclasses << klass
+      klass.superclasses << self
+    end
+    
+    # Add the given class as a superclass
+    def add_superclass(klass)
+      self.superclasses << klass
+      klass.subclasses << self
+    end
+    
+    # Flag this node as "used" (meaning that there are Resources having
+    # this class as it's type)
+    def flag_used
+      @used = true
+    end
+    
+    # Indicates if the node is "used", meaning if any resources have it
+    # as it's type
+    def used?
+      @used
+    end
+    
+    # Used to remove all "unreal superclasses", that are created by inferencing.
+    # A superclass is "unreal" if it appears in the path to the root
+    def weed_superclasses(root_path = [])
+      superclasses.reject! do |sup|
+        reject = false
+        # Ignore the last element in the root path, wich points to the direct parent
+        if(reject = root_path[0..-2].include?(sup))
+          sup.subclasses.reject! { |cl| cl == self }
+        end
+        reject
+      end
+      subclasses.each { |sub| sub.weed_superclasses(root_path + [ self ]) }
+    end
+    
+    def uri
+      @uri
+    end
+    
+    def to_s
+      @uri
+    end
+    
+    def to_uri
+      return N::SourceClass.new(@uri)
+    end
+    
+    def inspect
+      "<#{self.class.name}:#{self.object_id} @uri=\"#{uri}\" @subclasses = [#{subclasses.collect { |s| s.to_s}.join(', ')}] @superclasses = [#{superclasses.collect { |s| s.to_s}.join(', ')}] >"
+    end
+    
+  end
+  
+end

data/lib/ontology_graph/graph.rb

@@ -0,0 +1,118 @@
+module OntologyGraph
+
+  # Class for handling the graph of ontology classes. This allows
+  # quick access to each RDFS class know to the system.
+  #
+  # If ActiveRDF is available, the graph can initialize itself from
+  # the RDF store and allows access to all the subclass and superclass
+  # relations in the system.
+  class Graph
+    
+    include Enumerable
+    
+    # Create a new class graph
+    def initialize
+      @class_hash = {}
+    end
+    
+    # Add a relation between a subclass or a superclass
+    def add_relation(superclass, subclass)
+      subclass = get_or_create_node(subclass)
+      superclass = get_or_create_node(superclass)
+      superclass.add_subclass(subclass)
+    end
+    
+    # Retrieve the graph node for the given name/URL. If the node 
+    # does not already exist, it will be created. 
+    def get_or_create_node(name)
+      node = get_node(name)
+      return node if(node)
+      node = ClassNode.new(name)
+      @class_hash[name] = node
+      node
+    end
+    
+    def get_node(name)
+      @class_hash[name.to_s]
+    end
+    
+    # Iterate through each node
+    def each(&block)
+      @class_hash.each_value(&block)
+    end
+    alias :each_node :each
+    
+    # Build the whole graph from the RDF store. This will include all Resources that
+    # are either marked as an rdfs:class orare used as an rdf:type and all the subclass
+    # relations between them. 
+    def build_from_ardf
+      return unless(N::URI.active_rdf?)
+      
+      # First select all classes and add them as nodes
+      class_qry = Query.new(N::URI).select(:class).where(:class, N::RDF.type, N::RDFS.Class)
+      types = class_qry.execute
+      types.each { |t| @class_hash[t.to_s] = ClassNode.new(t.to_s) }
+      
+      # Now, look for all subclass relationships and add them
+      subtype_qry = Query.new(N::URI).distinct.select(:class, :subclass)
+      subtype_qry.where(:subclass, RDFS.subClassOf, :class)
+      subtype_list = subtype_qry.execute
+      subtype_list.each  { |cl, subcl| add_relation(cl, subcl) }
+      
+      # Flag all classes that are actually used
+      used_types_qry = Query.new(N::URI).distinct.select(:type)
+      used_types_qry.where(:element, RDF.type, :type)
+      used_types = used_types_qry.execute
+      used_types.each { |t| get_or_create_node(t).flag_used }
+      
+      weed_inference
+      
+    end
+    
+    # Reset the flags for tree walking on all nodes of the tree.
+    def reset_flags
+      @class_hash.each_value { |n| n.flags = nil }
+    end
+    
+    # Create a tree of subclasses, starting from the given node.
+    # This will return a ClassNode which is the root of a tree of 
+    # all classes that are reachable from the current node as subclasses.
+    def tree_from(node_name, &block)
+      reset_flags
+      make_tree_from(node_name, &block)
+    end
+    
+    # Weed out "inferred" subclass relationships from the graph, if
+    # they exist.
+    def weed_inference
+      root_elements = []
+      @class_hash.each_value do |node|
+        if(node.superclasses.empty?)
+          root_elements << node
+        end
+      end
+      
+      raise(RuntimeError, "No root elements in the graph, ontology graph cannot by cyclic") if(root_elements.empty?)
+
+      root_elements.each { |root| root.weed_superclasses }
+    end
+    
+    private 
+    
+    # See #tree_from
+    def make_tree_from(node_name)
+      node_name = node_name.to_s
+      start = get_or_create_node(node_name)
+      root = ClassNode.new(node_name)
+      start.flags = :visited
+      start.subclasses.each do |sub| 
+        next if(sub.flags == :visited)
+        accepted = block_given? ? yield(sub) : true
+        root.add_subclass(make_tree_from(sub)) unless(!accepted && (sub.subclasses.size == 0))
+      end
+      root
+    end
+    
+  end
+
+end

data/lib/semantic_naming/source_class.rb

@@ -1,43 +1,58 @@
 module N
 
-  # This is the type of URI that represents a class of sources. The methods
-  # that browse the ontology hierarchy depend on ActiveRDF for accessing the
-  # RDF store. If ActiveRDF is not present, these will return nitl.
+  # This is the type of URI that represents a class of sources. Each SourceClass 
+  # object is part of the internal class graph. If an ActiveRDF connection is
+  # present, it is possible to quickly navigate through the type hierarchy.
+  #
+  # The class hierarchy is base on the OntologyGraph structures - it will not
+  # show inferred types as subtypes or supertypes of the current class.
+  # 
+  # The graph of the class realtions will usually be cached, it can be reset
+  # by passing allow_caching = false to the respective methods.
   class SourceClass < URI
     
     # Get the supertype of this class
-    def supertypes
-      return nil unless(active_rdf? && is_iri?)
-      qry = Query.new(SourceClass).distinct.select(:o)
-      qry.where(self, RDFS.subClassOf, :o)
-      qry.where(:o, RDF.type, RDFS.Class)
-      qry.execute
+    def supertypes(allow_caching = true)
+      my_node(allow_caching).superclasses.collect { |st| SourceClass.new(st.uri) }
     end
     
     # Get the subtypes of this type
-    def subtypes
-      return nil unless(active_rdf? && is_iri?)
-      qry = Query.new(SourceClass).distinct.select(:s)
-      qry.where(:s, RDFS.subClassOf, self)
-      qry.where(:s, RDF.type, RDFS.Class)
-      qry.execute
+    def subtypes(allow_caching = true)
+      my_node(allow_caching).subclasses.collect { |st| SourceClass.new(st.uri) }
     end
     
     # Get the instances of this type. return_type will be the class used to 
-    # create the objects that are returned.
+    # create the objects that are returned. This will not use the cached
+    # graph but cause an RDF query on each call
     def instances(return_type)
       return nil unless(active_rdf? && is_iri?)
-      qry = Query.new(SourceClass).distinct.select(:s)
+      qry = Query.new(URI).distinct.select(:s)
       qry.where(:s, RDF.type, self)
       qry.execute
     end
     
-    # Get all the existing types from the RDF store
-    def self.rdf_types
-      return nil unless(URI.active_rdf?)
-      qry = Query.new(SourceClass).distinct.select(:s)
-      qry.where(:s, RDF.type, RDFS.Class)
-      qry.execute
+    # Returns the ClassNode element related to this class. This
+    # will return a "dummy" element when the node is not found in
+    # the graph
+    def my_node(allow_caching = true)
+      graph = SourceClass.class_graph(allow_caching)
+      graph.get_node(@uri_s) || OntologyGraph::ClassNode.new(@uri_s)
+    end
+    
+    # Return all the existing types as a list of SourceClass objects
+    def self.rdf_types(allow_caching = true)
+      graph = class_graph(allow_caching)
+      return nill unless(graph)
+      graph.collect { |n| SourceClass.new(n.uri) }
+    end
+    
+    # Get all the existing types from the RDF store. Return the class
+    # graph directly
+    def self.class_graph(allow_caching = true)
+      return @class_graph if(allow_caching && @class_graph)
+      @class_graph = OntologyGraph::Graph.new
+      @class_graph.build_from_ardf if(URI.active_rdf?)
+      @class_graph
     end
     
     # Return a subclass hierarchy. This is quicker than going through
@@ -47,95 +62,31 @@ module N
     # the values are hashes with the child elements, and so on
     #
     # E.g. : { type1 => { subtype_a => {}, subtype_b => { xtype => {}} }, type_2 => {}}
-    def self.subclass_hierarchy
-      return nil unless(URI.active_rdf?)
-      types = rdf_types
-      qry = Query.new(SourceClass).distinct.select(:class, :subclass)
-      qry.where(:class, RDF.type, RDFS.Class)
-      qry.where(:subclass, RDFS.subClassOf, :class)
-      subtype_list = qry.execute
-      
-      build_hierarchy_from(subtype_list, rdf_types)
-    end
-    
-    # This works like the subclass_hierarchy method, with the exception that
-    # 
-    # * Ontology information is only used for subtype relations
-    # * Resources are considered a "type" if they appear as an rdf:type attribute
-    # * Only types that are actively used (that is they appear as an rdf:type attribute)
-    #   are included
-    def self.used_subclass_hierarchy
-      all_types_qry = Query.new(SourceClass).distinct.select(:type)
-      all_types_qry.where(:element, RDF.type, :type)
-      all_types = all_types_qry.execute
-      
-      qry = Query.new(SourceClass).distinct.select(:class, :subclass)
-      qry.where(:subclass, RDFS.subClassOf, :class)
-      subtype_list = qry.execute
-      
-      all_types_hash = {}
-      all_types.each { |type| all_types_hash[type] = true }
-      
-      # TODO: Not very efficient, but then we don't expect many types
-      all_type_list = (all_types + subtype_list.collect { |el| el.last }).uniq
-      
-      hierarchy = build_hierarchy_from(subtype_list, all_type_list)
-      
-      purge_hierarchy!(hierarchy, all_types_hash)
-      
-      hierarchy
-    end
-    
-    private
-    
-    # Purge the elements from the hierarchy that don't have any "used"
-    # children. Returns true if some "used" elements were found in
-    # the hierarchy
-    def self.purge_hierarchy!(elements, used_elements)
-      used = false
-      elements.each do |element, children|
-        used_children = purge_hierarchy!(children, used_elements)
-        used_element = used_children || used_elements[element]
-        elements.delete(element) unless(used_element)
-        used ||= used_element
-      end
-      used
-    end
-    
-    # If all_types is given, it must be a true superset of all
-    # types in the query result
-    def self.build_hierarchy_from(query_result, all_types = nil)
-      hierarchy = {}
-      # Sift through the triples and add the sub-items
-      query_result.each do |sub_items|
-        klass, subklass = sub_items
-        hierarchy[klass] ||= {}
-        hierarchy[klass][subklass] = true
-      end
+    #
+    # If a block is passed, it will receive the ClassNode object of each
+    # class in the graph. If the block returns false, this class will not
+    # be included in the hierarchy if possible (that is, if the class is a leaf)
+    def self.subclass_hierarchy(root_list = nil, allow_caching = true, &block)
+      graph = SourceClass.class_graph(allow_caching)
       
-      # Now we link up the subclass relations
-      hierarchy.each do |key, values|
-        values.each_key do |subkey|
-          next if(subkey.is_a?(Symbol))
-          hierarchy[subkey] ||= {}
-          values[subkey] = hierarchy[subkey]
-          values[subkey][:is_child] = true
-        end
+      if(root_list)
+        root_list.collect! { |el| el.is_a?(OntologyGraph::ClassNode) ? el : OntologyGraph::ClassNode.new(el) }
+      else
+        root_list = []
+        graph.each_node { |n| root_list << n if(n.superclasses.empty?) }
       end
       
-      all_types ||= hierarchy.keys
-      
-      # Join with the general types and remove the children
-      all_types.each do |type|
-        xtype = (hierarchy[type] ||= {})
-        hierarchy.delete(type) if(xtype.delete(:is_child))
+      hierarchy = {}
+      root_list.each do |root_el|
+        remove = (block == nil) ? false : !block.call(root_el)
+        sub_hierarchy = subclass_hierarchy(root_el.subclasses, allow_caching, &block)
+        remove = remove && sub_hierarchy.empty?
+        hierarchy[N::URI.new(root_el.uri.to_s)] = sub_hierarchy unless(remove)
       end
       
-      hierarchy.delete(N::RDFS.Class)
-      hierarchy.delete(N::OWL.Class) if(defined?(N::OWL))
-      
       hierarchy
     end
     
+    
   end
 end

data/lib/semantic_naming/uri.rb

@@ -2,9 +2,9 @@ module N
   
   # This class contains basic functionality for URIs
   class URI
-  
+
     # Should behave like an ActiveRDF resource
-    include RDFS::ResourceLike
+    include RDFS::ResourceLike if(defined?(RDFS) && defined?(RDFS::ResourceLike))
     
     # Contains the registered uris
     @@registered_uris = Hash.new
@@ -306,7 +306,5 @@ module N
       result
     end
     
-
-    
   end
 end

data/lib/semantic_naming.rb

@@ -9,7 +9,7 @@ $: << this_dir + '/semantic_naming/'
 require 'rubygems'
 begin
   require 'active_rdf'
-rescue
+rescue Exception
   puts "ActiveRDF not found"
 end
 
@@ -18,3 +18,5 @@ require 'semantic_naming/default_namespaces'
 require 'semantic_naming/namespace'
 require 'semantic_naming/source_class'
 require 'semantic_naming/predicate'
+require 'ontology_graph/graph'
+require 'ontology_graph/class_node'

data/test/class_node_test.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/test_helper'
+# Test the uri class
+class URITest < Test::Unit::TestCase
+
+  def test_flagging
+    node = OntologyGraph::ClassNode.new('test_flagging')
+    assert(!node.used?)
+    node.flag_used
+    assert(node.used?)
+  end
+
+end

data/test/graph_test.rb

@@ -0,0 +1,133 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/test_helper'
+# Test the uri class
+class URITest < Test::Unit::TestCase
+  
+  def test_weeding
+    graph = build_test_for_weed
+    graph.weed_inference
+    test_node(graph, 'a', [], ['c', 'd'])
+    test_node(graph, 'b', [], ['d', 'e'])
+    test_node(graph, 'c', ['a'], [])
+    test_node(graph, 'd', ['a', 'b'], ['f', 'g'])
+    test_node(graph, 'e', ['b'], ['h'])
+    test_node(graph, 'f', ['d'], ['i'])
+    test_node(graph, 'g', ['d'], ['h'])
+    test_node(graph, 'h', ['g', 'e'], ['i'])
+    test_node(graph, 'i', ['f', 'h'], [])
+  end
+  
+  # Test the tree. This test looks a bit tricky, as the last node
+  # can be reached in two ways, and only one will show up in the tree
+  #
+  # To understand this, best draw the graph from build_test_graph
+  def test_tree
+    graph = build_test_graph
+    # Using the standard test graph, get a tree from the 'd' node
+    tree = graph.tree_from('d')
+    # Test the parent node
+    test_node_direct(tree, [], ['f', 'g'])
+    # flag to show that we have arrived at the 'i' node on exactly
+    # one of the possible paths
+    i_reached = false
+    # Test the two direct children of the parent node,
+    # which should be f and g
+    tree.subclasses.each do |sub|
+      if(sub.to_s == 'f')
+        # We are on the f node. 
+        # Check if we can reach the i node through f 
+        # The 'i' node can either be reached through f, or
+        # through g-h
+        if(sub.subclasses.size == 1)
+          # We have found the i node
+          test_node_direct(sub, ['d'], ['i'])
+          i_reached = true
+        else
+          test_node_direct(sub, ['d'], [])
+        end
+      elsif(sub.to_s == 'g')
+        # We are in the g node, coming from d.
+        # The next node will be 'h', and then we can
+        # either find 'i' (if not found through 'f')
+        # or not
+        test_node_direct(sub, ['d'], ['h'])
+        assert_equal(1, sub.subclasses.size)
+        # Check if we find the h node
+        hnode = sub.subclasses.first
+        assert_equal('h', hnode.to_s)
+        # look for the i node on this path, if it wasn't found above
+        if(hnode.subclasses.size == 0)
+          test_node_direct(hnode, ['g'], [])
+        else
+          assert_not(i_reached)
+          test_node_direct(hnode, ['g'], ['i'])
+          i_reached = true
+        end
+      else
+        fail
+      end
+    end
+    assert(i_reached)
+  end
+  
+  private
+  
+  def test_node(graph, node_name, superclasses, subclasses)
+    test_node_direct(graph.get_node(node_name), superclasses, subclasses)
+  end
+  
+  def test_node_direct(node, superclasses, subclasses)
+    assert_equal(node.superclasses.collect {|c| c.to_s }.sort, superclasses.sort)
+    assert_equal(node.subclasses.collect {|c| c.to_s }.sort, subclasses.sort)
+  end
+  
+  # Build the test graph for weeding out the inferred relations.
+  # 
+  # The tree is the build_test_graph plus
+  # the corresponding "direct" superclass and subclass relations
+  def build_test_for_weed
+    graph = build_test_graph
+    
+    graph.add_relation('a', 'f')
+    graph.add_relation('a', 'g')
+    graph.add_relation('a', 'h')
+    graph.add_relation('a', 'i')
+    graph.add_relation('d', 'h')
+    graph.add_relation('d', 'i')
+    graph.add_relation('g', 'i')
+    graph.add_relation('b', 'f')
+    graph.add_relation('b', 'g')
+    graph.add_relation('b', 'h')
+    graph.add_relation('b', 'i')
+    graph.add_relation('e', 'i')
+    graph
+  end
+  
+  # Build a test graph
+  # 
+  # The tree is 
+  # A -> [C, D]
+  # B -> [D, E]
+  # D -> [F, G]
+  # E -> [H]
+  # F -> [I]
+  # G -> [H]
+  # H -> [I]
+  #
+  def build_test_graph
+    graph = OntologyGraph::Graph.new
+    
+    graph.add_relation('a', 'c')
+    graph.add_relation('a', 'd')
+    graph.add_relation('d', 'f')
+    graph.add_relation('d', 'g')
+    graph.add_relation('f', 'i')
+    graph.add_relation('g', 'h')
+    graph.add_relation('h', 'i')
+    graph.add_relation('b', 'd')
+    graph.add_relation('b', 'e')
+    graph.add_relation('e', 'h')
+    graph
+  end
+  
+end

data/test/source_class_test.rb

@@ -41,17 +41,17 @@ class TypeTest < Test::Unit::TestCase
   def test_rdf_types
     return unless(RDF_ACTIVE)
     types = N::SourceClass.rdf_types.collect { |type| type.uri.to_s }
-    assert_equal([N::RDFTEST.Type1.to_s, N::RDFTEST.Type2.to_s, N::RDFTEST.Type3.to_s, N::RDFTEST.Type4.to_s].sort, types.sort)
+    assert_equal([N::RDFTEST.Type1.to_s, N::RDFTEST.Type2.to_s, N::RDFTEST.Type3.to_s, N::RDFTEST.Type4.to_s, N::RDFS.Class.to_s].sort, types.sort)
   end
   
   def test_subclass_hierarchy
     hierarchy = N::SourceClass.subclass_hierarchy
-    assert_equal({N::RDFTEST.Type1 => { N::RDFTEST.Type2 => {}, N::RDFTEST.Type3 => {} }, N::RDFTEST.Type4 => { N::RDFTEST.Type3 => {}}}, hierarchy)
+    assert_equal({N::RDFTEST.Type1 => { N::RDFTEST.Type2 => {}, N::RDFTEST.Type3 => {} }, N::RDFTEST.Type4 => { N::RDFTEST.Type3 => {}}, N::RDFS.Class => {}}, hierarchy)
   end
   
   def test_used_subclass_hierarchy
-    hierarchy = N::SourceClass.used_subclass_hierarchy
-    assert_equal({N::RDFTEST.Type1 => { N::RDFTEST.Type2 => {}}}, hierarchy)
+    hierarchy = N::SourceClass.subclass_hierarchy { |t|  t.used? }
+    assert_equal({N::RDFTEST.Type1 => { N::RDFTEST.Type2 => {}}, N::RDFS.Class => {}}, hierarchy)
   end
   
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: semantic_naming
 version: !ruby/object:Gem::Version 
-  version: 2.0.6
+  version: 2.1.0
 platform: ruby
 authors: 
-  - Daniel Hahn
+- Daniel Hahn
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-11-26 00:00:00 +01:00
+date: 2009-12-11 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -20,35 +20,37 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-  - README.rdoc
+- README.rdoc
 files: 
-  - lib/semantic_naming.rb
-  - lib/semantic_naming/default_namespaces.rb
-  - lib/semantic_naming/namespace.rb
-  - lib/semantic_naming/predicate.rb
-  - lib/semantic_naming/source_class.rb
-  - lib/semantic_naming/uri.rb
-  - README.rdoc
+- lib/ontology_graph/class_node.rb
+- lib/ontology_graph/graph.rb
+- lib/semantic_naming.rb
+- lib/semantic_naming/default_namespaces.rb
+- lib/semantic_naming/namespace.rb
+- lib/semantic_naming/predicate.rb
+- lib/semantic_naming/source_class.rb
+- lib/semantic_naming/uri.rb
+- README.rdoc
 has_rdoc: true
 homepage: http://talia.discovery-project.eu/
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-  - --charset=UTF-8
+- --charset=UTF-8
 require_paths: 
-  - lib
+- lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
   version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
   version: 
 requirements: []
 
@@ -58,7 +60,9 @@ signing_key:
 specification_version: 3
 summary: Semantic Naming Extensions for ActiveRDF, Talia and others
 test_files: 
-  - test/namespace_test.rb
-  - test/predicate_test.rb
-  - test/source_class_test.rb
-  - test/uri_test.rb
+- test/class_node_test.rb
+- test/graph_test.rb
+- test/namespace_test.rb
+- test/predicate_test.rb
+- test/source_class_test.rb
+- test/uri_test.rb