activerdf_net7 1.6.11

data/lib/active_rdf/federation/federation_manager.rb

@@ -0,0 +1,112 @@
+require 'federation/connection_pool'
+
+include ActiveRdfBenchmark
+
+# Manages the federation of datasources: distributes queries to right 
+# datasources and merges their results
+
+class FederationManager
+  # add triple s,p,o (context is optional) to the currently selected write-adapter
+  def FederationManager.add(s,p,o,c=nil)
+    benchmark("SPARQL/RDF", Logger::DEBUG) do |bench_message|
+      bench_message << "ADD #{s} - #{p} - #{o} : #{c}" if(bench_message)
+      # TODO: allow addition of full graphs
+      raise ActiveRdfError, "cannot write without a write-adapter" unless ConnectionPool.write_adapter
+      ConnectionPool.write_adapter.add(s,p,o,c)
+    end
+  end
+
+  # delete triple s,p,o (context is optional) to the currently selected write-adapter
+  def FederationManager.delete(s,p,o,c=nil)
+    benchmark("SPARQL/RDF", Logger::DEBUG) do |bench_message|
+      bench_message << "DELETE #{s} - #{p} - #{o} : #{c}" if(bench_message)
+      raise ActiveRdfError, "cannot write without a write-adapter" unless ConnectionPool.write_adapter
+      # transform wildcard symbols to nil (for the adaptors)
+      s = nil if s.is_a? Symbol
+      p = nil if p.is_a? Symbol
+      o = nil if o.is_a? Symbol
+      ConnectionPool.write_adapter.delete(s,p,o,c)
+    end
+  end
+
+  # delete every triples about a specified resource
+  def FederationManager.delete_all(resource)
+    delete(resource, nil, nil)
+  end
+  
+  # Clear the store (or the given context)
+  def FederationManager.clear(context=nil)
+    # FIXME: Make sure that all adapters support clearing
+    raise(RuntimeError, "Adapter #{ConnectionPool.write_adapter.class} doesn't support clear") unless(ConnectionPool.write_adapter.respond_to?(:clear))
+    ConnectionPool.write_adapter.clear(context)
+  end
+
+  # executes read-only queries
+  # by distributing query over complete read-pool
+  # and aggregating the results
+  def FederationManager.query(q, options={:flatten => true, :result_format => nil})
+    if ConnectionPool.read_adapters.empty?
+      raise ActiveRdfError, "cannot execute query without data sources" 
+    end
+
+    benchmark("SPARQL/RDF", Logger::DEBUG) do |bench_message|
+      # Only build the benchmark message if we need it
+      bench_message << ((q.class == String) ? q : q.to_sp) if(bench_message)
+      # ask each adapter for query results
+      # and yield them consequtively
+      if block_given?
+        ConnectionPool.read_adapters.each do |source|
+          source.query(q) do |*clauses|
+            yield(*clauses)
+          end
+        end
+      else
+        # build Array of results from all sources
+        # TODO: write test for sebastian's select problem
+        # (without distinct, should get duplicates, they
+        # were filtered out when doing results.union)
+        # FIXME: Calling get_sparql_query_results? This *only* exists on the redland adapter
+        results = []
+        ConnectionPool.read_adapters.each do |source|
+          if (q.class != String)
+            source_results = source.query(q)
+          else
+            source_results = source.get_sparql_query_results(q, RDFS::Resource, options[:result_format])
+          end
+          source_results.each do |clauses|
+            results << clauses
+          end
+        end
+
+        # filter the empty results
+        results.reject {|ary| ary.empty? }
+
+        # remove duplicate results from multiple
+        # adapters if asked for distinct query
+        # (adapters return only distinct results,
+        # but they cannot check duplicates against each other)
+        results.uniq! if ((q.class != String) && (q.distinct?))
+
+        # flatten results array if only one select clause
+        # to prevent unnecessarily nested array [[eyal],[renaud],...]
+        if (q.class != String)
+          results.flatten! if (q.select_clauses.size == 1 or q.ask?)
+        else
+          results.flatten! if q.scan(/[?]/).length == 2
+        end
+
+        # remove array (return single value or nil) if asked to
+        if options[:flatten] or ((q.class != String)  && (q.count?))
+          case results.size
+          when 0
+            results = nil
+          when 1
+            results = results.first
+          end
+        end
+      end
+
+      results
+    end # End benchmark
+  end # End query
+end

data/lib/active_rdf/instance_exec.rb

@@ -0,0 +1,13 @@
+module Kernel
+ # Like instace_eval but allows parameters to be passed.
+  def instance_exec(*args, &block)
+    mname = "__instance_exec_#{Thread.current.object_id.abs}_#{object_id.abs}"
+    Object.class_eval{ define_method(mname, &block) }
+    begin
+      ret = send(mname, *args)
+    ensure
+      Object.class_eval{ undef_method(mname) } rescue nil
+    end
+    ret
+  end
+end

data/lib/active_rdf/objectmanager/bnode.rb

