activerdf_net7 1.6.16 → 1.7.0

data/lib/active_rdf/objectmanager/literal.rb

@@ -1,71 +1,102 @@
 # require 'active_rdf'
 require 'time'
 
-module Literal
-  Namespace.register :xsd, 'http://www.w3.org/2001/XMLSchema#'
-  def xsd_type
-    case self
-    when String
-      XSD::string
-    when Integer
-      XSD::integer
-    when Float
-      XSD::double
-    when TrueClass, FalseClass
-      XSD::boolean
-    when DateTime, Date, Time
-      XSD::date
+module RDFS
+  module Literal
+    ActiveRDF::Namespace.register :xsd, 'http://www.w3.org/2001/XMLSchema#'
+
+    class << self
+      attr_accessor :class_uri
     end
-  end
 
-  def self.typed(value, type)
-    case type
-    when XSD::string
-      String.new(value)
-    when XSD::date
-      DateTime.parse(value)
-    when XSD::boolean
-      value == 'true' or value == 1
-    when XSD::integer
-      value.to_i
-    when XSD::double
-      value.to_f
+    # convert value to class type
+    def self.typed(value, type)
+      case type
+      when XSD::string
+        String.new(value)
+      when XSD::integer
+        value.to_i
+      when XSD::double
+        value.to_f
+      when XSD::boolean
+        value == 'true' or value == 1
+      when XSD::dateTime
+        DateTime.parse(value)
+      when XSD::time
+        Time.parse(value)
+      when XSD::date
+        Date.parse(value)
+      else
+        value
+      end
     end
-  end
 
-  def to_ntriple
-    if $activerdf_without_xsdtype
-      "\"#{to_s}\""
-    else
-      "\"#{to_s}\"^^#{xsd_type}"
+    def xsd_type
+      case self
+      when String
+        XSD::string
+      when Integer
+        XSD::integer
+      when Float
+        XSD::double
+      when TrueClass, FalseClass
+        XSD::boolean
+      when DateTime
+        XSD::dateTime
+      when Date
+        XSD::date
+      when Time
+        XSD::time
+      end
+    end
+    alias :datatype :xsd_type
+
+    def to_literal_s
+      s = kind_of?(Time) ? xmlschema : to_s
+      unless $activerdf_without_datatype
+        "\"#{s}\"^^<#{xsd_type}>"
+      else
+        "\"#{s}\""
+      end
     end
   end
+  Literal.class_uri = RDFS::Literal
 end
 
-class String; include Literal; end
-class Integer; include Literal; end
-class Float; include Literal; end
-class DateTime; include Literal; end
-class Date; include Literal; end
-class Time; include Literal; end
-class TrueClass; include Literal; end
-class FalseClass; include Literal; end
+class String; include RDFS::Literal; end
+class Integer; include RDFS::Literal; end
+class Float; include RDFS::Literal; end
+class DateTime; include RDFS::Literal; end
+class Date; include RDFS::Literal; end
+class Time; include RDFS::Literal; end
+class TrueClass; include RDFS::Literal; end
+class FalseClass; include RDFS::Literal; end
 
 class LocalizedString < String
-  include Literal
+  include RDFS::Literal
+
   attr_reader :lang
-  def initialize value, lang=nil
+  def initialize(value, lang)
     super(value)
-
-    @lang = lang
-    @lang = lang[1..-1] if @lang[0..0] == '@'
+    @lang = lang.sub(/^@/,'')
   end
 
-  def to_ntriple
-    if @lang
-      "\"#{to_s}\"@#@lang"
+  def ==(other)
+    if other.is_a?(LocalizedString)
+      super && @lang == other.lang
     else
       super
     end
   end
-end
+  alias_method :eql?, :==
+
+  def inspect
+    super + "@#@lang"
+  end
+
+  # returns quoted string with language type if present.
+  # xsd:string isn't appended when lang missing (xsd:string should be considered the default type)
+  def to_literal_s
+    $activerdf_without_datatype ? "\"#{self}\"" : "\"#{self}\"@#@lang"
+  end
+end

data/lib/active_rdf/objectmanager/namespace.rb

@@ -1,106 +1,139 @@
 # require 'active_rdf'
 
 # Manages namespace abbreviations and expansions
-
-class Namespace
-  @@namespaces = Hash.new
-  @@inverted_namespaces = Hash.new
-
-  # registers a namespace prefix and its associated expansion (full URI)
-  # e.g. :rdf and 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
-  def self.register(prefix, fullURI)
-		raise ActiveRdfError, 'prefix nor uri can be empty' if (prefix.to_s.empty? or fullURI.to_s.empty?)
-    # raise ActiveRdfError, "namespace uri should end with # or /" unless /\/|#/ =~ fullURI.to_s[-1..-1]
-		ActiveRdfLogger::log_info(self) { "Namespace: registering #{fullURI} to #{prefix}" }
-    @@namespaces[prefix.to_sym] = fullURI.to_s
-    @@inverted_namespaces[fullURI.to_s] = prefix.to_sym
-
-    # enable namespace lookups through FOAF::name
-    # if FOAF defined, add to it
-    if Object.const_defined?(prefix.to_s.upcase)
-      ns = Object.const_get(prefix.to_s.upcase)
-    else
-      # otherwise create a new module for it
-      ns = Module.new  
-      Object.const_set(prefix.to_s.upcase, ns)
-    end
-
-    # catch FOAF::name or all other lookups 
-    class << ns
-      def method_missing(method, *args)
-        Namespace.lookup(self.to_s.downcase.to_sym, method)
+module ActiveRDF
+  class Namespace
+    @@namespaces = Hash.new
+    @@inverted_namespaces = Hash.new
+
+    # registers a namespace prefix and its associated expansion (full URI)
+    # e.g. :rdf and 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
+    def Namespace.register(prefix, fullURI)
+      raise ActiveRdfError, 'prefix nor uri can be empty' if (prefix.to_s.empty? or fullURI.to_s.empty?)
+      raise ActiveRdfError, "namespace uri should end with # or /" unless /\/|#/ =~ fullURI.to_s[-1..-1]
+      klass_name = prefix.to_s.upcase
+      prefix = prefix.to_s.downcase.to_sym
+    ActiveRdfLogger::log_info(self) {  "Namespace: registering #{fullURI} to #{klass_name}" }
+      @@namespaces[prefix] = fullURI.to_s
+      @@inverted_namespaces[fullURI.to_s] = prefix
+
+      # enable namespace lookups through FOAF::name
+      # if FOAF defined, extend it
+      if Object.const_defined?(klass_name)
+        ns = Object.const_get(klass_name)
+      else
+        # otherwise create a new module for it
+        ns = Module.new
+        Object.const_set(klass_name, ns)
       end
+      ns.extend NamespaceProxy
+      ns.prefix = prefix
+      ns
+    end
 
-      def const_missing(klass)
-        ObjectManager.construct_class(Namespace.lookup(self.to_s.downcase.to_sym, klass))
-      end
+    # returns currently registered namespace abbreviations (e.g. :foaf, :rdf)
+    def Namespace.abbreviations
+      @@namespaces.keys
+    end
 
-      # make some builtin methods private because lookup doesn't work otherwise 
-      # on e.g. RDF::type and FOAF::name
-      [:type, :name, :id].each {|m| private(m) }
+    def Namespace.include?(name)
+      @@namespaces.keys.include?(name.to_s.downcase.to_sym)
     end
 
-    # return the namespace proxy object
-    ns
-  end
+    # like include?, but returns the key for the namespace
+    def Namespace.find(name)
+      name = name.to_s.downcase.to_sym
+      @@namespaces.keys.find{|k| k == name}
+    end
 
-  # returns a resource whose URI is formed by concatenation of prefix and localname
-  def self.lookup(prefix, localname, resource_type = RDFS::Resource)
-    resource_type.new(expand(prefix, localname))
-  end
+    # returns a resource whose URI is formed by concatenation of prefix and localname
+    def Namespace.lookup(prefix, localname)
+      RDFS::Resource.new(expand(prefix, localname))
+    end
 
-  # returns URI (string) formed by concatenation of prefix and localname
-  def self.expand(prefix, localname)
-    @@namespaces[prefix.to_sym].to_s + localname.to_s
-  end
+    # returns URI (string) formed by concatenation of prefix and localname
+    def Namespace.expand(prefix, localname)
+      prefix = prefix.downcase if prefix.is_a?String
+      prefix = prefix.to_sym
+      @@namespaces[prefix].to_s + localname.to_s if @@namespaces[prefix]
+    end
 
-  # returns prefix (if known) for the non-local part of the URI,
-  # or nil if prefix not registered
-  def self.prefix(resource)
-    # get string representation of resource uri
-    uri = if(resource.respond_to?(:uri))
-      resource.uri.to_s
-    else 
-      resource.to_s
+    # returns prefix (if known) for the non-local part of the URI,
+    # or nil if prefix not registered
+    def Namespace.prefix(obj)
+      uri = obj.respond_to?(:uri) ? obj.uri : obj.to_s
+      # uri.to_s gives us the uri of the resource (if resource given)
+      # then we find the last occurrence of # or / (heuristical namespace
+      # delimitor)
+      delimiter = uri.rindex(/#|\//)
+
+      # if delimiter not found, URI cannot be split into (non)local-part
+      return uri if delimiter.nil?
+
+      # extract non-local part (including delimiter)
+      nonlocal = uri[0..delimiter]
+      @@inverted_namespaces[nonlocal]
     end
 
-    # uri.to_s gives us the uri of the resource (if resource given)
-    # then we find the last occurrence of # or / (heuristical namespace
-    # delimitor)
-    delimiter = uri.rindex(/#|\//)
+    # returns local-part of URI
+    def Namespace.localname(obj)
+      uri = obj.respond_to?(:uri) ? obj.uri : obj.to_s
+      delimiter = uri.rindex(/#|\//)
+      if delimiter.nil? or delimiter == uri.size-1
+        uri
+      else
+        uri[delimiter+1..-1]
+      end
+    end
 
-    # if delimiter not found, URI cannot be split into (non)local-part
-    return uri if delimiter.nil?
+    # abbreviates resource if namespace is registered, otherwise returns nil
+    def Namespace.abbreviate(obj)
+      uri = obj.to_s
+      # uri.to_s gives us the uri of the resource (if resource given)
+      # then we find the last occurrence of # or / (heuristical namespace
+      # delimitor)
+      delimiter = uri.rindex(/#|\//)
+
+      if delimiter.nil? or delimiter == uri.size-1
+        abbr = @@inverted_namespaces[uri]
+        abbr.to_s if (abbr)
+      else
+        abbr = @@inverted_namespaces[uri[0..delimiter]]
+        abbr.to_s.upcase + "::" + uri[delimiter+1..-1] if (abbr)
+      end
+    end
+  end
 
-    # extract non-local part (including delimiter)
-    nonlocal = uri[0..delimiter]
+  module NamespaceProxy
+    attr_accessor :prefix, :klasses, :resources
 
-    @@inverted_namespaces[nonlocal]
-  end
+    def NamespaceProxy.extend_object(obj)
+      # make some builtin methods private because lookup doesn't work otherwise
+      # on e.g. RDF::type and FOAF::name
+      class << obj
+        [:type, :name, :id].each {|m| private(m) if respond_to?(m)}
+      end
+      super
+    end
 
-  # returns local-part of URI
-  def self.localname(resource)
-    # get string representation of resource uri
-    uri = if(resource.respond_to?(:uri))
-      resource.uri.to_s
-    else 
-      resource.to_s
+    # catch FOAF::name.
+    def method_missing(method, *args)
+      @resources ||={}  # resource cache
+      @resources[method] ||= Namespace.lookup(@prefix, method)
     end
 
-    delimiter = uri.rindex(/#|\//)
-    if delimiter.nil? or delimiter == uri.size-1
-      uri
-    else
-      uri[delimiter+1..-1]
+    # catch FOAF::Person
+    def const_missing(klass)
+    ActiveRdfLogger::log_info(self) { "Const missing on Namespace #{klass}" }
+      @klasses ||={}  # class cache
+      @klasses[klass] ||= ObjectManager.construct_class(Namespace.lookup(@prefix, klass))
     end
-  end
 
-	# returns currently registered namespace abbreviations (e.g. :foaf, :rdf)
-	def self.abbreviations
-		@@namespaces.keys
-	end
-end
+  end
 
-Namespace.register(:rdf, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#')
-Namespace.register(:rdfs, 'http://www.w3.org/2000/01/rdf-schema#')
-Namespace.register(:owl, 'http://www.w3.org/2002/07/owl#')
+  Namespace.register(:rdf, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#')
+  Namespace.register(:rdfs, 'http://www.w3.org/2000/01/rdf-schema#')
+  Namespace.register(:owl, 'http://www.w3.org/2002/07/owl#')
+  Namespace.register(:dc, 'http://purl.org/dc/elements/1.1/')
+  Namespace.register(:dcterms, 'http://purl.org/dc/terms/')
+end

data/lib/active_rdf/objectmanager/object_manager.rb

@@ -1,119 +1,124 @@
 # require 'active_rdf'
 
 # Constructs Ruby classes for RDFS classes (in the right namespace)
-
-class ObjectManager
-  # Constructs empty Ruby classes for all RDF types found in the data. Allows 
-  # users to invoke methods on classes (e.g. FOAF::Person) without
-  # getting symbol undefined errors (because e.g. foaf:person wasnt encountered
-  # before so no class was created for it)
-  def self.construct_classes
-    # find all rdf:types and construct class for each of them
-    #q = Query.new.select(:t).where(:s,Namespace.lookup(:rdf,:type),:t)
-
-    # find everything defined as rdfs:class or owl:class
-    type = Namespace.lookup(:rdf,:type)
-    rdfsklass = Namespace.lookup(:rdfs,:Class)
-
-    # TODO: we should not do this, we should not support OWL
-    # instead, owl:Class is defined as subclass-of rdfs:Class, so if the 
-    # reasoner has access to owl definition it should work out fine.
-    owlklass = Namespace.lookup(:owl,:Class)
-
-    klasses = []
-    klasses << Query.new.distinct(:s).where(:s,type,rdfsklass).execute
-    klasses << Query.new.distinct(:s).where(:s,type,owlklass).execute
-
-    # flattening to get rid of nested arrays
-    # compacting array to get rid of nil (if one of these queries returned nil)
-    klasses = klasses.flatten.compact
+module ActiveRDF
+  class ObjectManager
+    # Constructs empty Ruby classes for all RDF types found in the data. Allows
+    # users to invoke methods on classes (e.g. FOAF::Person) without
+    # getting symbol undefined errors (because e.g. foaf:person wasnt encountered
+    # before so no class was created for it)
+    def ObjectManager.construct_classes
+      # find all rdf:types and construct class for each of them
+      #q = Query.new.select(:t).where(:s,Namespace.lookup(:rdf,:type),:t)
+
+      # TODO: we should not do this, we should not support OWL
+      # instead, owl:Class is defined as subclass-of rdfs:Class, so if the
+      # reasoner has access to owl definition it should work out fine.
+      klasses = []
+      klasses << Query.new.distinct(:s).where(:s,RDF::type,RDFS::Class).execute
+      klasses << Query.new.distinct(:s).where(:s,RDF::type,OWL::Class).execute
+
+      # flattening to get rid of nested arrays
+      # compacting array to get rid of nil (if one of these queries returned nil)
+      klasses = klasses.flatten.compact
     ActiveRdfLogger::log_debug(self) { "Construct_classes: classes found: #{klasses}" }
 
-    # then we construct a Ruby class for each found rdfs:class
-    # and return the set of all constructed classes
-    klasses.collect { |t| construct_class(t) }
-  end
+      # then we construct a Ruby class for each found rdfs:class
+      # and return the set of all constructed classes
+      klasses.collect { |t| construct_class(t) }
+    end
 
-  # constructs Ruby class for the given resource (and puts it into the module as
-  # defined by the registered namespace abbreviations)
-  def self.construct_class(resource)
-    # get prefix abbreviation and localname from type
-    # e.g. :foaf and Person
-    localname = Namespace.localname(resource)
-    prefix = Namespace.prefix(resource)
-
-    # find (ruby-acceptable) names for the module and class
-    # e.g. FOAF and Person
-    if prefix.nil?
-      # if the prefix is unknown, we create our own from the full URI
-      modulename = create_module_name(resource)
+    # constructs Ruby class for the given resource (and puts it into the module as
+    # defined by the registered namespace abbreviations)
+    def ObjectManager.construct_class(class_or_resource_or_uri)
+      case class_or_resource_or_uri
+        when Class, Module
+          return class_or_resource_or_uri
+        when RDFS::Resource
+          resource = class_or_resource_or_uri
+        when String
+          resource = RDFS::Resource.new(class_or_resource_or_uri)
+        else raise ActiveRdfError, "ObjectManager: can't construct class from #{class_or_resource_or_uri.inspect}"
+      end
+
+      # get prefix abbreviation and localname from type
+      # e.g. :foaf and Person
+      localname = Namespace.localname(resource)
+      prefix = Namespace.prefix(resource)
+
+      # find (ruby-acceptable) names for the module and class
+      # e.g. FOAF and Person
+      if prefix.nil?
+        # if the prefix is unknown, we create our own from the full URI
+        modulename = create_module_name(resource)
       ActiveRdfLogger::log_debug(self) { "Construct_class: constructing modulename #{modulename} from URI #{resource}" }
-    else
-      # otherwise we convert the registered prefix into a module name
-      modulename = prefix_to_module(prefix)
+      else
+        # otherwise we convert the registered prefix into a module name
+        modulename = prefix_to_module(prefix)
       ActiveRdfLogger::log_debug(self) { "ObjectManager: construct_class: constructing modulename #{modulename} from registered prefix #{prefix}" }
-    end
-    klassname = localname_to_class(localname)
+      end
+      klassname = localname_to_class(localname)
 
-    # look whether module defined
-    # else: create it
-    _module = if Object.const_defined?(modulename.to_sym)
+      # look whether module defined
+      # else: create it
+      _module = if Object.const_defined?(modulename.to_sym)
       ActiveRdfLogger::log_debug(self) { "ObjectManager: construct_class: module name #{modulename} previously defined" }
-      Object.const_get(modulename.to_sym)
-    else
+          Object.const_get(modulename.to_sym)
+        else
       ActiveRdfLogger::log_debug(self) { "ObjectManager: construct_class: defining module name #{modulename} now" }
-      Object.const_set(modulename, Module.new)
-    end
+          Object.const_set(modulename, Module.new)
+        end
 
-    # look whether class defined in that module
-    if _module.const_defined?(klassname.to_sym)
+      # look whether class defined in that module
+      if _module.const_defined?(klassname.to_sym)
       ActiveRdfLogger::log_debug(self) { "ObjectManager: construct_class: given class #{klassname} defined in the module" }
-      # if so, return the existing class
-      _module.const_get(klassname.to_sym)
-    else
+        # if so, return the existing class
+        _module.const_get(klassname.to_sym)
+      else
       ActiveRdfLogger::log_debug(self) { "ObjectManager: construct_class: creating given class #{klassname}" }
-      # otherwise: create it, inside that module, as subclass of RDFS::Resource
-      # (using toplevel Class.new to prevent RDFS::Class.new from being called)
-      klass = _module.module_eval("#{klassname} = Object::Class.new(RDFS::Resource)")
-      klass.class_uri = resource
-      klass
+        # otherwise: create it, inside that module, as subclass of RDFS::Resource
+        # (using toplevel Class.new to prevent RDFS::Class.new from being called)
+        klass = _module.module_eval("#{klassname} = Object::Class.new(RDFS::Resource)")
+        klass.class_uri = resource
+        klass
+      end
     end
-  end
 
-  def self.prefix_to_module(prefix)
-    # TODO: remove illegal characters
-    prefix.to_s.upcase
-  end
+    def ObjectManager.prefix_to_module(prefix)
+      # TODO: remove illegal characters
+      prefix.to_s.upcase
+    end
 
-  def self.localname_to_class(localname)
-    # replace illegal characters inside the uri
-    # and capitalize the classname
-    replace_illegal_chars(localname).capitalize
-  end
+    def ObjectManager.localname_to_class(localname)
+      # replace illegal characters inside the uri
+      # and capitalize the classname
+      replace_illegal_chars(localname)
+    end
 
-  def self.create_module_name(resource)
-    # TODO: write unit test to verify replacement of all illegal characters
+    def ObjectManager.create_module_name(resource)
+      # TODO: write unit test to verify replacement of all illegal characters
 
-    # extract non-local part (including delimiter)
-    uri = resource.uri
-    delimiter = uri.rindex(/#|\//)
-    nonlocal = uri[0..delimiter]
+      # extract non-local part (including delimiter)
+      uri = resource.uri
+      delimiter = uri.rindex(/#|\//)
+      nonlocal = uri[0..delimiter]
 
-    # remove illegal characters appearing at the end of the uri (e.g. trailing 
-    # slash)
-    cleaned_non_local = nonlocal.gsub(/[^a-zA-Z0-9]+$/, '')
+      # remove illegal characters appearing at the end of the uri (e.g. trailing
+      # slash)
+      cleaned_non_local = nonlocal.gsub(/[^a-zA-Z0-9]+$/, '')
 
-    # replace illegal chars within the uri
-    replace_illegal_chars(cleaned_non_local).upcase
-  end
+      # replace illegal chars within the uri
+      replace_illegal_chars(cleaned_non_local).upcase
+    end
 
-  def self.replace_illegal_chars(name)
-    name.gsub(/[^a-zA-Z0-9]+/, '_')
-  end
+    def ObjectManager.replace_illegal_chars(name)
+      name.gsub(/[^a-zA-Z0-9]+/, '_')
+    end
 
-  #declare the class level methods as private with these directives
-  private_class_method :prefix_to_module
-  private_class_method :localname_to_class
-  private_class_method :create_module_name
-  private_class_method :replace_illegal_chars
-end
+    #declare the class level methods as private with these directives
+    private_class_method :prefix_to_module
+    private_class_method :localname_to_class
+    private_class_method :create_module_name
+    private_class_method :replace_illegal_chars
+  end
+end

data/lib/active_rdf/objectmanager/ordered_set.rb

@@ -98,7 +98,7 @@ class OrderedSet
   # execute query and return the result
   def query
     # execute query
-    result = Query.new.select(:p, :o).where(self.uri, :p, :o).filter('regex(str(?p), "^' + (RDF::_).uri + '")').execute
+    result = Query.new.select(:p, :o).where(self.uri, :p, :o).regex(:p, "^#{(RDF::_).uri}").execute
     
     # order result
     result = result.sort_by { |items| items[0] }