semantic_naming 2.0.0

data/README.rdoc

@@ -0,0 +1,3 @@
+= SemanticNaming
+
+Semantic URL handling that can be used with the Talia system or ActiveRDF

data/lib/semantic_naming/default_namespaces.rb

@@ -0,0 +1,10 @@
+module N
+  class Namespace < N::URI
+    @@default_namespaces = {
+      'rdf' => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+      'xsd' => "http://www.w3.org/2001/XMLSchema#",
+      'rdfs' => "http://www.w3.org/2000/01/rdf-schema#",
+      'owl' => "http://www.w3.org/2002/07/owl#"
+    }
+  end
+end

data/lib/semantic_naming/namespace.rb

@@ -0,0 +1,33 @@
+module N
+  # This is for URIs that act as namespaces. A namespace
+  # is a "prefix" for URIs.
+  #
+  # Shortcuts for some default namespaces are automatically defined (rdf, owl,
+  # ...). See default_namespaces.rb for details. 
+  # 
+  # Usually there should be no need to change those default namespaces
+  class Namespace < N::URI
+    
+    @@default_namespaces.each do |shortcut, uri|
+      Namespace.shortcut(shortcut, uri)
+    end
+    
+    # Finds all members of the given type that are part of this namespace. 
+    # *Attention*: Due to the workings of SPARQL this will retrieve *all*
+    # elements that match the type and filter them. Thus it's advised to
+    # use this only for types of which only a few elements are known to exist
+    # (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) }
+    end
+    
+    # Returns a list of predicate names.
+    def predicates
+      elements_with_type(N::RDF.Property, N::Predicate).map { |p| p.local_name }
+    end
+  end
+end

data/lib/semantic_naming/predicate.rb

@@ -0,0 +1,6 @@
+module N
+  # This is the type of URI that represents a type of predicate
+  # (or relation, or property)
+  class Predicate < URI
+  end
+end

data/lib/semantic_naming/source_class.rb

@@ -0,0 +1,44 @@
+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.
+  class SourceClass < URI
+    
+    # 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) }
+    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) }
+    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) }
+    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) }
+    end
+    
+  end
+end

data/lib/semantic_naming/uri.rb

