semantic_naming 2.0.0 → 2.0.1

data/README.rdoc

@@ -1,3 +1,9 @@
 = SemanticNaming
 
-Semantic URL handling that can be used with the Talia system or ActiveRDF
+Semantic URL handling that can be used with the Talia system or ActiveRDF. This contains
+a number of methods of encoding semantic URIs, dealing with namespaces and providing a 
+neat interface to access URIs.
+
+The library offers additional functionality when active_rdf is installed. Note that at this
+point in time you should use the 'activerdf_net7' gem, as it's tuned to work with the 
+semantic naming. The default activerdf gem *will* cause problems.

data/lib/semantic_naming/namespace.rb

@@ -19,10 +19,10 @@ module N
     # (e.g. Onotology classes)
     def elements_with_type(type, element_type = N::URI)
       return unless(rdf_active? && is_iri?)
-      qry = ::Query.new.distinct.select(:s)
-      qry.where(:s, make_res(RDF::type), make_res(type))
-      qry.filter_uri_regexp(:s, "^#{@uri_s}")
-      qry.execute.collect { |item| element_type.new(item.uri) }
+      qry = ::Query.new(element_type).distinct.select(:s)
+      qry.where(:s, RDF.type, type)
+      qry.filter_regexp(:s, "^#{@uri_s}")
+      qry.execute
     end
     
     # Returns a list of predicate names.

data/lib/semantic_naming/source_class.rb

@@ -8,36 +8,77 @@ module N
     # Get the supertype of this class
     def supertypes
       return nil unless(active_rdf? && is_iri?)
-      qry = Query.new.distinct.select(:o)
-      qry.where(make_res(@uri_s), make_res(RDFS::subClassOf), :o)
-      qry.where(:o, make_res(RDF::type), make_res(RDFS + 'Class'))
-      qry.execute.collect { |item| SourceClass.new(item.uri) }
+      qry = Query.new(SourceClass).distinct.select(:o)
+      qry.where(self, RDFS.subClassOf, :o)
+      qry.where(:o, RDF.type, RDFS.Class)
+      qry.execute
     end
     
     # Get the subtypes of this type
     def subtypes
       return nil unless(active_rdf? && is_iri?)
-      qry = Query.new.distinct.select(:s)
-      qry.where(:s, make_res(RDFS::subClassOf), make_res(@uri_s))
-      qry.where(:s, make_res(RDF::type), make_res(RDFS + 'Class'))
-      qry.execute.collect { |item| SourceClass.new(item.uri) }
+      qry = Query.new(SourceClass).distinct.select(:s)
+      qry.where(:s, RDFS.subClassOf, self)
+      qry.where(:s, RDF.type, RDFS.Class)
+      qry.execute
     end
     
     # Get the instances of this type. return_type will be the class used to 
     # create the objects that are returned.
     def instances(return_type)
       return nil unless(active_rdf? && is_iri?)
-      qry = Query.new.distinct.select(:s)
-      qry.where(:s, make_res(RDF::type.to_s), make_res(@uri_s))
-      qry.execute.collect { |item| return_type.new(item.uri) }
+      qry = Query.new(SourceClass).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.distinct.select(:s)
-      qry.where(:s, make_res(RDF::type), make_res(RDFS + 'Class'))
-      qry.execute.collect { |item| SourceClass.new(item.uri) }
+      qry = Query.new(SourceClass).distinct.select(:s)
+      qry.where(:s, RDF.type, RDFS.Class)
+      qry.execute
+    end
+    
+    # Return a subclass hierarchy. This is quicker than going through
+    # the hierarchy step by step. It will look at all subclass (*not*
+    # superclass!) relationships and return a nested, tree-like structure
+    # build of hashes. Each key in the hash will be the class object, and
+    # 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
+      hierarchy = {}
+      # Sift through the triples and add the sub-items
+      subtype_list.each do |sub_items|
+        klass, subklass = sub_items
+        hierarchy[klass] ||= {}
+        hierarchy[klass][subklass] = true
+      end
+      
+      # Now we link up the subclass relations
+      hierarchy.each do |key, values|
+        values.each_key do |subkey|
+          next if(subkey == :is_child)
+          hierarchy[subkey] ||= {}
+          values[subkey] = hierarchy[subkey]
+          values[subkey][:is_child] = true
+        end
+      end
+      
+      # Join with the general types and remove the children
+      types.each do |type|
+        xtype = (hierarchy[type] ||= {})
+        hierarchy.delete(type) if(xtype.delete(:is_child))
+      end
+      
+      hierarchy
     end
     
   end

