activerdf_net7 1.6.11

data/lib/active_rdf_helpers.rb

@@ -0,0 +1,30 @@
+# Default ActiveRDF error
+class ActiveRdfError < StandardError
+end
+
+class Module
+	# Adds boolean accessor to a class (e.g. person.male?)
+  def bool_accessor *syms
+    attr_accessor(*syms)
+    syms.each { |sym| alias_method "#{sym}?", sym }
+    remove_method(*syms)
+  end
+end
+
+module ActiveRdfBenchmark
+  # Benchmarking for ActiveRecord. You may pass a message with additional
+  # information - there's a little hack that the "real" benchmark will pass
+  # the message to the block, while the "non-benchmark" call will pass nil.
+  # This allows you to build the message in the block only if you need it.
+  def benchmark(title, log_level = Logger::DEBUG, message = '')
+    if(ActiveRdfLogger.logger.level <= log_level)
+      result = nil
+      seconds = Benchmark.realtime { result = yield(message) }
+      ActiveRdfLogger.log_add("\033[31m\033[1m#{title}\033[0m (#{'%.5f' % seconds}) -- \033[34m#{message}\033[0m", log_level, self)
+      result
+    else
+      yield(nil)
+    end
+  end
+
+end

data/lib/active_rdf_log.rb

@@ -0,0 +1,100 @@
+require 'logger'
+
+
+class ActiveRdfLogger
+
+  # Create log methods for each level
+  %w(debug info warn error fatal).each do |level|
+    module_eval <<-"end_eval"
+          def self.log_#{level}(message_or_context, context = nil)
+            message_or_context, context = nil, message_or_context if(block_given?)
+            log_add(message_or_context, Logger::#{level.upcase}, context) do
+              yield if(block_given?)
+            end
+          end
+    end_eval
+  end
+
+  class << self
+
+    # Get the logger for the ActiveRDF library. This will default to the Rails
+    # logger if that is active. Otherwise it will use the configured logger
+    # for ActiveRDF. (Note that some messages may go to the configured logger
+    # if ActiveRDF is initialized before Rails).
+    def logger
+      @logger ||= get_active_rdf_logger
+    end
+
+    # Assign a new logger
+    def logger=(logger)
+      @logger = logger
+      @native_logger = false
+    end
+
+    # Logs a message of the given severity. The context may identify the class/
+    # object that logged the message
+    def log_add(message = nil, severity = Logger::DEBUG, context = nil)
+      logger.add(severity, nil, "ActiveRDF") do
+        message = yield if(!message && block_given?)
+        log_message(message, context)
+      end
+    end
+
+    private
+
+    def log_message(message, context = nil)
+      message = ("\033[32m\033[4m\033[1m#{context_string(context)}\033[0m ") << message if(context)
+      return message if(@native_logger)
+      "\033[35m\033[4m\033[1mActiveRDF\033[0m " << message
+    end
+
+    def context_string(context)
+      return context if(context.is_a?(String))
+      context = context.class unless(context.is_a?(Class))
+      context.name
+    end
+
+    def get_active_rdf_logger
+      if(defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER)
+        RAILS_DEFAULT_LOGGER
+      else
+        @native_logger = true
+
+        # use either $ACTIVE_RDF_LOG for logging or current directory
+        location = ENV['ACTIVE_RDF_LOG'] || $stdout # "#{Dir.pwd}/activerdf.log"
+        location = $stdout if(location == "STDOUT")
+        logger = Logger.new(location, 1, 100*1024)
+
+        # if user has specified loglevel we use that, otherwise we use default level
+        # in the environment variable ACTIVE_RDF_LOG_LEVEL we expect numbers, which we
+        # have to convert
+        if ENV['ACTIVE_RDF_LOG_LEVEL'].nil?
+          logger.level = Logger::WARN
+        else
+          logger.level = ENV['ACTIVE_RDF_LOG_LEVEL'].to_i
+        end
+
+        logger
+      end
+    end
+    
+  end
+end
+
+class Logger
+  def debug_pp(message, variable)  
+    if variable.respond_to?(:join)
+      if variable.empty?
+        debug(sprintf(message, "empty"))
+      else 
+        debug(sprintf(message, variable.join(', ')))        
+      end
+    else
+      if variable.nil?
+        debug(sprintf(message, 'empty'))
+      else
+        debug(sprintf(message, variable))
+      end
+    end
+  end
+end

data/test/common.rb

@@ -0,0 +1,119 @@
+def get_adapter
+  types = ConnectionPool.adapter_types
+  if types.include?(:rdflite)
+    get_rdflite
+  elsif types.include?(:redland)
+    get_redland
+  elsif types.include?(:sparql)
+    get_sparql
+  elsif types.include?(:yars)
+    get_yars
+  elsif types.include?(:jars2)
+    get_jars2
+  else
+    raise ActiveRdfError, "no suitable adapter found for test"
+  end
+end
+
+def get_read_only_adapter
+  if ConnectionPool.adapter_types.include?(:sparql)
+    get_sparql
+  else
+    raise ActiveRdfError, "no suitable read-only adapter found for test"
+  end
+end
+
+# TODO make this work with a list of existing adapters, not only one
+def get_different_adapter(existing_adapter)
+  types = ConnectionPool.adapter_types
+  if types.include?(:rdflite)
+    if existing_adapter.class == RDFLite
+      ConnectionPool.add :type => :rdflite, :unique => true
+    else
+      get_rdflite
+    end
+  elsif types.include?(:redland) and existing_adapter.class != RedlandAdapter
+    get_rdflite
+  elsif types.include?(:sparql) and existing_adapter.class != SparqlAdapter
+    get_sparql
+  elsif types.include?(:yars) and existing_adapter.class != YarsAdapter
+    get_yars
+  elsif types.include?(:jars2) and existing_adapter.class != Jars2Adapter
+    get_jars2
+  else
+    raise ActiveRdfError, "only one adapter on this system, or no suitable adapter found for test"
+  end
+end
+
+def get_all_read_adapters
+  types = ConnectionPool.adapter_types
+  adapters = types.collect {|type| self.send("get_#{type}") }
+  adapters.select {|adapter| adapter.reads?}
+end
+
+def get_all_write_adapters
+  types = ConnectionPool.adapter_types
+  adapters = types.collect {|type| self.send("get_#{type}") }
+  adapters.select {|adapter| adapter.writes?}
+end
+
+def get_write_adapter
+  types = ConnectionPool.adapter_types
+  if types.include?(:rdflite)
+    get_rdflite
+  elsif types.include?(:redland)
+    get_redland
+  elsif types.include?(:yars)
+    get_yars
+  elsif types.include?(:jars2)
+    get_jars2
+  else
+    raise ActiveRdfError, "no suitable adapter found for test"
+  end
+end
+
+# TODO use a list of exisiting adapters not only one
+def get_different_write_adapter(existing_adapter)
+  types = ConnectionPool.adapter_types
+  if types.include?(:rdflite)
+    if existing_adapter.class == RDFLite
+      ConnectionPool.add :type => :rdflite, :unique => true
+    else
+      get_rdflite
+    end
+  elsif types.include?(:redland) and existing_adapter.class != RedlandAdapter
+    get_redland
+  elsif types.include?(:yars) and existing_adapter.class != YarsAdapter
+    get_yars
+  else
+    raise ActiveRdfError, "only one write adapter on this system, or no suitable write adapter found for test"
+  end
+end
+
+# get all adapters used in Talia
+def get_talia_adapters
+  types = ConnectionPool.adapter_types
+  ConnectionPool.add :type => :rdflite if types.include?(:rdflite)
+  ConnectionPool.add :type => :fetching if types.include?(:fetching)
+  ConnectionPool.add :type => :suggesting if types.include?(:suggesting)
+  ConnectionPool.add :type => :redland if types.include?(:redland)
+  ConnectionPool.add :type => :sesame if types.include?(:sesame)
+  if ConnectionPool.adapters.size > 0
+    return ConnectionPool.adapters
+  else
+    raise ActiveRdfError, "No adapter for Talia found on this system, or no suitable write adapter found for Talia test"
+  end
+end
+
+private
+def get_sparql
+  ConnectionPool.add(:type => :sparql, :url => "http://sparql.org/books",
+  :engine => :joseki, :results => :sparql_xml)
+end
+
+def get_fetching; ConnectionPool.add(:type => :fetching); end
+def get_suggesting; ConnectionPool.add(:type => :suggesting); end
+def get_rdflite; ConnectionPool.add(:type => :rdflite); end
+def get_redland; ConnectionPool.add(:type => :redland); end
+def get_yars; ConnectionPool.add(:type => :yars); end
+def get_jars2; ConnectionPool.add(:type => :jars2); end

data/test/directaccess/test_direct_access.rb

@@ -0,0 +1,64 @@
+$:.unshift File.join(File.dirname(__FILE__),'..', '..','lib', 'active_rdf')
+
+require 'test/unit'
+require 'directaccess/direct_access'
+
+class TestDirectAccess < Test::Unit::TestCase
+  
+  def setup
+    # load Redland Adapter
+    #ConnectionPool.clear
+    #adapter = load_adapter(:redland)
+    #adapter.load("#{File.dirname(__FILE__)}/../test_person_data.nt") if !adapter.nil?
+  end
+  
+  @@eyal = "<http://activerdf.org/test/eyal>"
+  @@age = "<http://activerdf.org/test/age>"
+  @@age_number = "18"
+  
+  
+  def test_query
+    ConnectionPool.clear
+    adapter = load_adapter(:redland)
+    if !adapter.nil?
+      adapter.load("#{File.dirname(__FILE__)}/../test_person_data.nt")
+      # test SELECT query
+      assert_not_equal nil, DirectAccess.sparql_query("SELECT ?p ?o WHERE {#{@@eyal} ?p ?o}")
+      assert_not_equal nil, DirectAccess.sparql_query("SELECT ?o WHERE {#{@@eyal} #{@@age} ?o}")
+      assert_raise(ActiveRdfError) {DirectAccess.sparql_query(nil)}
+      assert_raise(ActiveRdfError) {DirectAccess.sparql_query(123)}
+    
+      # test return value
+      assert_equal Array, DirectAccess.sparql_query("SELECT ?o WHERE {#{@@eyal} #{@@age} ?o}",:array).class
+      assert_equal String, DirectAccess.sparql_query("SELECT ?p WHERE {#{@@eyal} ?p '27'}")[0].class
+    end
+  end
+
+  def test_propertylist
+    ConnectionPool.clear
+    adapter = load_adapter(:redland)
+    if !adapter.nil?
+      # test creation
+      assert_equal PropertyList, DirectAccess.find_all_by_subject_and_predicate(@@eyal, @@age).class
+      assert_raise(ActiveRdfError) {DirectAccess.find_all_by_subject_and_predicate(nil, nil)}
+      
+      # test add
+      pl = DirectAccess.find_all_by_subject_and_predicate(@@eyal, @@age)
+      assert_kind_of(PropertyList, pl)
+      assert_equal false, pl.include?(@@age_number)
+      assert_equal true, (pl << @@age_number)
+      assert_equal true, pl.include?(@@age_number)
+    
+      # test remove
+      assert_equal true, (pl.remove(@@age_number))
+      assert_equal false, pl.include?(@@age_number)
+      assert_equal true, (pl.remove)
+      assert_equal 0, pl.size
+      assert_equal 0, DirectAccess.find_all_by_subject_and_predicate(@@eyal, @@age).size
+    
+      # test replace
+      pl << "123"
+      assert_equal true, pl.replace("123", @@age_number)    
+    end
+  end
+end

data/test/federation/test_connection_pool.rb

@@ -0,0 +1,86 @@
+# Author:: Benjamin Heitmann
+# Copyright:: (c) 2005-2006
+# License:: LGPL
+
+require 'test/unit'
+require 'active_rdf'
+require 'federation/connection_pool'
+require "#{File.dirname(__FILE__)}/../common"
+
+class TestConnectionPool < Test::Unit::TestCase
+  def setup
+		ConnectionPool.clear
+  end
+
+  def teardown
+		ConnectionPool.clear
+  end
+
+  def test_class_add_data_source    
+    # test for successfull adding of an adapter
+    adapter = get_adapter
+    assert_kind_of ActiveRdfAdapter, adapter
+    assert ConnectionPool.adapter_pool.include?(adapter)
+    
+    # now check that we get the same adapter if we supply the same parameters
+    adapter2 = get_adapter
+    assert_equal adapter, adapter2
+    # test same object_id
+  end
+
+  def test_class_adapter_pool
+		#ConnectionPool.clear
+    assert_equal 0, ConnectionPool.adapter_pool.size
+    adapter = get_adapter
+    assert_equal 1, ConnectionPool.adapter_pool.size
+  end
+
+  def test_class_register_adapter
+    ConnectionPool.register_adapter(:funkytype, ActiveRdfAdapter)
+    assert ConnectionPool.adapter_types.include?(:funkytype)
+    # unregister test adapter
+    ConnectionPool.unregister_adapter(:funkytype)
+    assert !ConnectionPool.adapter_types.include?(:funkytype)
+  end
+
+  def test_class_auto_flush_equals
+    # assert auto flushing by default
+    assert ConnectionPool.auto_flush?
+    ConnectionPool.auto_flush = false
+    assert !ConnectionPool.auto_flush?
+  end
+
+  def test_class_clear
+    ConnectionPool.clear
+    assert ConnectionPool.adapter_pool.empty?
+    assert_nil ConnectionPool.write_adapter
+  end
+
+  def test_class_write_adapter
+    adapter = get_write_adapter
+    assert_kind_of ActiveRdfAdapter, adapter
+  end
+
+  def test_class_write_adapter_equals
+    # get 2 adapter
+    adapter1 = get_write_adapter
+    
+    # if another write adapter is present
+    adapter2 = get_different_write_adapter(adapter1)
+    # check if the selected write adapter is the second
+    assert_equal adapter2, ConnectionPool.write_adapter if !adapter2.nil?
+    
+    # change write adatper
+    ConnectionPool.write_adapter = adapter1
+    #check if the selected write adapter is the first
+    assert_equal adapter1, ConnectionPool.write_adapter
+  end
+end
+
+# need access to connectionpool.adapter_pool in tests
+class ConnectionPool
+  def self.adapter_pool
+    @@adapter_pool
+  end
+end
+

data/test/federation/test_federation_manager.rb

@@ -0,0 +1,145 @@
+# Author:: Eyal Oren
+# Copyright:: (c) 2005-2006
+# License:: LGPL
+
+require 'test/unit'
+require 'active_rdf'
+require 'federation/federation_manager'
+require "#{File.dirname(__FILE__)}/../common"
+
+class TestFederationManager < Test::Unit::TestCase
+  def setup
+    ConnectionPool.clear
+  end
+
+  def teardown
+  end
+
+  @@eyal = RDFS::Resource.new("http://activerdf.org/test/eyal")
+  @@age = RDFS::Resource.new("http://activerdf.org/test/age")
+  @@age_number = RDFS::Resource.new("27")
+  @@eye = RDFS::Resource.new("http://activerdf.org/test/eye")
+  @@eye_value = RDFS::Resource.new("blue")
+  @@type = RDFS::Resource.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#type")
+  @@person = RDFS::Resource.new("http://www.w3.org/2000/01/rdf-schema#Resource")
+  @@resource = RDFS::Resource.new("http://activerdf.org/test/Person")
+
+
+  def test_single_pool
+    a1 = get_adapter
+    a2 = get_adapter
+    assert_equal a1, a2
+    assert_equal a1.object_id, a2.object_id
+  end
+
+  def test_class_add
+    write1 = get_write_adapter
+    FederationManager.add(@@eyal, @@age, @@age_number)
+
+    age_result = Query.new.select(:o).where(@@eyal, @@age, :o).execute
+    assert "27", age_result
+  end
+
+  def test_class_add_no_write_adapter
+    # zero write, one read -> must raise error
+    adapter = get_read_only_adapter
+    assert (not adapter.writes?)
+    assert_raises(ActiveRdfError) { FederationManager.add(@@eyal, @@age, @@age_number) }
+  end
+
+  def test_class_add_one_write_one_read
+    # one write, one read
+
+    write1 = get_write_adapter
+    read1 = get_read_only_adapter
+    assert_not_equal write1,read1
+    assert_not_equal write1.object_id, read1.object_id
+
+    FederationManager.add(@@eyal, @@age, @@age_number)
+
+    age_result = Query.new.select(:o).where(@@eyal, @@age, :o).execute
+    assert "27", age_result
+  end
+
+  def test_get_different_read_and_write_adapters
+    r1 = get_adapter
+    r2 = get_different_adapter(r1)
+    assert_not_equal r1,r2
+    assert_not_equal r1.object_id, r2.object_id
+
+    w1 = get_write_adapter
+    w2 = get_different_write_adapter(w1)
+    assert_not_equal w1,w2
+    assert_not_equal w1.object_id, w2.object_id
+  end
+
+  def test_class_add_two_write
+    # two write, one read, no switching
+    # we need to different write adapters for this
+    #
+
+    write1 = get_write_adapter
+    write2 = get_different_write_adapter(write1)
+
+    read1 = get_read_only_adapter
+
+    FederationManager.add(@@eyal, @@age, @@age_number)
+
+    age_result = Query.new.select(:o).where(@@eyal, @@age, :o).execute
+    assert "27", age_result
+  end
+
+  def test_class_add_two_write_switching
+    # two write, one read, with switching
+
+    write1 = get_write_adapter
+    write2 = get_different_write_adapter(write1)
+
+    read1 = get_read_only_adapter
+
+    FederationManager.add(@@eyal, @@age, @@age_number)
+    age_result = Query.new.select(:o).where(@@eyal, @@age, :o).execute
+    assert "27", age_result
+
+    ConnectionPool.write_adapter = write2
+
+    FederationManager.add(@@eyal, @@eye, @@eye_value)
+    age_result = Query.new.select(:o).where(@@eyal, @@eye, :o).execute
+    assert "blue", age_result
+
+    second_result = write2.query(Query.new.select(:o).where(@@eyal, @@eye, :o))
+    assert "blue", second_result
+  end
+
+  # this test makes no sense without two different data sources
+  def test_federated_query
+    first_adapter = get_write_adapter
+    first_adapter.load("#{File.dirname(__FILE__)}/../test_person_data.nt")
+    first = Query.new.select(:s,:p,:o).where(:s,:p,:o).execute
+
+    # results should not be empty, because then the test succeeds trivially
+    assert_not_nil first
+    assert first != []
+
+    ConnectionPool.clear
+    second_adapter = get_different_write_adapter(first_adapter)
+    second_adapter.load("#{File.dirname(__FILE__)}/../test_person_data.nt")
+    second = Query.new.select(:s,:p,:o).where(:s,:p,:o).execute
+
+    # now we query both adapters in parallel
+    ConnectionPool.clear
+    first_adapter = get_write_adapter
+    first_adapter.load("#{File.dirname(__FILE__)}/../test_person_data.nt")
+    second_adapter = get_different_write_adapter(first_adapter)
+    second_adapter.load("#{File.dirname(__FILE__)}/../test_person_data.nt")
+    both = Query.new.select(:s,:p,:o).where(:s,:p,:o).execute
+    # assert both together contain twice the sum of the separate sources
+    assert_equal first + second, both
+
+    # since both sources contain the same data, we check that querying (both!)
+    # in parallel for distinct data, actually gives same results as querying
+    # only the one set
+    uniq = Query.new.distinct(:s,:p,:o).where(:s,:p,:o).execute
+    assert_equal first.sort, uniq.sort
+  end
+end