@@ -0,0 +1,7 @@
+module RDFS
+  class BNode < Resource
+    def to_s
+      "<_:#{uri}>"
+    end
+  end
+end

data/lib/active_rdf/objectmanager/literal.rb

@@ -0,0 +1,71 @@
+# 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
+    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
+    end
+  end
+
+  def to_ntriple
+    if $activerdf_without_xsdtype
+      "\"#{to_s}\""
+    else
+      "\"#{to_s}\"^^#{xsd_type}"
+    end
+  end
+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 LocalizedString < String
+  include Literal
+  attr_reader :lang
+  def initialize value, lang=nil
+    super(value)
+
+    @lang = lang
+    @lang = lang[1..-1] if @lang[0..0] == '@'
+  end
+
+  def to_ntriple
+    if @lang
+      "\"#{to_s}\"@#@lang"
+    else
+      super
+    end
+  end
+end

data/lib/active_rdf/objectmanager/namespace.rb

@@ -0,0 +1,106 @@
+# 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)
+      end
+
+      def const_missing(klass)
+        ObjectManager.construct_class(Namespace.lookup(self.to_s.downcase.to_sym, klass))
+      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) }
+    end
+
+    # return the namespace proxy object
+    ns
+  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 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 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
+    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(/#|\//)
+
+    # 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
+
+  # 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
+    end
+
+    delimiter = uri.rindex(/#|\//)
+    if delimiter.nil? or delimiter == uri.size-1
+      uri
+    else
+      uri[delimiter+1..-1]
+    end
+  end
+
+	# returns currently registered namespace abbreviations (e.g. :foaf, :rdf)
+	def self.abbreviations
+		@@namespaces.keys
+	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#')

data/lib/active_rdf/objectmanager/object_manager.rb

@@ -0,0 +1,119 @@
+# 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
+    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
+
+  # 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)
+      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)
+      ActiveRdfLogger::log_debug(self) { "ObjectManager: construct_class: constructing modulename #{modulename} from registered prefix #{prefix}" }
+    end
+    klassname = localname_to_class(localname)
+
+    # 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
+      ActiveRdfLogger::log_debug(self) { "ObjectManager: construct_class: defining module name #{modulename} now" }
+      Object.const_set(modulename, Module.new)
+    end
+
+    # 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
+      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
+    end
+  end
+
+  def self.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 self.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]
+
+    # 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
+
+  def self.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

data/lib/active_rdf/objectmanager/ordered_set.rb

@@ -0,0 +1,116 @@
+# require 'active_rdf'
+require 'queryengine/query'
+require 'objectmanager/resource'
+
+class OrderedSet
+    
+  # the uri of current resource
+  attr_reader :uri
+    
+  # Initialize SeqContainer
+  def initialize(uri)
+    @uri = RDF::Seq.new uri
+  end
+  
+  # get all elements of Resource that match with 'rdf:_'
+  # 
+  # return value: Array
+  def elements
+    # execute query
+    query.collect { |predicate, object| object }
+  end
+  
+  # get element at position index
+  # *index: int
+  #
+  # return value: RDFS::Resource
+  def at(index)
+    # get predicate for next item
+    predicate =  index_to_predicate(index)
+    
+    # execute query
+    result = Query.new.select(:o).where(self.uri, predicate, :o).execute
+    
+    if (!(result.nil?) and (result.size > 0))
+      result.first
+    else
+      nil
+    end
+  end
+      
+  # return size of elements
+  #
+  # return value: int
+  def size
+    result = query
+    
+    if result.empty?
+      return 0
+    else
+      index = predicate_to_index result.last[0]
+      return index.to_i
+    end
+  end
+    
+  # add a new object
+  # * object: RDFS::Resource
+  def add(object)
+    # get predicate for next item
+    predicate =  index_to_predicate(size + 1)
+      
+    # add item
+    FederationManager.add(self.uri, predicate , object)
+  end
+    
+  # remove an existing object
+  # * index: int
+  def delete(index)
+    # get predicate to delete
+    predicate = index_to_predicate(index)
+    
+    # delete item
+    FederationManager.delete(self.uri, predicate, nil)
+  end
+    
+  # remove all copy of object to OrderedSet
+  def delete_all()
+    # call delete method
+    (1..size).each do |index|
+      self.delete(index)
+    end
+  end
+    
+  # replace item
+  # * index: int
+  # * object: RDFS::Resource
+  def replace(index, object)
+    # delete item
+    self.delete(index)
+      
+    # get predicate for index
+    predicate =  index_to_predicate(index)
+      
+    # add item
+    FederationManager.add(self.uri, predicate , object)
+  end
+    
+  private
+  # 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
+    
+    # order result
+    result = result.sort_by { |items| items[0] }
+  end
+
+  # return predicate from index
+  def index_to_predicate(index)
+    RDFS::Resource.new(RDF::_.uri + "#{index}")
+  end
+  
+  # return index of the predicate
+  def predicate_to_index(predicate)
+    predicate.uri.sub(RDF::_.uri, '')
+  end
+end