data/lib/semantic_naming/uri.rb

@@ -1,4 +1,3 @@
-require 'active_rdf'
 module N
   
   # This class contains basic functionality for URIs
@@ -70,9 +69,9 @@ module N
       @uri_s
     end
     
-    # Same for YAML
+    # YAML representation is the uri string
     def to_yaml
-      @uri_s
+      self.to_s.to_yaml
     end
     
     # Alias "uri" for compatibility with ActiveRDF
@@ -140,7 +139,9 @@ module N
       type = str.split(separator)
       type = [type[1]] if(type[0] == "")
       if(type.size == 2)
-        self.new(N::URI[type[0]] + type[1])
+        namespace = N::URI[type[0]]
+        raise(ArgumentError, "Unknown namespace #{type[0]} for #{str}") unless(namespace)
+        self.new(namespace + type[1])
       else
         default_namespace + type[0]
       end
@@ -265,20 +266,10 @@ module N
       URI.active_rdf?
     end
     
-    # Create a resource from the given type
-    def self.make_res(type)
-      ::RDFS::Resource.new(type.to_s)
-    end
-    
-    # Instance convenience accessor
-    def make_res(type)
-      self.class.make_res(type)
-    end
-    
     # Gets the rdfs:labels from the rdf store
     def rdfs_labels
      if(active_rdf? && is_iri?)
-        labels = make_res(@uri_s)[(N::RDFS::label).to_s]
+        labels = Query.new(N::URI).distinct.select(:label).where(self, N::RDFS.label, :label).execute
         if(labels && labels.size > 0)
           labels
         end # else nil
@@ -302,5 +293,7 @@ module N
       result
     end
     
+
+    
   end
 end

data/lib/semantic_naming.rb

@@ -6,6 +6,13 @@ this_dir = File.dirname(File.expand_path(file))
 $: << this_dir
 $: << this_dir + '/semantic_naming/'
 
+require 'rubygems'
+begin
+  require 'active_rdf'
+rescue
+  puts "ActiveRDF not found"
+end
+
 require 'semantic_naming/uri'
 require 'semantic_naming/default_namespaces'
 require 'semantic_naming/namespace'

data/test/source_class_test.rb

@@ -43,4 +43,11 @@ class TypeTest < Test::Unit::TestCase
     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)
   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)
+  end
+  
+  
 end

metadata

@@ -1,26 +1,13 @@
 --- !ruby/object:Gem::Specification 
-name: semantic_naming
-version: !ruby/object:Gem::Version 
-  version: 2.0.0
-platform: ruby
-authors: 
-- Daniel Hahn
-autorequire: 
-bindir: bin
-cert_chain: []
-
-date: 2009-10-14 00:00:00 +02:00
-default_executable: 
-dependencies: []
+extensions: []
 
-description: 
-email: hahn@netseven.it
+homepage: http://talia.discovery-project.eu/
 executables: []
 
-extensions: []
-
-extra_rdoc_files: 
-- README.rdoc
+version: !ruby/object:Gem::Version 
+  version: 2.0.1
+post_install_message: 
+date: 2009-11-04 23:00:00 +00:00
 files: 
 - lib/semantic_naming.rb
 - lib/semantic_naming/default_namespaces.rb
@@ -29,36 +16,49 @@ files:
 - lib/semantic_naming/source_class.rb
 - lib/semantic_naming/uri.rb
 - README.rdoc
+rubygems_version: 1.3.5
+rdoc_options: 
+- --charset=UTF-8
+signing_key: 
+cert_chain: []
+
+name: semantic_naming
 has_rdoc: true
-homepage: http://talia.discovery-project.eu/
+platform: ruby
+summary: Semantic Naming Extensions for ActiveRDF, Talia and others
+default_executable: 
+bindir: bin
 licenses: []
 
-post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
-- lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  version: 
   requirements: 
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version 
       version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement 
   version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version 
       version: "0"
-  version: 
-requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.3.5
-signing_key: 
+require_paths: 
+- lib
 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
+dependencies: []
+
+description: 
+email: hahn@netseven.it
+authors: 
+- Daniel Hahn
+extra_rdoc_files: 
+- README.rdoc
+requirements: []
+
+rubyforge_project: 
+autorequire: