activerdf 1.0 → 1.1

data/README

@@ -1,5 +1,3 @@
-== Welcome to ActiveRDF
-
 ActiveRDF is a library for accessing RDF data from Ruby programs. It can be used 
 as data layer in Ruby-on-Rails, similar to ActiveRecord (which provides an O/R 
 mapping to relational databases). ActiveRDF in RoR allows you to create semantic 
@@ -10,16 +8,23 @@ etc. programmatically, without queries.
 See http://www.activerdf.org for more information.
 
 == Getting Started
+
+See http://wiki.activerdf.org/GettingStartedGuide for information on how to install 
+ActiveRDF, get it running with some data sources, and start using it.
+
+== Simple Example
+
+The following example uses a SPARQL endpoint with FOAF data and displays all 
+people found in the data source:
+
  require 'active_rdf'
  ConnectionPool.add_data_source :type => :sparql, :host => '...'
  Namespace.register :foaf, 'http://xmlns.com/foaf/0.1/'
  ObjectManager.construct_classes
  people = FOAF::Person.find_all
 
-See http://activerdf.org for more examples.
-
 == License
-ActiveRDF is distributed under the LGPL[link:../LICENSE] license.
+ActiveRDF is distributed under the LGPL[link:http://www.gnu.org/licenses/lgpl.html] license.
 
 == Authors
 * Eyal Oren

data/Rakefile

@@ -11,7 +11,19 @@ include FileUtils
 # setup tests and rdoc files
 setup_tests
 setup_clean ["pkg", "lib/*.bundle", "*.gem", ".config"]
-setup_rdoc ['README', 'LICENSE', 'lib/**/*.rb']
+
+# setup rdoc task
+#setup_rdoc ['README', 'LICENSE', 'lib/**/*.rb']
+Rake::RDocTask.new do |rdoc|
+	files = ['README', 'LICENSE', 'lib/**/*.rb', 'doc/**/*.rdoc', 'test/*.rb']
+	files << 'activerdf-*/lib/**/*.rb'
+	rdoc.rdoc_files.add(files)
+	rdoc.main = "README" # page to start on
+	rdoc.title = "ActiveRDF documentation"
+	rdoc.template = "tools/allison/allison.rb"
+	rdoc.rdoc_dir = 'doc' # rdoc output folder
+	rdoc.options << '--line-numbers' << '--inline-source'
+end
 
 # default task: install
 desc 'test and package gem'

data/lib/active_rdf/federation/active_rdf_adapter.rb

@@ -1,11 +1,8 @@
-# Author:: Benjamin Heitmann
-# Copyright:: (c) 2005-2006 
-# License:: LGPL
-
 require 'active_rdf'
 require 'queryengine/query2sparql'
 
-# generic superclass of all adapters
+# Generic superclass of all adapters
+
 class ActiveRdfAdapter
 	# indicate if adapter can read and write
 	bool_accessor :reads, :writes
@@ -14,5 +11,4 @@ class ActiveRdfAdapter
 	def translate(query)
 	 	Query2SPARQL.translate(query)
 	end
-	
 end

data/lib/active_rdf/federation/connection_pool.rb

@@ -1,13 +1,9 @@
-# Maintains pool of adapter instances that are connected to datasources
-# returns right adapter for a given datasource, by either reusing
-# existing adapter-instance or creating new adapter-instance
-#
-# Author:: Eyal Oren
-# Copyright:: (c) 2005-2006
-# License:: LGPL
-
 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
@@ -37,7 +33,7 @@ class ConnectionPool
 
   # clears the pool: removes all registered data sources
   def ConnectionPool.clear
-    $log.info "ConnectionPool: clear called"
+    $activerdflog.info "ConnectionPool: clear called"
     @@adapter_pool = []
     @@adapter_parameters = []
     self.write_adapter = nil
@@ -59,7 +55,7 @@ class ConnectionPool
 
   # returns adapter-instance for given parameters (either existing or new)
   def ConnectionPool.add_data_source(connection_params)
-    $log.info "ConnectionPool: add_data_source with params: #{connection_params.inspect}"
+    $activerdflog.info "ConnectionPool: 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)
@@ -68,14 +64,14 @@ class ConnectionPool
       # 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)
-      $log.debug("Create a new adapter for parameters #{connection_params.inspect}")
+      $activerdflog.debug("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
-      $log.debug("Reusing existing adapter")
+      $activerdflog.debug("Reusing existing adapter")
       adapter = @@adapter_pool[index]
     end
 
@@ -85,6 +81,19 @@ class ConnectionPool
     return adapter
   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
@@ -94,7 +103,7 @@ class ConnectionPool
   # adapter-types can register themselves with connection pool by
   # indicating which adapter-type they are
   def ConnectionPool.register_adapter(type, klass)
-    $log.info "ConnectionPool: registering adapter of type #{type} for class #{klass}"
+    $activerdflog.info "ConnectionPool: registering adapter of type #{type} for class #{klass}"
     @@registered_adapter_types[type] = klass
   end
 

data/lib/active_rdf/federation/federation_manager.rb

@@ -1,16 +1,12 @@
-# Manages the federation of datasources
-# distributes queries to right datasources and merges their results
-#
-# Author:: Eyal Oren
-# Copyright:: (c) 2005-2006
-# License:: LGPL
 require 'federation/connection_pool'
 
+# Manages the federation of datasources: distributes queries to right 
+# datasources and merges their results
+
 class FederationManager
   # add triple s,p,o to the currently selected write-adapter
   def FederationManager.add(s,p,o)
     # TODO: allow addition of full graphs
-    $log.debug "FederationManager: add: triple is #{s} #{p} #{o}"
     ConnectionPool.write_adapter.add(s,p,o)
   end
 
@@ -22,7 +18,6 @@ class FederationManager
 			raise ActiveRdfError, "cannot execute query without data sources" 
 		end
 
-    $log.debug "FederationManager: query called with: #{q}"
     # ask each adapter for query results
     # and yield them consequtively
     if block_given?
@@ -72,9 +67,6 @@ class FederationManager
       end
     end
     
-    $log.debug_pp("FederationManager: query results are %s", final_results)
-    
-    
-    return final_results
+    final_results
   end
 end

data/lib/active_rdf/objectmanager/namespace.rb

@@ -1,13 +1,8 @@
-# Manages namespace abbreviations and expansions
-#
-# Author:: Eyal Oren
-# Copyright:: (c) 2005-2006
-# License:: LGPL
-
 require 'active_rdf'
 
-class Namespace
+# Manages namespace abbreviations and expansions
 
+class Namespace
   @@namespaces = Hash.new
   @@inverted_namespaces = Hash.new
 
@@ -15,7 +10,7 @@ class Namespace
   # 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?)
-		$log.info "Namespace: registering #{fullURI} to #{prefix}"
+		$activerdflog.info "Namespace: registering #{fullURI} to #{prefix}"
     @@namespaces[prefix.to_sym] = fullURI.to_s
     @@inverted_namespaces[fullURI.to_s] = prefix.to_sym
   end
@@ -23,7 +18,6 @@ class Namespace
   # returns a resource whose URI is formed by concatenation of prefix and localname
   def self.lookup(prefix, localname)
     full_resource = expand(prefix, localname)
-    $log.debug "Namespace: lookup for Resource #{full_resource} initiated"
     RDFS::Resource.new(expand(prefix, localname))
   end
 

data/lib/active_rdf/objectmanager/object_manager.rb

@@ -1,15 +1,11 @@
-# Constructs Ruby classes for RDFS classes (in the right namespace)
-#
-# Author:: Eyal Oren
-# Copyright:: (c) 2005-2006
-# License:: LGPL
 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
+	# 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
@@ -31,7 +27,7 @@ class ObjectManager
 		# 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
-		$log.debug "ObjectManager: construct_classes: classes found: #{klasses}"
+		$activerdflog.debug "ObjectManager: construct_classes: classes found: #{klasses}"
 		
 		# then we construct a Ruby class for each found rdfs:class
 		# and return the set of all constructed classes
@@ -51,31 +47,31 @@ class ObjectManager
     if prefix.nil?
 			# if the prefix is unknown, we create our own from the full URI
       modulename = create_module_name(resource)
-      $log.debug "ObjectManager: construct_class: constructing modulename #{modulename} from URI #{resource}"
+      $activerdflog.debug "ObjectManager: construct_class: constructing modulename #{modulename} from URI #{resource}"
 		else
 			# otherwise we convert the registered prefix into a module name
 			modulename = prefix_to_module(prefix)
-			$log.debug "ObjectManager: construct_class: constructing modulename #{modulename} from registered prefix #{prefix}"
+			$activerdflog.debug "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)
-        $log.debug "ObjectManager: construct_class: module name #{modulename} previously defined"
+        $activerdflog.debug "ObjectManager: construct_class: module name #{modulename} previously defined"
 				Object.const_get(modulename.to_sym)
 			else
-        $log.debug "ObjectManager: construct_class: defining module name #{modulename} now"
+        $activerdflog.debug "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)
-      $log.debug "ObjectManager: construct_class: given class #{klassname} defined in the module"
+      $activerdflog.debug "ObjectManager: construct_class: given class #{klassname} defined in the module"
 			# if so, return the existing class
 			_module.const_get(klassname.to_sym)
 		else
-      $log.debug "ObjectManager: construct_class: creating given class #{klassname}"
+      $activerdflog.debug "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)")

data/lib/active_rdf/objectmanager/resource.rb

@@ -1,19 +1,14 @@
-# Represents an RDF resource and manages manipulations of that resource,
-# including data lookup (e.g. eyal.age), data updates (e.g. eyal.age=20),
-# class-level lookup (Person.find_by_name 'eyal'), and class-membership
-# (eyal.class ...Person)
-#
-# Author:: Eyal Oren
-# Copyright:: (c) 2005-2006
-# License:: LGPL
-
 require 'active_rdf'
 require 'objectmanager/object_manager'
 require 'objectmanager/namespace'
 require 'queryengine/query'
 
-# TODO: add unit test to validate class construction and queries on them
 module RDFS
+	# Represents an RDF resource and manages manipulations of that resource,
+	# including data lookup (e.g. eyal.age), data updates (e.g. eyal.age=20),
+	# class-level lookup (Person.find_by_name 'eyal'), and class-membership
+	# (eyal.class ...Person).
+
   class RDFS::Resource
     # adding accessor to the class uri:
     # the uri of the rdf resource being represented by this class
@@ -27,8 +22,6 @@ module RDFS
     # creates new resource representing an RDF resource
     def initialize uri
       raise ActiveRdfError, "creating resource <#{uri}>" unless uri.is_a?(String)
-
-#      $log.debug "RDFS::Resource new: initializing new Resource with #{uri}"
       @uri = uri
     end
 
@@ -77,7 +70,7 @@ module RDFS
     def Resource.method_missing(method, *args)
       method_name = method.to_s
 
-      $log.debug "RDFS::Resource: method_missing on class: called with method name #{method}"
+      $activerdflog.debug "RDFS::Resource: method_missing on class: called with method name #{method}"
 
       # extract predicates on which to match
       # e.g. find_by_name, find_by_name_and_age
@@ -102,12 +95,12 @@ module RDFS
         end
 
         # execute query
-        $log.debug "RDFS::Resource: method_missing on class: executing query: #{query}"
-        return query.execute
+        $activerdflog.debug "RDFS::Resource: method_missing on class: executing query: #{query}"
+        return query.execute(:flatten => true)
       end
 
       # otherwise, if no match found, raise NoMethodError (in superclass)
-      $log.warn 'RDFS::Resource: method_missing on class: method not matching find_by_*'
+      $activerdflog.warn 'RDFS::Resource: method_missing on class: method not matching find_by_*'
       super
     end
 
@@ -156,7 +149,7 @@ module RDFS
       # cheaper than (1)-(2) but (1) and (2) are probably more probable (getting
       # attribute values over executing custom methods)
 
-      $log.debug "RDFS::Resource: method_missing on instance: called with method name #{method}"
+      $activerdflog.debug "RDFS::Resource: method_missing on instance: called with method name #{method}"
 
       # are we doing an update or not?
       # checking if method ends with '='
@@ -170,7 +163,7 @@ module RDFS
       end
 
       candidates = if update
-                      class_level_predicates
+                      (class_level_predicates + direct_predicates).compact.uniq
                     else
                       direct_predicates
                     end
@@ -198,7 +191,8 @@ module RDFS
       end
     end
     
-    raise ActiveRdfError, "could not set #{methodname} to #{args}: no suitable predicate found. Maybe you are missing some shcema information?" if update
+		raise ActiveRdfError, "could not set #{methodname} to #{args}: no suitable 
+		predicate found. Maybe you are missing some schema information?" if update
 
     # get/set attribute value did not succeed, so checking option (2) and (4)
     
@@ -225,8 +219,8 @@ module RDFS
     # checking possibility (4)
     # TODO: implement search strategy to select in which class to invoke
     # e.g. if to_s defined in Resource and in Person we should use Person
-    $log.debug "RDFS::Resource: method_missing on instance: branch selected: execution of custom class method"
-    self.class.each do |klass|
+    $activerdflog.debug "RDFS::Resource: method_missing option 4: custom class method"
+    self.type.each do |klass|
       if klass.instance_methods.include?(method.to_s)
         _dup = klass.new(uri)
         return _dup.send(method,*args)
@@ -241,20 +235,28 @@ module RDFS
     nil
   end
 
-  # returns classes to which this resource belongs (according to rdf:type)
-  def class
+	# saves instance into datastore
+	def save
+		db = ConnectionPool.write_adapter
+		rdftype = Namespace.lookup(:rdf, :type)
+		types.each do |t|
+			db.add(self, rdftype, t)
+		end
+
+		Query.new.distinct(:p,:o).where(self, :p, :o).execute do |p, o|
+			db.add(self, p, o)
+		end
+	end
+
+  def type
     types.collect do |type|
       ObjectManager.construct_class(type)
     end
   end
 
-  def type
-    get_property_value(Namespace.lookup(:rdf,:type))
-  end
-
   # overrides built-in instance_of? to use rdf:type definitions
   def instance_of?(klass)
-    self.class.include?(klass)
+    self.type.include?(klass)
   end
 
   # returns all predicates that fall into the domain of the rdf:type of this
@@ -272,54 +274,49 @@ module RDFS
     else
       q = Query.new.select(:p)
     end
-    q.where(self,:p, :o).execute(:flatten => false) || []
+    q.where(self,:p, :o).execute
   end
 
   def property_accessors
     direct_predicates.collect {|pred| Namespace.localname(pred) }
   end
 
-  # returns all rdf:types of this resource
-  def types
-    type = Namespace.lookup(:rdf, :type)
-
-    # we lookup the type in the database
-    types = Query.new.distinct(:t).where(self,type,:t).execute(:flatten => false)
-
-    # if we dont know it, we return Resource (as toplevel)
-    # this should in theory actually never happen (since any node is a rdfs:Resource)
-    # but could happen if the subject is unknown to the database
-    # or if the database does not support RDFS inferencing
-    return [Namespace.lookup(:rdfs,"Resource")] if types.empty?
-    return types
-  end
-
   # alias include? to ==, so that you can do paper.creator.include?(eyal)
   # without worrying whether paper.creator is single- or multi-valued
   alias include? ==
 
   # returns uri of resource, can be overridden in subclasses
   def to_s
-    "resource: #{uri}"
+    "<#{uri}>"
   end
 
-  def label(*args)
-    label = get_property_value(Namespace.lookup(:rdfs,:label)) || Namespace.localname(self)
-
-		# empty labels are not useful: replace them by localname
-		label = Namespace.localname(self) if label.empty?
-
-		# if we have no localname, use full uri
-		label = uri if label.empty?
-
-		label
+	# label of resource (rdfs:label if available, uri otherwise)
+  def label
+    get_property_value(Namespace.lookup(:rdfs,:label)) || uri
   end
 
   private
   def get_property_value(predicate, args=[])
     return_ary = args[0][:array] if args[0].is_a?(Hash)
     flatten_results = !return_ary
-    Query.new.distinct(:o).where(self, predicate, :o).execute(:flatten => flatten_results)
+    query = Query.new.distinct(:o).where(self, predicate, :o)
+		query.execute(:flatten => flatten_results)
   end  
+
+  # returns all rdf:types of this resource
+  def types
+    type = Namespace.lookup(:rdf, :type)
+
+    # we lookup the type in the database
+    types = Query.new.distinct(:t).where(self,type,:t).execute
+
+    # we are also always of type rdfs:resource and of our own class (e.g. foaf:Person)
+		defaults = []
+		defaults << Namespace.lookup(:rdfs,:Resource)
+		defaults << self.class.class_uri
+
+    (types + defaults).uniq
+  end
+
 end
 end

data/lib/active_rdf/queryengine/query.rb

@@ -1,73 +1,88 @@
-# Represents a query on a datasource, abstract representation of SPARQL features
-# is passed to federation/adapter for execution on data
-#
-# Author:: Eyal Oren
-# Copyright:: (c) 2005-2006
-# License:: LGPL
 require 'active_rdf'
 require 'federation/federation_manager'
 
-# TODO add log for every method which constitues to the query
-
+# Represents a query on a datasource, abstract representation of SPARQL 
+# features. Query is passed to federation manager or adapter for execution on 
+# data source.  In all clauses symbols represent variables: 
+# Query.new.select(:s).where(:s,:p,:o).
 class Query
-  attr_reader :select_clauses, :where_clauses, :keywords, :limits, :offsets
-  bool_accessor :distinct, :ask, :select, :count, :keyword
+	attr_reader :select_clauses, :where_clauses, :sort_clauses, :keywords, :limits, :offsets
+	bool_accessor :distinct, :ask, :select, :count, :keyword, :reasoning
 
-  def initialize
-    $log.debug "Query: initializing"
-    distinct = false
+	def initialize
+		distinct = false
 		limit = nil
 		offset = nil
-    @select_clauses = []
-    @where_clauses = []
+		@select_clauses = []
+		@where_clauses = []
+		@sort_clauses = []
 		@keywords = {}
-  end
+		@reasoning = true
+	end
 
+	# Clears the select clauses
 	def clear_select
-    $log.debug "Query: clearing select query"
+		$activerdflog.debug "cleared select clause"
 		@select_clauses = []
 		distinct = false
 	end
 
-  def select *s
-    @select = true
-    s.each do |e|
-      @select_clauses << parametrise(e) 
-    end
+	# Adds variables to select clause
+	def select *s
+		@select = true
+		s.each do |e|
+			@select_clauses << parametrise(e) 
+		end
 		# removing duplicate select clauses
 		@select_clauses.uniq!
-    $log.debug "Query: the current select clauses are: #{@select_clauses.join(', ')}"
-    self
-  end
+		self
+	end
 
-  def ask
-    @ask = true
-    $log.debug "Query: the current select clauses are: #{@select_clauses.join(', ')}"
-    self
-  end
+	# Adds variables to ask clause (see SPARQL specification)
+	def ask
+		@ask = true
+		self
+	end
 
-  def distinct *s
-    @distinct = true
-    select(*s)
-  end
-  alias_method :select_distinct, :distinct
+	# Adds variables to select distinct clause
+	def distinct *s
+		@distinct = true
+		select(*s)
+	end
+	alias_method :select_distinct, :distinct
 
+	# Adds variables to count clause
 	def count *s
 		@count = true
 		select(*s)
 	end
 
+	# Adds sort predicates (must appear in select clause)
+	def sort *s
+		s.each do |e|
+			@sort_clauses << parametrise(e) 
+		end
+		# removing duplicate select clauses
+		@sort_clauses.uniq!
+		self
+	end
+
+	# Adds limit clause (maximum number of results to return)
 	def limit(i)
 		@limits = i 
 		self
 	end
 
+	# Add offset clause (ignore first n results)
 	def offset(i)
 		@offsets = i
 		self
 	end
 
-  def where s,p,o
+	# Adds where clauses (s,p,o) where each constituent is either variable (:s) or 
+	# an RDFS::Resource. Keyword queries are specified with the special :keyword 
+	# symbol: Query.new.select(:s).where(:s, :keyword, 'eyal')
+	def where s,p,o,c=nil
 		case p
 		when :keyword
 			# treat keywords in where-clauses specially
@@ -79,26 +94,20 @@ class Query
 			# generator. 
 			# if you construct this query manually, you shouldn't! if your select 
 			# variable happens to be in one of the removed clauses: tough luck.
-			
-      unless s.respond_to?(:uri)
-    		unless s.class == Symbol
-    		  $log.debug "Query: where: got a Subject which is no Symbol, and no RDFS::Resource, but is instead: #{s}"
-          raise(ActiveRdfError, "cannot add a where clause, in which s is not a resource and not a variable")
-    		end
-      end
-      unless p.respond_to?(:uri)
-    		unless p.class == Symbol
-    		  $log.debug "Query: where: got a Predicate which is no Symbol, and no RDFS::Resource, but is instead: #{p}"
-          raise(ActiveRdfError, "cannot add a where clause, in which s is not a resource and not a variable")
-    		end
-      end
-      
-			@where_clauses << [s,p,o].collect{|arg| parametrise(arg)}
+
+			unless s.respond_to?(:uri) or s.class == Symbol
+				raise(ActiveRdfError, "cannot add a where clause with s #{s}: s must be a resource or a variable")
+			end
+			unless p.respond_to?(:uri) or p.class == Symbol
+				raise(ActiveRdfError, "cannot add a where clause with p #{p}: p must be a resource or a variable")
+			end
+
+			@where_clauses << [s,p,o,c].collect{|arg| parametrise(arg)}.compact
 		end
     self
   end
 
-	# adds keyword constraint to the query. You can use all Ferret query syntax in 
+	# Adds keyword constraint to the query. You can use all Ferret query syntax in 
 	# the constraint (e.g. keyword_where(:s,'eyal|benjamin')
 	def keyword_where s,o
 		@keyword = true
@@ -111,24 +120,14 @@ class Query
 		self
 	end
 
-# this is not normal behaviour, the method is implemented inside FacetNavigation
-#	def replace_where_clause old,new
-#		return unless where_clauses.includes?(old)
-#		where_clauses.delete(old)
-#		where_clauses.insert(new)
-#	end
-
-  # execute query on data sources
-  # either returns result as array
+  # Executes query on data sources. Either returns result as array
   # (flattened into single value unless specified otherwise)
   # or executes a block (number of block variables should be
   # same as number of select variables)
   #
-  # usage: results = query.execute
-  # usage: query.execute do |s,p,o| ... end
-  def execute(options={:flatten => true}, &block)
-    $log.debug "Query: executing query: #{self.inspect}"
-    
+  # usage:: results = query.execute
+  # usage:: query.execute do |s,p,o| ... end
+  def execute(options={:flatten => false}, &block)
     if block_given?
       FederationManager.query(self) do |*clauses|
         block.call(*clauses)
@@ -138,6 +137,7 @@ class Query
     end
   end
 
+	# Returns query string depending on adapter (e.g. SPARQL, N3QL, etc.)
   def to_s
 		if ConnectionPool.read_adapters.empty?
 			inspect 
@@ -146,6 +146,7 @@ class Query
 		end
   end
 
+	# Returns SPARQL serialisation of query
   def to_sp
 		require 'queryengine/query2sparql'
 		Query2SPARQL.translate(self)
@@ -159,6 +160,8 @@ class Query
       #'?' + s.to_s
     when RDFS::Resource
       s
+		when nil
+			nil
     else
       '"' + s.to_s + '"'
     end

data/lib/active_rdf/queryengine/query2jars2.rb

@@ -1,12 +1,7 @@
-# Translates abstract query into jars2 query
-# ignores ASK queries
-#
-# Author:: Eyal Oren
-# Copyright:: (c) 2005-2006
-# License:: LGPL
 require 'active_rdf'
 
-
+# Translates abstract query into jars2 query.
+# (ignores ASK queries)
 class Query2Jars2
 	def self.translate(query)
 		str = ""
@@ -21,7 +16,7 @@ class Query2Jars2
 			# figure it out.
 		end
 		
-		$log.debug "Query2Jars2: translated #{query} to #{str}"
+		$activerdflog.debug "Query2Jars2: translated #{query} to #{str}"
 		return str
 	end
 end

data/lib/active_rdf/queryengine/query2sparql.rb

@@ -1,11 +1,7 @@
-# translates abstract query into SPARQL that can be executed on SPARQL-compliant data source
-#
-# Author:: Eyal Oren
-# Copyright:: (c) 2005-2006
-# License:: LGPL
 require 'active_rdf'
 
-
+# Translates abstract query into SPARQL that can be executed on SPARQL-compliant
+# data source.
 class Query2SPARQL
   def self.translate(query)
     str = ""
@@ -19,7 +15,7 @@ class Query2SPARQL
       str << "ASK { #{where_clauses(query)} }"
     end
     
-    $log.debug "Query2SPARQL: translated the query to #{str}"
+    $activerdflog.debug "Query2SPARQL: translated the query to #{str}"
     return str
   end
 

data/lib/active_rdf.rb

@@ -1,8 +1,4 @@
-# Loader of ActiveRDF library
-#
-# Author:: Eyal Oren and Renaud Delbru
-# Copyright:: (c) 2005-2006 Eyal Oren and Renaud Delbru
-# License:: LGPL
+# ActiveRDF loader
 
 # adding active_rdf subdirectory to the ruby loadpath
 file = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
@@ -13,7 +9,7 @@ $: << this_dir + '/active_rdf/'
 require 'active_rdf_helpers'
 require 'active_rdf_log'
 
-$log.info "ActiveRDF started, logging level: #{$log.level}"
+$activerdflog.info "ActiveRDF started, logging level: #{$activerdflog.level}"
 
 # load standard classes that need to be loaded at startup
 require 'objectmanager/resource'
@@ -26,7 +22,7 @@ def load_adapter s
   begin
     require s
   rescue StandardError => e
-    $log.info "could not load adapter #{s}: #{e}"
+    $activerdflog.info "could not load adapter #{s}: #{e}"
   end
 end
 
@@ -34,15 +30,17 @@ require 'rubygems'
 #determine if we are installed as a gem right now:
 if Gem::cache().search("activerdf").empty?
    #we are not running as a gem
-   $log.info 'ActiveRDF is NOT installed as a Gem'
+   $activerdflog.info 'ActiveRDF is NOT installed as a Gem'
    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'
 else
    #we are indeed running as a gem
    require 'gem_plugin'
-   $log.info 'ActiveRDF is installed as a Gem'
+   $activerdflog.info 'ActiveRDF is installed as a Gem'
    GemPlugin::Manager.instance.load "activerdf" => GemPlugin::INCLUDE
 end
 

data/lib/active_rdf_helpers.rb

@@ -1,9 +1,9 @@
-# defining ActiveRDF errors
+# Default ActiveRDF error
 class ActiveRdfError < StandardError
 end
 
-# adding bool_accessor to ruby
 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 }

data/lib/active_rdf_log.rb

@@ -1,27 +1,16 @@
 require 'logger'
 
-$log =
-  begin
-    # us the rails logger if running under rails
-    RAILS_DEFAULT_LOGGER 
-  rescue NameError
-    unless ENV['ACTIVE_RDF_LOG'].nil?
-      # write to environment variable $RDF_LOG if set
-      Logger.new(ENV['ACTIVE_RDF_LOG'], 1, 100*1024) 
-    else
-      require 'tmpdir'
-      # else just write to the temp dir
-      Logger.new(Dir.tmpdir.to_s + "/activerdf.log", 1, 100*1024); 
-    end
-  end
+# use either $ACTIVE_RDF_LOG for logging or current directory
+location = ENV['ACTIVE_RDF_LOG'] || "#{Dir.pwd}/activerdf.log"
+$activerdflog = 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?
-  $log.level = Logger::WARN
+  $activerdflog.level = Logger::WARN
 else
-  $log.level = ENV['ACTIVE_RDF_LOG_LEVEL'].to_i
+  $activerdflog.level = ENV['ACTIVE_RDF_LOG_LEVEL'].to_i
 end
 
 class Logger

data/test/objectmanager/test_resource_reading.rb

@@ -28,25 +28,25 @@ class TestResourceReading < Test::Unit::TestCase
   end
 
   def test_eyal_predicates
-    predicates = @eyal.direct_predicates
-
-    # assert that the three found predicates are eye, age, and type
-    assert_equal 3, predicates.size
-    predicates_labels = predicates.collect {|pred| pred.label }
+    # assert that eyal's three direct predicates are eye, age, and type
+    preds = @eyal.direct_predicates.collect {|p| p.uri }
+    assert_equal 3, preds.size
     ['age', 'eye', 'type'].each do |pr|
-      assert predicates_labels.include?(pr), "Eyal should have predicate #{pr}"
+      assert preds.any? {|uri| uri =~ /.*#{pr}$/ }, "Eyal should have predicate #{pr}"
     end
 
-    # assert that the found predicates on Person are eye, age, and type
-    predicates_labels = predicates.collect {|pred| pred.label }
-    ['age', 'eye', 'type'].each do |pr|
-      assert predicates_labels.include?(pr), "Eyal should have predicate #{pr}"
-    end
+		# test class level predicates
+		class_preds = @eyal.class_level_predicates.collect {|p| p.uri }
+		# eyal.type: person and resource, has predicates age, eye, and 
+		# rdfs:label, rdfs:comment, etc.
+    assert_equal 10, class_preds.size
   end
 
   def test_eyal_types
-    type_labels = @eyal.types.collect {|pred| pred.label}
-    assert_equal ['Person','Resource'], type_labels
+    types = @eyal.type
+		assert_equal 2, types.size
+		assert types.include?(AR::Person)
+		assert types.include?(RDFS::Resource)
   end
 
   def test_eyal_age

data/test/queryengine/test_query.rb

@@ -15,13 +15,9 @@ class TestQuery < Test::Unit::TestCase
   end
 
   def test_sparql_generation
-
-    # TODO: write tests for distinct, ask
-
     query = Query.new
     query.select(:s)
     query.where(:s, RDFS::Resource.new('predicate'), '30')
-
     generated = Query2SPARQL.translate(query)
     expected = "SELECT ?s WHERE { ?s <predicate> \"30\" . }"
     assert_equal expected, generated
@@ -33,13 +29,15 @@ class TestQuery < Test::Unit::TestCase
     generated = Query2SPARQL.translate(query)
     expected = "SELECT ?s WHERE { ?s <foaf:age> ?a. ?a <rdf:type> <xsd:int> . }"
     assert_equal expected, generated
+	end
 
-    #		query = Query.new
-    #		query.select(:s).select(:a)
-    #		query.where(:s, 'foaf:age', :a)
-    #		generated = Query2SPARQL.translate(query)
-    #		expected = "SELECT DISTINCT ?s ?a WHERE { ?s foaf:age ?a .}"
-    #		assert_equal expected, generated
+	def test_sparql_distinct
+    query = Query.new
+    query.distinct(:s)
+    query.where(:s, RDFS::Resource.new('foaf:age'), :a)
+    generated = Query2SPARQL.translate(query)
+    expected = "SELECT DISTINCT ?s WHERE { ?s <foaf:age> ?a . }"
+    assert_equal expected, generated
   end
 
   def test_query_omnipotent

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: activerdf
 version: !ruby/object:Gem::Version 
-  version: "1.0"
-date: 2006-11-02 00:00:00 +00:00
+  version: "1.1"
+date: 2006-12-08 00:00:00 +00:00
 summary: Offers object-oriented access to RDF (with adapters to several datastores).
 require_paths: 
 - lib