@@ -0,0 +1,306 @@
+require 'active_rdf'
+module N
+  
+  # This class contains basic functionality for URIs
+  class URI
+  
+    # Should behave like an ActiveRDF resource
+    include RDFS::ResourceLike
+    
+    # Contains the registered uris
+    @@registered_uris = Hash.new
+    
+    # Contains an inverse hash to lookup the shortcuts by uir
+    @@inverse_register = Hash.new
+    
+    # Regexp that can match the part up until last # or / character,
+    # and the part behind that (domain, localname)
+    @@domainsplit_re = Regexp.compile("(.*[/#])([^/#]*)$")
+    
+    # Match the language part in labels
+    @@lang_re = /(.*)@(.+)$/
+  
+    # make some builtin methods private because lookup doesn't work otherwise 
+    # on e.g. RDF::type and FOAF::name
+    [:type, :id].each {|m| private(m) }
+  
+    # Create a new URI
+    def initialize(uri_s)
+      uri_s = uri_s.to_s
+      # TODO: More checking
+      @uri_s = uri_s
+    end
+    
+    # Compare operator
+    def ==(object)
+      return true if eql?(object)
+      return object == @uri_s if(object.kind_of?(String))
+      return false
+    end
+    
+    # eql? compare operator
+    def eql?(object)
+      return object.to_s == @uri_s if(object.kind_of?(URI))
+      return false
+    end
+    
+    # Returns a hash
+    def hash
+      @uri_s.hash
+    end
+    
+    # Add operator
+    def +(uri)
+      new_s = @uri_s + uri.to_s
+      return URI.new(new_s)
+    end
+    
+    # Checks if the current URI is local
+    def local?
+      N::LOCAL.domain_of?(self)
+    end
+    
+    # Redirect for checking if this is remote
+    def remote?
+      !local?
+    end
+    
+    # String representation is the uri itself
+    def to_s
+      @uri_s
+    end
+    
+    # Same for YAML
+    def to_yaml
+      @uri_s
+    end
+    
+    # Alias "uri" for compatibility with ActiveRDF
+    alias_method :uri, :to_s
+    
+    # Get a string representation in the form of 'namespace:name'. It is 
+    # possible to select a different separator from ':'
+    def to_name_s(separator = ':')
+      "#{namespace}#{separator}#{local_name}"
+    end
+    
+    # This creates a helpers for a nice notation of
+    # like my_domain::myid
+    def const_missing(klass)
+      return URI.new(@uri_s + klass.to_s)
+    end
+    
+    # See const_missing
+    def method_missing(method, *args)
+      # Quick sanity check: args make no sense for this
+      raise(NoMethodError, "Undefined method: " + method.to_s) if(args && args.size > 0)    
+      
+      return URI.new(@uri_s + method.to_s)
+    end
+    
+    # Is true if this object describes the domain of the
+    # given uri, and the given uri is a resource in that
+    # domain
+    def domain_of?(uri)
+      uri_s = uri.to_s
+      
+      (uri_s =~ /\A#{@uri_s}\w*/) != nil
+    end
+    
+    # Request URI by shortcut. If called on a sublass, this accessor
+    # will only return an URI if it's of the same type as the subclass.
+    def self.[](shortcut)
+      shortcut = shortcut.to_s.downcase.to_sym
+      
+      uri = @@registered_uris[shortcut]
+      
+      # We only return the uri if it's of the same kind as ourselves
+      uri.kind_of?(self) ? uri : nil 
+    end
+    
+    # Returns a hash with all registered shortcuts.
+    # This will only return the shortcuts of the same class (and subclasses)
+    # than the one on which the method is called
+    def self.shortcuts
+      shortcuts = {}
+      @@registered_uris.each do |key, value|
+        shortcuts[key] = value if(value.kind_of?(self))
+      end
+      
+      shortcuts
+    end
+    
+    # Check if a shortcut is registered
+    def self.shortcut_exists?(shortcut)
+      @@registered_uris[shortcut.to_s.downcase.to_sym] != nil
+    end
+    
+    # Get an URI string from the given string in ns:name notation
+    def self.make_uri(str, separator = ":", default_namespace = N::LOCAL)
+      type = str.split(separator)
+      type = [type[1]] if(type[0] == "")
+      if(type.size == 2)
+        self.new(N::URI[type[0]] + type[1])
+      else
+        default_namespace + type[0]
+      end
+    end
+    
+    # Returns the local name
+    def local_name
+      localname = nil
+      
+      if(md = @@domainsplit_re.match(@uri_s))
+        localname = md[2]
+      end
+      
+      localname
+    end
+    
+    # Returns the domain part of the URI
+    def domain_part
+      domainpart = nil
+      
+      if(md = @@domainsplit_re.match(@uri_s))
+        domainpart = md[1]
+      end
+      
+      domainpart ? URI.new(domainpart) : nil
+    end
+    
+    # Returns the shortcut for the current URI, or nil
+    # if no shortcut is defined for this URI
+    def my_shortcut
+      @@inverse_register[@uri_s]
+    end
+    
+    # Returns the namespace of this URI, if the URI
+    # is part of a namespace. The rule is quite strict:
+    # The URI is only part of the namespace if it is the
+    # namespace itself or the namespace plus a single local part
+    # 
+    # If the URI is not part of a namespace, nil is returned
+    def namespace
+      nspace = nil
+      
+      domain_shortcut = domain_part.my_shortcut
+      
+      if(domain_shortcut && URI[domain_shortcut].is_a?(Namespace))
+        nspace = domain_shortcut
+      end
+      
+      nspace
+    end
+    
+    # Register a shortcut to the given URI. You may force to overwrite an 
+    # existing shortcut, but this is not recommended. The option exists practically
+    # only to override default namespaces if there is a need.
+    def self.shortcut(shortcut, uri, force = false)
+      shortcut = shortcut.to_s.downcase.to_sym
+      constant = shortcut.to_s.upcase.to_sym
+      
+      # make an object of my own type
+      uri = self.new(uri)
+      
+      if(!force && (@@registered_uris[shortcut] || N.const_defined?(constant)))
+        raise(NameError, "Shortcut already defined: '#{shortcut.to_s}'")
+      end
+      
+      if(!force && (@@inverse_register[uri.to_s]))
+        raise(NameError, "Shortcut for this uri already exists: #{uri.to_s}")
+      end
+      
+      @@registered_uris[shortcut] = uri
+      @@inverse_register[uri.to_s] = shortcut
+      N.const_set(constant, uri)
+      
+      return uri
+    end
+    
+    # Check if a given string is an URI
+    def self.is_uri?(uri_str)
+      uri_str =~ /:/
+    end
+    
+    # If the RDF store is active and the class has an rdfs:label, this will be
+    # returned. Otherwise, this will return the short name of the current source
+    # (like ns:name)
+    # 
+    # You may give a language, if none is given 'en' is used by default. If
+    # no label with a language marker is found, the first none-language-label
+    # is used
+    def rdf_label(language = 'en')
+      @labels ||= {}
+      @labels[language] ||= label_by_lang(rdfs_labels, language)
+      # The rdf label is cache, while the default may change
+      @labels[language] ||= to_name_s
+      @labels[language]
+    end
+    
+    private
+    
+    # Check if the ActiveRDF library is present.
+    def self.active_rdf?
+      unless(defined?(@active_rdf))
+        @active_rdf = defined?(::ConnectionPool) &&  (::ConnectionPool.read_adapters.size > 0)
+      end
+      
+      @active_rdf
+    end
+    
+    # See the respective class method
+    def is_iri?
+      self.class.is_iri?(@uri_s)
+    end
+    
+    # Checks if the current URI is a valid IRI (special for of URI defined
+    # in the SPARQL spec). URIs that are not IRIs may cause problems with
+    # SPARQL queries.
+    def self.is_iri?(string)
+      (string =~ /[{}|\\^`\s]/) == nil
+    end
+    
+    # RDF check, this is a convenience for instances
+    def active_rdf?
+      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]
+        if(labels && labels.size > 0)
+          labels
+        end # else nil
+      end # else nil
+    end
+    
+    # Gets the label for the given language. If no labels are given, return nil
+    def label_by_lang(labels, language = 'en')
+      return nil unless(labels)
+      result = nil
+      labels.each do |label|
+        if(match = @@lang_re.match(label)) # check if there is a "language" string
+          if(match[2] == language)
+            return match[1] # We've found one, break here and return the label part
+          end
+        else
+          result ||= label # Keep the non-language label
+        end
+      end
+      
+      result
+    end
+    
+  end
+end

data/lib/semantic_naming.rb

@@ -0,0 +1,13 @@
+# SemanticNaming loader
+
+# adding semantic_naming subdirectory to the ruby loadpath
+file = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
+this_dir = File.dirname(File.expand_path(file))
+$: << this_dir
+$: << this_dir + '/semantic_naming/'
+
+require 'semantic_naming/uri'
+require 'semantic_naming/default_namespaces'
+require 'semantic_naming/namespace'
+require 'semantic_naming/source_class'
+require 'semantic_naming/predicate'

data/test/namespace_test.rb

@@ -0,0 +1,55 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/test_helper'
+  
+# Test the namespace functionality
+class NamespaceTest < Test::Unit::TestCase
+  # Tests the basic registering of namespaces
+  def test_shortcut
+    new_ns = N::Namespace.shortcut(:ns_short, "http://www.ns_short.com/")
+    assert_equal(new_ns, N::NS_SHORT);
+    assert_equal(new_ns.to_s, "http://www.ns_short.com/")
+    assert_equal(new_ns, N::URI.new("http://www.ns_short.com/"))
+    assert_kind_of(N::Namespace, new_ns)
+    assert_kind_of(N::Namespace, N::NS_SHORT)
+    assert_raise(NameError) { N::Namespace.shortcut(:ns_short, "http://www.ns_short.com/") }
+  end
+  
+  # Test if the "shortcuts" method works correctly for namespaces
+  def test_shortcuts
+    N::Namespace.shortcut(:at_least_one_ns, "http://atleast_namespace.com/")
+    N::URI.shortcut(:another_one_outside_uri, "http://anotherone_uri.com/")
+    assert(N::Namespace.shortcuts.size > 0, "There should be at least one namespace shortcut")
+    assert(!N::Namespace.shortcuts.include?(:another_one_outside))
+  end
+  
+  # Test the array-type accessor
+  def test_array_type_access
+    new_ns = N::Namespace.shortcut(:ns_array_test, "http://www.ns_array_test.com/")
+    assert_equal(new_ns, N::Namespace[:ns_array_test])
+  end
+  
+  # Test the array-type accessor if the superclass is excluded
+  def test_array_type_access_super
+    N::URI.shortcut(:ns_array_test_s, "http://www.ns_array_test_super.com/")
+    assert_equal(nil, N::Namespace[:ns_array_test_s])
+  end
+  
+  # Test the array-type accessor if sibling classes are excluded
+  def test_array_type_access_sibling
+    N::SourceClass.shortcut(:ns_array_test_sib, "http://www.ns_array_test_sibling.com/")
+    assert_equal(nil, N::Namespace[:ns_array_test_sib])
+  end
+  
+  # Test getting elements by type
+  def test_elements_by_type
+    return unless(RDF_ACTIVE)
+    namespace = N::Namespace.new(N::RDFTEST)
+    elements = namespace.elements_with_type(N::RDFTEST.Type1).collect { |type| type.uri.to_s }
+    assert_equal([N::RDFTEST.test1.to_s, N::RDFTEST.test2.to_s].sort, elements.sort)
+  end
+  
+  def _ignore_test_predicates
+    assert_kind_of(Array, N::RDF.predicates) unless RDF_ACTIVE
+  end
+end
+  

data/test/predicate_test.rb

@@ -0,0 +1,21 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/test_helper'
+  
+# Test the namespace functionality
+class PredicateTest < Test::Unit::TestCase
+  include N
+  def setup
+    @uri = "http://www.predicate_shortcut.com/"
+  end
+  
+  # Tests the basic registering of namespaces
+  def test_shortcut
+    new_pr = Predicate.shortcut(:newpr, @uri)
+    assert_equal(new_pr, NEWPR);
+    assert_equal(new_pr.to_s, @uri)
+    assert_equal(new_pr, URI.new(@uri))
+    assert_kind_of(Predicate, new_pr)
+    assert_kind_of(Predicate, NEWPR)
+    assert_raise(NameError) { Namespace.shortcut(:newpr, @uri) }
+  end  
+end

data/test/source_class_test.rb

@@ -0,0 +1,46 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/test_helper'
+
+  
+# Test the uri class
+class TypeTest < Test::Unit::TestCase
+  
+  # Tests the basic registering of namespaces
+  def test_shortcut
+    new_sc = N::SourceClass.shortcut(:newsc, "http://www.source_shortcut.com/")
+    assert_equal(new_sc, N::NEWSC);
+    assert_equal(new_sc.to_s, "http://www.source_shortcut.com/")
+    assert_equal(new_sc, N::URI.new("http://www.source_shortcut.com/"))
+    assert_kind_of(N::SourceClass, new_sc)
+    assert_kind_of(N::SourceClass, N::NEWSC)
+    assert_raise(NameError) { N::Namespace.shortcut(:newsc, "http://www.source_shortcut.com/") }
+  end
+  
+  # Test the supertypes method
+  def test_supertypes
+    return unless(RDF_ACTIVE)
+    src = N::SourceClass.new(N::RDFTEST.Type1)
+    subtypes = src.subtypes.collect { |type| type.uri.to_s }
+    assert_equal([N::RDFTEST.Type2.to_s, N::RDFTEST.Type3.to_s].sort, subtypes.sort)
+  end
+  
+  def test_subtypes
+    return unless(RDF_ACTIVE)
+    src = N::SourceClass.new(N::RDFTEST.Type3)
+    supertypes = src.supertypes.collect { |type| type.uri.to_s }
+    assert_equal([N::RDFTEST.Type1.to_s, N::RDFTEST.Type4.to_s].sort, supertypes.sort)
+  end
+  
+  def test_instances
+    return unless(RDF_ACTIVE)
+    src = N::SourceClass.new(N::RDFTEST.Type1)
+    instances = src.instances(N::URI).collect { |type| type.uri.to_s }
+    assert_equal([N::RDFTEST.test1.to_s, N::RDFTEST.test2.to_s, N::RDFTEST2.test1.to_s, N::RDFTEST2.test2.to_s].sort, instances.sort)
+  end
+  
+  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)
+  end
+end

data/test/uri_test.rb

@@ -0,0 +1,225 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/test_helper'
+# Test the uri class
+class URITest < Test::Unit::TestCase
+  
+  @@local_domain = "http://www.samplething.com/"
+  if(!N.const_defined?(:LOCAL))
+    N::Namespace.shortcut(:local, @@local_domain)
+  end
+  
+  # Basic test for uri class
+  def test_uri
+    uri_string = "http://foobar.com/xyz/"
+    uri = N::URI.new(uri_string)
+    assert_equal(uri_string, uri.to_s)
+  end
+  
+  # Test local and remote checks
+  def test_local_remote
+    local_string = @@local_domain + "/myid"
+    remote_string = "http://www.remote.com/something"
+    
+    
+    domain = N::URI.new(@@local_domain)
+    local = N::URI.new(local_string)
+    remote = N::URI.new(remote_string)
+    
+    assert(local.local?)
+    assert(!local.remote?)
+    assert(remote.remote?)
+    assert(!remote.local?)
+    assert(domain.local?)
+  end
+  
+  # Tests the equality operator
+  def test_equality
+   uri_string = "http://foobar.com/xyz/"
+   uri = N::URI.new(uri_string)
+   uri_2 = N::URI.new(uri_string)
+   uri_other = N::URI.new("http://otheruri.com/")
+   
+   assert_equal(uri, uri_string)
+   assert_equal(uri, uri)
+   assert_equal(uri, uri_2)
+   assert_not_equal("http://something.org", uri)
+   assert_not_equal(uri, uri_other)
+   assert_not_equal(uri, Hash.new)
+  end
+  
+  # Tests the domain_of operation
+  def test_domain_of
+    local_string = @@local_domain + "/myid"
+    remote_string = "http://www.remote.com/something"
+    
+    local_domain = N::URI.new(@@local_domain)
+    local = N::URI.new(local_string)
+    remote = N::URI.new(remote_string)
+    
+    assert(local.domain_of?(local))
+    assert(local.domain_of?(local_string))
+    assert(local_domain.domain_of?(local))
+    assert(local_domain.domain_of?(local_string))
+    
+    assert(!local.domain_of?(local_domain))
+    assert(!local.domain_of?(remote))
+    assert(!local.domain_of?(remote_string))
+    assert(!remote.domain_of?(local))
+  end
+  
+  # Test the add operator
+  def test_add
+    uri_string = "http://foobar.com/xyz/"
+    uri = N::URI.new(uri_string)
+    assert_equal(N::URI.new(uri_string + "add"), uri + "add")
+    assert_equal(N::URI.new(uri_string +  "add"), uri + N::URI.new("add"))
+  end
+  
+  # Test if builtin methods were overwritten
+  def test_builtin_overwrite
+    domain = N::URI.new(@@local_domain)
+    assert_kind_of(N::URI, domain::type)
+    assert_equal(@@local_domain + "type", domain.type.to_s)
+  end
+  
+  # Test the easy accessors
+  def test_easy_accessors
+    domain = N::URI.new(@@local_domain)
+    assert_equal(@@local_domain + "foo", (domain.foo).to_s)
+    assert_equal(@@local_domain + "foo", (domain::foo).to_s)
+    assert_equal(@@local_domain + "FoO", (domain.FoO).to_s)
+    assert_raise(NoMethodError) { domain.foo(12) }
+  end
+  
+  # Test registering of shortcuts
+  def test_shortcut_register
+    uri = N::URI.new("http://foo.foo.com/")
+    N::URI.shortcut(:foo, uri.to_s)
+    assert_equal(N::FOO, uri)
+    assert_kind_of(N::URI, N::FOO)
+  end
+  
+  # Test the shortcuts method
+  def test_shortcuts
+    N::URI.shortcut(:at_least_one, "http://atleast.com")
+    N::URI.shortcut(:at_least_two, "http://atleasttwo.com")
+    assert(N::URI.shortcuts.size > 1, "There should be at least two shortcuts")
+    assert(N::URI.shortcuts.keys.include?(:at_least_one))
+    assert(N::URI.shortcuts.keys.include?(:at_least_two))
+  end
+  
+  # Test if the assignment of illegal shortcuts fails correctly
+  def test_illegal_shortcuts
+    N::URI.shortcut(:illegal_short, "http://illegal.shortcut.com/")
+    assert_raises(NameError) { N::URI.shortcut(:illegal_short, "xxx") }
+    assert_raises(NameError) { N::URI.shortcut(:legal_short, "http://illegal.shortcut.com/")}
+  end
+  
+  # Checks if nonexistent/illegal shortcuts fail correctly
+  def test_nonexistent_shortcut 
+    assert_raises(NameError) { N::Foo }
+  end
+  
+  # Tests the array-type accessor
+  def test_shortcut_accessor
+    assert_equal(N::LOCAL, N::URI[:local])
+  end
+  
+  # Test array-type accessor with subclass
+  def test_shortcut_accessor_subclass
+    namesp = N::Namespace.shortcut(:uri_array_ns_short, "http://test_shortcut_accessor_subclass/")
+    assert_equal(namesp, N::URI[:uri_array_ns_short])
+  end
+  
+  # Test the is_uri? convenience method
+  def test_is_uri
+    assert(N::URI.is_uri?("http://foobar.org/"))
+    assert(N::URI.is_uri?("http://foobar.org/"))
+    assert(N::URI.is_uri?("baa:boo"))
+    assert(!N::URI.is_uri?("foo"))
+  end
+  
+  # Try to get the shortcut from a URL
+  def test_check_shortcut
+    N::Namespace.shortcut(:xyshortcut, "http://xyz/")
+    assert_equal(:xyshortcut, N::URI.new("http://xyz/").my_shortcut)
+  end
+  
+  # Try to get inexistent shortcut from a URL
+  def test_inexistent_shortcut
+    assert_equal(nil, N::URI.new("http://noshortcut/").my_shortcut)
+  end
+  
+  # Try to get the local name of an uri
+  def test_local_name
+    assert_equal("master", N::URI.new("http://somethingelse.com/master").local_name)
+    assert_equal("slave", N::URI.new("http://somethingelse.com/master#slave").local_name)
+    assert_equal("chicken", N::URI.new("http://somethingelse.com/animals/chicken").local_name)
+  end
+  
+  # Special case for local name
+  def test_only_local_name
+    assert_equal(nil, N::URI.new("file:thingy").local_name)
+  end
+  
+  # Only domain, no local
+  def test_inexistent_local_name
+    assert_equal("", N::URI.new("http://somethingelse.com/").local_name)
+  end
+  
+  # Try to get the path name of an uri
+  def test_domain_part
+    assert_kind_of(N::URI, N::URI.new("http://somethingelse.com/foobar/bla/").domain_part)
+    assert_equal("http://somethingelse.com/foobar/bla/", N::URI.new("http://somethingelse.com/foobar/bla/").domain_part.to_s)
+    assert_equal("http://somethingelse.com/foobar/bla/", N::URI.new("http://somethingelse.com/foobar/bla/thing").domain_part.to_s)
+    assert_equal("http://somethingelse.com/foobar/bla#", N::URI.new("http://somethingelse.com/foobar/bla#thong").domain_part.to_s)
+  end
+  
+  # Test special URI with no domain
+  def test_no_domain
+    assert_equal(nil, N::URI.new("file:thingy").domain_part)
+  end
+  
+  # Try to get the namspace of an uri
+  def test_namespace
+    N::Namespace.shortcut(:test_namespace, "http://test_namespace/")
+    assert_equal(:test_namespace, N::URI.new("http://test_namespace/").namespace)
+    assert_equal(:test_namespace, N::URI.new("http://test_namespace/else").namespace)
+    assert_equal(nil, N::URI.new("http://test_namespace/else/other").namespace)
+  end
+  
+  # No namespace
+  def test_namespace_inexistent
+    assert_equal(nil, N::URI.new("http://unrelated").namespace)
+  end
+  
+  # Test make_uri
+  def test_make_uri
+    N::Namespace.shortcut(:makeuri, "http://test_makeuri/")
+    uri = N::URI.make_uri("makeuri:foo")
+    assert_equal("http://test_makeuri/foo", uri.to_s)
+  end
+  
+  # Test namespace with shortcut of wrong time
+  def test_not_defined_as_namespace
+    N::URI.shortcut(:not_namespace, "http://iamnotanamespace/")
+    assert_equal(nil, N::URI.new("http://iamnotanamespace/").namespace)
+  end
+  
+  # Test rdf label
+  def test_rdf_label
+    uri = N::URI.new(N::RDFTEST::test1)
+    if(RDF_ACTIVE)
+      assert_equal("Like a virgin", uri.rdf_label('it'))
+      assert_equal("come on", uri.rdf_label('en'))
+      assert_equal("come on", uri.rdf_label)
+    else
+      assert_equal("rdftest:test1", uri.rdf_label('it'))
+    end
+  end
+  
+  def test_hash
+    assert_equal(N::RDFTEST.testme.to_s.hash, N::RDFTEST.testme.hash)
+  end
+  
+end

metadata

@@ -0,0 +1,64 @@
+--- !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: []
+
+description: 
+email: hahn@netseven.it
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- 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
+has_rdoc: true
+homepage: http://talia.discovery-project.eu/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  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: 
+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