activerdf_net7 1.6.11

data/activerdf-yars/README

@@ -0,0 +1,10 @@
+== ActiveRDF YARS adapter
+This is the ActiveRDF adapter to the YARS and Jars2 RDF stores. 
+See http://www.activerdf.org/ for more information.
+
+== License
+This adapter is distributed under the LGPL license.
+
+== Authors
+* Eyal Oren
+

data/activerdf-yars/Rakefile

@@ -0,0 +1,38 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'tools/rakehelp'
+require 'fileutils'
+include FileUtils
+
+setup_tests
+setup_clean ["pkg", "lib/*.bundle", "*.gem", ".config"]
+
+setup_rdoc ['README', 'LICENSE', 'lib/**/*.rb', 'doc/**/*.rdoc']
+
+desc "Does a full compile, test run"
+task :default => [:test, :package]
+
+version="xx"
+name="activerdf_yars"
+
+setup_gem(name, version) do |spec|
+  spec.summary = "ActiveRDF adapter to YARS RDF store" 
+  spec.description = spec.summary
+  spec.author="Eyal Oren <eyal.oren@deri.org"
+  spec.add_dependency('gem_plugin', '>= 0.2.1')
+  spec.add_dependency('activerdf', '>= 0.9.2')
+end
+
+
+task :install => [:test, :package] do
+  sh %{sudo gem install pkg/#{name}-#{version}.gem}
+end
+
+task :uninstall => [:clean] do
+  sh %{sudo gem uninstall #{name}}
+end
+
+task :reinstall => [:uninstall, :install]

data/activerdf-yars/lib/activerdf_yars/init.rb

@@ -0,0 +1,10 @@
+# add the directory in which this file is located to the ruby loadpath
+file =
+if File.symlink?(__FILE__)
+  File.readlink(__FILE__)
+else
+  __FILE__
+end
+$: << File.dirname(File.expand_path(file))
+
+require 'jars2'

data/activerdf-yars/lib/activerdf_yars/jars2.rb

@@ -0,0 +1,119 @@
+# Author:: Eyal Oren
+# Copyright:: (c) 2005-2006
+# License:: LGPL
+
+# require 'active_rdf'
+require 'queryengine/query2jars2'
+require 'net/http'
+require 'cgi'
+
+# Read-only adapter to jars2
+# (experimental YARS branch for SWSE engine)
+class Jars2Adapter < ActiveRdfAdapter
+  ActiveRdfLogger::log_info "Loading Jars2 adapter", self
+  ConnectionPool.register_adapter(:jars2, self)
+
+  # initialises connection to jars2 datastore
+  # available parameters are:
+  # * :host (default 'm3pe.org')
+  # * :port (default 2020)
+  def initialize(params = {})
+    super()
+    @reads = true
+    @writes = false
+
+    @host = params[:host] || 'm3pe.org'
+    @port = params[:port] || 2020
+    ActiveRdfLogger::log_info(self) { "Initializing new instance with host: #{@host} port: #{@port}" }
+    @yars = Net::HTTP.new(@host, @port)
+  end
+
+  def translate query
+    Query2Jars2.translate(query)
+  end
+
+  # executes query on jars2 datastore
+  def query(query)
+    qs = Query2Jars2.translate(query)
+    header = { 'Accept' => 'application/rdf+n3' }
+
+    # querying Jars2, adding 'eyal' parameter to get all variable bindings in 
+    # the result
+    response = @yars.get("/?q=#{CGI.escape(qs)}&eyal", header)
+
+    ActiveRdfLogger::log_debug(self) { "Jars2Adapter: query executed: #{qs}" }
+
+    # return empty array if no content
+    return [] if response.is_a?(Net::HTTPNoContent)
+
+    # return false unless HTTP OK returned
+    return false unless response.is_a?(Net::HTTPOK)
+
+    # parse the result
+    results = parse_result(response.body, query)
+
+    # remove duplicates if asked for distinct results
+    if query.distinct?
+      final_results = results.uniq
+    else
+      final_results = results
+    end
+
+    ActiveRdfLogger::log_debug_pp "Query returned %s", final_results if ActiveRdfLogger::log_level == Logger::DEBUG
+    final_results
+  end
+
+  private
+  Resource = /<[^>]*>/
+  Literal = /"[^"]*"/
+  Node = Regexp.union(Resource,Literal)
+
+  # parses Jars2 results into array of ActiveRDF objects
+  def parse_result(response, query)
+    # Jars2 responses contain one result per line
+    results = response.split("\n")
+
+    # the first line of the response contains the variable bindings of the 
+    # results: we look at that line to figure out which column contains the 
+    # data we are looking for (which is the variables mentioned in the select 
+    # clauses of the query
+    bindings = results[0].split(' ')
+
+    # array of found answers, will be filled by iterating over the results and 
+    # only including the requested (i.e. selected) clauses
+    answers = []
+
+    # we iterate over the real results, and extract the clauses that we're 
+    # looking for (i.e. the select clauses from the query)
+    results[1..-1].each do |result|
+
+      # scan row for occurence of nodes (either resources or literals)
+      row = result.scan(Node)
+
+      # for each select clause, we find its index, and add the value at that 
+      # location in the result row to our answer
+      row = query.select_clauses.collect do |clause|
+        clause_index = bindings.index(clause)
+        convert_into_activerdf(row[clause_index], query.resource_class)
+      end
+      answers << row
+    end
+
+    answers
+  end
+
+  # converts ntriples serialisation of resource or literal into ActiveRDF object.
+  #
+  # resource_type is the class to be used for "resource" objects.
+  def convert_into_activerdf(string, resource_type)
+    case string
+    when /<(.*)>/
+      # <http://foaf/Person> is a resource
+      resource_type.new($1)
+    when /"(.*)"/
+      # "30" is a literal
+      # TODO: handle datatypes
+      String.new($1)
+    end
+  end
+end

data/lib/active_rdf.rb

@@ -0,0 +1,85 @@
+
+require 'rubygems'
+
+# ActiveRDF loader
+
+file = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
+this_dir = File.dirname(File.expand_path(file))  
+
+$: << this_dir + '/'
+$: << this_dir + '/active_rdf/'
+
+require 'active_rdf_helpers'
+require 'active_rdf_log'
+
+
+# load standard classes that need to be loaded at startup
+require 'objectmanager/resource_like'
+require 'objectmanager/resource'
+require 'objectmanager/bnode'
+require 'objectmanager/literal'
+require 'objectmanager/namespace'
+require 'federation/connection_pool'
+require 'queryengine/query'
+require 'federation/active_rdf_adapter'
+
+ActiveRdfLogger::log_info "ActiveRDF loaded, logging level: #{ActiveRdfLogger::logger.level}"
+
+def load_adapter s
+  begin
+    require s
+  rescue Exception => e
+    ActiveRdfLogger::log_info "Could not load adapter #{s}: #{e}"
+    #raise exception if the environment variable is specified
+    raise ActiveRdfError, "Could not load adapter #{s}: #{e}" unless ENV['ACTIVE_RDF_ADAPTERS'].nil?
+  end
+end
+
+
+# determine whether activerdf is installed as a gem:
+if Gem::cache.search(/^activerdf$/).empty?
+  # we are not running as a gem
+  ActiveRdfLogger::log_info 'ActiveRDF is NOT installed as a Gem', self
+  if ENV['ACTIVE_RDF_ADAPTERS'].nil?
+    if RUBY_PLATFORM =~ /java/
+      load_adapter this_dir + '/activerdf/activerdf-jena/lib/activerdf_jena/init'
+      load_adapter this_dir + '/activerdf/activerdf-sparql/lib/activerdf_sparql/sparql'
+      load_adapter this_dir + '/../activerdf-sesame/lib/activerdf_sesame/sesame'
+    else
+      load_adapter this_dir + '/../activerdf-rdflite/lib/activerdf_rdflite/rdflite'
+      load_adapter this_dir + '/../activerdf-rdflite/lib/activerdf_rdflite/fetching'
+      load_adapter this_dir + '/../activerdf-rdflite/lib/activerdf_rdflite/suggesting'
+      load_adapter this_dir + '/../activerdf-redland/lib/activerdf_redland/redland'
+      load_adapter this_dir + '/../activerdf-sparql/lib/activerdf_sparql/sparql'
+      #load_adapter this_dir + '/../activerdf-yars/lib/activerdf_yars/jars2'
+    end
+  else
+    #load specified adapters
+    #for example: ENV['ACTIVE_RDF_ADAPTERS'] = "redland,sparql"
+    ENV['ACTIVE_RDF_ADAPTERS'].split(",").uniq.each { |adapterItem|  
+      case adapterItem.strip.downcase 
+      when "rdflite"
+        load_adapter this_dir + '/../activerdf-rdflite/lib/activerdf_rdflite/rdflite'
+        load_adapter this_dir + '/../activerdf-rdflite/lib/activerdf_rdflite/fetching'
+        load_adapter this_dir + '/../activerdf-rdflite/lib/activerdf_rdflite/suggesting'
+      when "redland"
+        load_adapter this_dir + '/../activerdf-redland/lib/activerdf_redland/redland'
+      when "sparql"
+        load_adapter this_dir + '/../activerdf-sparql/lib/activerdf_sparql/sparql'
+      when "jars"
+        load_adapter this_dir + '/../activerdf-yars/lib/activerdf_yars/jars2'
+      when "sesame"
+        load_adapter this_dir + '/../activerdf-sesame/lib/activerdf_sesame/sesame'
+      else
+        ActiveRdfLogger::log_error "Unknown adapter #{name}"
+        raise ActiveRdfError, "Unknown adapter #{name}"
+      end
+    }
+  end
+else
+  # we are running as a gem
+  require 'gem_plugin'
+  ActiveRdfLogger::log_info 'ActiveRDF is installed as a Gem'
+  GemPlugin::Manager.instance.load "activerdf" => GemPlugin::INCLUDE
+end
+

data/lib/active_rdf/directaccess/direct_access.rb

@@ -0,0 +1,49 @@
+require 'active_rdf_helpers'
+
+
+# Direct access for Redland adapter
+# 
+# Syntax
+# "<http://......>" = Resource
+# "abc"             = Literal
+# "_:"              = Blank Node
+# "_:123"           = Blank Node with id
+class DirectAccess
+  
+  # Execute a SPARQL query. The second parameter specify the result format (:json, :xml, :array) (optional)
+  #
+  # The return default value is an Array.
+  # If you specify :xml or :json in result_format, the return value is a String that contain the request format.
+  # 
+  # Example: query("SELECT ?p ?o WHERE {<http://activerdf.org/test/eyal> ?p ?o}", :json)
+  def self.sparql_query(query, result_format=:array)
+    # verify input
+    if query.nil?
+      raise ActiveRdfError, "cannot execute empty query"
+    end
+    
+    # verify class type
+    if query.class != String
+      raise ActiveRdfError, "query must be String."
+    end
+    
+    # execute query
+    FederationManager.query(query, {:result_format => result_format})
+  end
+  
+  # Find all triple by subject and predicate
+  # The return value is a PropertyList
+  def self.find_all_by_subject_and_predicate(s,p)
+    # verify input
+    if s.nil? || p.nil?
+      raise ActiveRdfError, "subject and predicate can't be nil"
+    end
+    
+    # execute query
+    query_result = self.sparql_query("SELECT ?o WHERE {#{s} #{p} ?o}")
+    
+    # return propertyList
+    return PropertyList.new(p, query_result, s)
+  end
+  
+end

data/lib/active_rdf/federation/active_rdf_adapter.rb

@@ -0,0 +1,47 @@
+# require 'active_rdf'
+require 'queryengine/query2sparql'
+
+# Generic superclass of all adapters
+
+class ActiveRdfAdapter
+  # indicate if adapter can read and write
+  bool_accessor :reads, :writes, :enabled
+
+  def initialize
+    @enabled = true
+  end
+
+  # Indicate if the adapter supports contexts
+  def supports_context?
+    self.class.supports_context?
+  end
+
+  # translate a query to its string representation
+  def translate(query)
+    Query2SPARQL.translate(query)
+  end
+
+  # Clear the adapter. Crude default implementation, which can be overwritten
+  # in subclasses. TODO: This queries all adapters, this may lead to problems...
+  def clear
+    raise(ActiveRdfError, "Can only delete from writing adapters") unless(writes?)
+    to_delete = Query.new.select(:s, :p, :o).where(:s, :p, :o).execute
+    to_delete.each do |s, p, o|
+      delete(s, p, o)
+    end
+  end
+
+  # Indicates if this adapter class supports contexts  
+  def self.supports_context?
+    @context_supported = false if(@context_supported == nil)
+    @context_supported
+  end
+
+  private
+
+  # Method to set the "context_supported" flag
+  def self.supports_context
+    @context_supported = true
+  end
+
+end

data/lib/active_rdf/federation/connection_pool.rb

@@ -0,0 +1,156 @@
+# require 'active_rdf'
+
+# Maintains pool of adapter instances that are connected to datasources. Returns 
+# right adapter for a given datasource, by either reusing an
+# existing adapter-instance or creating new a adapter-instance.
+
+class ConnectionPool
+  class << self
+    attr_accessor :write_adapter
+
+    # sets automatic flushing of data from adapters to original datasources 
+    # (e.g. redland on-file database). If disabled, changes to an adapter are 
+    # not written back into the original source: you need to invoke 
+    # ConnectionPool.flush manually
+    bool_accessor :auto_flush
+  end
+  # pool of all adapters
+  @@adapter_pool = Array.new
+
+  # pool of connection parameters to all adapter
+  @@adapter_parameters = Array.new
+
+  # currently active write-adapter (we can only write to one at a time)
+  self.write_adapter = nil
+
+  # default setting for auto_flush
+  self.auto_flush = true
+
+  # adapters-classes known to the pool, registered by the adapter-class
+  # itself using register_adapter method, used to select new
+  # adapter-instance for requested connection type
+  @@registered_adapter_types = Hash.new
+
+  # clears the pool: removes all registered data sources
+  def ConnectionPool.clear
+    ActiveRdfLogger::log_info "Clear called", self
+    @@adapter_pool.clear
+    @@adapter_parameters.clear
+    self.write_adapter = nil
+  end
+
+  def ConnectionPool.adapters
+    @@adapter_pool.dup
+  end
+
+  # flushes all openstanding changes into the original datasource.
+  def ConnectionPool.flush
+    write_adapter.flush
+  end
+
+  def ConnectionPool.adapter_types
+    @@registered_adapter_types.keys
+  end
+
+  # returns the set of currently registered read-access datasources
+  def ConnectionPool.read_adapters
+    @@adapter_pool.select {|adapter| adapter.reads? && adapter.enabled?}
+  end
+
+  def ConnectionPool.write_adapters
+    @@adapter_pool.select {|adapter| adapter.writes? && adapter.enabled?}
+  end
+
+  # returns adapter-instance for given parameters (either existing or new)
+  def ConnectionPool.add_data_source(connection_params)
+    ActiveRdfLogger::log_info(self) { "add_data_source with params: #{connection_params.inspect}" }
+
+    # either get the adapter-instance from the pool
+    # or create new one (and add it to the pool)
+    index = @@adapter_parameters.index(connection_params)
+    if index.nil?
+      # adapter not in the pool yet: create it,
+      # register its connection parameters in parameters-array
+      # and add it to the pool (at same index-position as parameters)
+      ActiveRdfLogger::log_debug(self) { "Create a new adapter for parameters #{connection_params.inspect}" }
+      adapter = create_adapter(connection_params)
+      @@adapter_parameters << connection_params
+      @@adapter_pool << adapter
+    else
+      # if adapter parametrs registered already,
+      # then adapter must be in the pool, at the same index-position as its parameters
+      ActiveRdfLogger::log_debug("Reusing existing adapter")
+      adapter = @@adapter_pool[index]
+    end
+
+    # sets the adapter as current write-source if it can write
+    self.write_adapter = adapter if adapter.writes?
+
+    return adapter
+  end
+
+  # remove one adapter from activerdf
+  def ConnectionPool.remove_data_source(adapter)
+    ActiveRdfLogger.log_info(self) { "ConnectionPool: remove_data_source with params: #{adapter.to_s}" }
+
+    index = @@adapter_pool.index(adapter)
+
+    # remove_data_source mit be called repeatedly, e.g because the adapter object is stale
+    unless index.nil?
+      @@adapter_parameters.delete_at(index)
+      @@adapter_pool.delete_at(index)
+      if self.write_adapters.empty?
+        self.write_adapter = nil
+      else
+        self.write_adapter = self.write_adapters.first
+      end
+    end
+
+  end
+
+  # sets adapter-instance for connection parameters (if you want to re-enable an existing adapter)
+  def ConnectionPool.set_data_source(adapter, connection_params = {})
+    index = @@adapter_parameters.index(connection_params)
+    if index.nil?
+      @@adapter_parameters << connection_params
+      @@adapter_pool << adapter
+    else
+      @@adapter_pool[index] = adapter
+    end
+    self.write_adapter = adapter if adapter.writes?
+    adapter
+  end
+
+  # aliasing add_data_source as add
+  # (code bit more complicad since they are class methods)
+  class << self
+    alias add add_data_source
+  end
+
+  # adapter-types can register themselves with connection pool by
+  # indicating which adapter-type they are
+  def ConnectionPool.register_adapter(type, klass)
+    ActiveRdfLogger::log_info(self) { "Registering adapter of type #{type} for class #{klass}" }
+    @@registered_adapter_types[type] = klass
+  end
+
+  # unregister adapter-type
+  def ConnectionPool.unregister_adapter(type)
+    ActiveRdfLogger::log_info(self) { "ConnectionPool: deregistering adapter of type #{type}" }
+    @@registered_adapter_types.delete type
+  end
+
+  # create new adapter from connection parameters
+  def ConnectionPool.create_adapter connection_params
+    # lookup registered adapter klass
+    klass = @@registered_adapter_types[connection_params[:type].to_sym]
+
+    # raise error if adapter type unknown
+    raise(ActiveRdfError, "unknown adapter type #{connection_params[:type]}") if klass.nil?
+
+    # create new adapter-instance
+    klass.send(:new, connection_params)
+  end
+
+  private_class_method :create_adapter
+end