activerdf 1.4 → 1.5

data/CHANGELOG

@@ -1,3 +1,12 @@
+== activerdf (1.6)
+  * TODO: remove ObjectManager.construct_classes (classes exist automagically after Namespace.register)
+
+== activerdf (1.5) Thu, 12 Apr 2007 22:42:28 +0100
+  * allows directly using classes in query: where(:s, RDF::type, SIOC::Post)
+  * extended search in Resource.find (e.g. order results, pagination)
+  * added eyal.all_age and eyal.all_foaf::name to always return Arrays
+  * added support for writing namespaced attributes (eyal.foaf::name = ...)
+
 == activerdf (1.4) Tue, 27 Feb 2007 20:50:21 +0000
   * dynamic finders support prefixes (find_by_foaf::name)
   * ntriples parser supports encoded literals (HTML)

data/lib/active_rdf/federation/connection_pool.rb

@@ -39,6 +39,10 @@ class ConnectionPool
     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

data/lib/active_rdf/federation/federation_manager.rb

@@ -15,6 +15,7 @@ class FederationManager
   # by distributing query over complete read-pool
   # and aggregating the results
   def FederationManager.query(q, options={:flatten => true})
+    $activerdflog.debug "querying #{q.to_sp}"
 		if ConnectionPool.read_adapters.empty?
 			raise ActiveRdfError, "cannot execute query without data sources" 
 		end

data/lib/active_rdf/objectmanager/namespace.rb

@@ -33,7 +33,7 @@ class Namespace
 
       # make some builtin methods private because lookup doesn't work otherwise 
       # on e.g. RDF::type and FOAF::name
-      [:type, :name].each {|m| private(m) }
+      [:type, :name, :id].each {|m| private(m) }
     end
 
     # return the namespace proxy object
@@ -83,7 +83,7 @@ class Namespace
     end
 
     delimiter = uri.rindex(/#|\//)
-    if delimiter.nil?
+    if delimiter.nil? or delimiter == uri.size-1
       uri
     else
       uri[delimiter+1..-1]

data/lib/active_rdf/objectmanager/resource.rb

@@ -3,6 +3,9 @@ require 'objectmanager/object_manager'
 require 'objectmanager/namespace'
 require 'queryengine/query'
 
+# TODO: finish removal of ObjectManager.construct_classes: make dynamic finders 
+# accessible on instance level, and probably more stuff.
+
 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),
@@ -21,8 +24,14 @@ module RDFS
 
     # creates new resource representing an RDF resource
     def initialize uri
-      raise ActiveRdfError, "creating resource <#{uri}>" unless uri.is_a?(String)
-      @uri = uri
+      @uri = case uri
+            when RDFS::Resource
+             uri.uri
+            when String
+              uri
+            else 
+              raise ActiveRdfError, "cannot create resource <#{uri}>"
+            end
 			@predicates = Hash.new
     end
 
@@ -31,17 +40,18 @@ module RDFS
     # because it cannot be found in Namespace.lookup otherwise)
     self.class_uri = Namespace.lookup(:rdfs, :Resource)
 
+    def self.uri; class_uri.uri; end
+    def self.==(other)
+      other.respond_to?(:uri) ? other.uri == self.uri : false
+    end
+
     #####                        ######
     ##### start of instance-level code
     #####                        ######
 
     # a resource is same as another if they both represent the same uri
     def ==(other)
-      if other.respond_to?(:uri)
-        other.uri == self.uri
-      else
-        false
-      end
+      other.respond_to?(:uri) ? other.uri == self.uri : false
     end
     alias_method 'eql?','=='
 
@@ -86,8 +96,46 @@ module RDFS
 
     # returns array of all instances of this class (e.g. Person.find_all)
     # (always returns collection)
-    def Resource.find_all
-      query = Query.new.distinct(:s).where(:s, Namespace.lookup(:rdf,:type), class_uri)
+    def Resource.find_all(*args)
+      find(:all, *args)
+    end
+
+    def Resource.find(*args)
+      class_uri.find(*args)
+    end
+
+    #####                         #####
+    ##### instance level methods	#####
+    #####                         #####
+    def find(*args)
+      # extract sort options from args
+      options = args.last.is_a?(Hash) ? args.pop : {}
+
+      query = Query.new.distinct(:s)
+      query.where(:s, Namespace.lookup(:rdf,:type), self)
+
+      if options.include? :order
+        sort_predicate = options[:order]
+        query.sort(:sort_value)
+        query.where(:s, sort_predicate, :sort_value)
+      end
+
+      if options.include? :reverse_order
+        sort_predicate = options[:reverse_order]
+        query.reverse_sort(:sort_value)
+        query.where(:s, sort_predicate, :sort_value)
+      end
+
+      if options.include? :where
+        raise ActiveRdfError, "where clause should be hash of predicate => object" unless options[:where].is_a? Hash
+        options[:where].each do |p,o|
+          query.where(:s, p, o)
+        end
+      end
+
+      query.limit(options[:limit]) if options[:limit]
+      query.offset(options[:offset]) if options[:offset]
+
       if block_given?
         query.execute do |resource|
           yield resource
@@ -97,10 +145,6 @@ module RDFS
       end
     end
 
-    #####                         #####
-    ##### instance level methods	#####
-    #####                         #####
-
     # manages invocations such as eyal.age
     def method_missing(method, *args)
       # possibilities:
@@ -134,42 +178,55 @@ module RDFS
 			# action: return namespace proxy that handles 'name' invocation, by 
 			# rewriting into predicate lookup (similar to case (5)
 
-      # maybe change order in which to check these, checking (4) is probably
-      # cheaper than (1)-(2) but (1) and (2) are probably more probable (getting
-      # attribute values over executing custom methods)
-
-      $activerdflog.debug "RDFS::Resource: method_missing on instance: called with method name #{method}"
+      $activerdflog.debug "method_missing: #{method}"
 
       # are we doing an update or not? 
 			# checking if method ends with '='
 
-      if method.to_s[-1..-1] == '='
-        methodname = method.to_s[0..-2]
-        update = true
-      else
-        methodname = method.to_s
-        update = false
+      update = method.to_s[-1..-1] == '='
+      methodname = if update 
+                     method.to_s[0..-2]
+                   else
+                     method.to_s
+                   end
+
+      # extract single values from array unless user asked for eyal.all_age
+      flatten = true
+      if method.to_s[0..3] == 'all_'
+        flatten = false
+        methodname = methodname[4..-1]
       end
 
 			# check possibility (5)
 			if @predicates.include?(methodname)
-				return predicate_invocation(@predicates[methodname], args, update)
+				return predicate_invocation(@predicates[methodname], args, update, flatten)
 			end
 
 			# check possibility (6)
-			if Namespace.abbreviations.include?(method)
+			if Namespace.abbreviations.include?(methodname.to_sym)
 				namespace = Object.new	
-				@@uri = method
+				@@uri = methodname
 				@@subject = self
-				class <<namespace
-					def method_missing(localname, *args)
-						predicate = Namespace.lookup(@@uri, localname)
-						Query.new.distinct(:o).where(@@subject, predicate, :o).execute(:flatten => true)
-					end
+        @@flatten = flatten
+
+        # catch the invocation on the namespace
+        class <<namespace
+          def method_missing(localname, *args)
+            # check if updating or reading predicate value
+            if localname.to_s[-1..-1] == '='
+              # set value
+              predicate = Namespace.lookup(@@uri, localname.to_s[0..-2])
+              args.each { |value| FederationManager.add(@@subject, predicate, value) }
+            else
+              # read value
+              predicate = Namespace.lookup(@@uri, localname)
+              Query.new.distinct(:o).where(@@subject, predicate, :o).execute(:flatten => @@flatten)
+            end
+          end
           private(:type)
-				end
-				return namespace
-			end
+        end
+        return namespace
+      end
 
       candidates = if update
                       (class_level_predicates + direct_predicates).compact.uniq
@@ -180,7 +237,7 @@ module RDFS
 			# checking possibility (1) and (3)
 			candidates.each do |pred|
 				if Namespace.localname(pred) == methodname
-					return predicate_invocation(pred, args, update)
+					return predicate_invocation(pred, args, update, flatten)
 				end
 			end
 			
@@ -299,11 +356,6 @@ module RDFS
 			"<#{uri}>"
 		end
 
-	#	# label of resource (rdfs:label if available, uri otherwise)
-	#  def label
-	#    get_property_value(Namespace.lookup(:rdfs,:label)) || uri
-	#  end
-
 		private
 
 #		def ancestors(predicate)
@@ -311,24 +363,17 @@ module RDFS
 #			Query.new.distinct(:p).where(predicate, subproperty, :p).execute
 #		end
 
-		def predicate_invocation(predicate, args, update)
+		def predicate_invocation(predicate, args, update, flatten)
 			if update
 				args.each do |value|
 					FederationManager.add(self, predicate, value)
 				end
 				args
 			else
-				get_property_value(predicate, args)
+        Query.new.distinct(:o).where(self, predicate, :o).execute(:flatten => flatten)
 			end
 		end
 
-		def get_property_value(predicate, args=[])
-			return_ary = args[0][:array] if args[0].is_a?(Hash)
-			flatten_results = !return_ary
-			query = Query.new.distinct(:o).where(self, predicate, :o)
-			query.execute(:flatten => flatten_results)
-		end  
-
 		# returns all rdf:types of this resource but without a conversion to 
 		# Ruby classes (it returns an array of RDFS::Resources)
 		def types

data/lib/active_rdf/queryengine/query.rb

@@ -6,7 +6,7 @@ require 'federation/federation_manager'
 # data source.  In all clauses symbols represent variables: 
 # Query.new.select(:s).where(:s,:p,:o).
 class Query
-	attr_reader :select_clauses, :where_clauses, :sort_clauses, :keywords, :limits, :offsets
+	attr_reader :select_clauses, :where_clauses, :sort_clauses, :keywords, :limits, :offsets, :reverse_sort_clauses
 	bool_accessor :distinct, :ask, :select, :count, :keyword, :reasoning
 
 	def initialize
@@ -18,6 +18,7 @@ class Query
 		@sort_clauses = []
 		@keywords = {}
 		@reasoning = true
+    @reverse_sort_clauses = []
 	end
 
 	# Clears the select clauses
@@ -57,25 +58,33 @@ class Query
 		select(*s)
 	end
 
-	# Adds sort predicates (must appear in select clause)
+	# Adds sort predicates
 	def sort *s
-		s.each do |e|
-			@sort_clauses << parametrise(e) 
-		end
-		# removing duplicate select clauses
+    # add sort clauses without duplicates
+		s.each { |clause| @sort_clauses << parametrise(clause) }
 		@sort_clauses.uniq!
+
+		self
+	end
+
+  # adds reverse sorting predicates
+  def reverse_sort *s
+    # add sort clauses without duplicates
+		s.each { |clause| @reverse_sort_clauses << parametrise(clause) }
+		@reverse_sort_clauses.uniq!
+
 		self
 	end
 
 	# Adds limit clause (maximum number of results to return)
 	def limit(i)
-		@limits = i 
+		@limits = i.to_i
 		self
 	end
 
 	# Add offset clause (ignore first n results)
 	def offset(i)
-		@offsets = i
+		@offsets = i.to_i
 		self
 	end
 
@@ -128,6 +137,9 @@ class Query
   # usage:: results = query.execute
   # usage:: query.execute do |s,p,o| ... end
   def execute(options={:flatten => false}, &block)
+    options = {:flatten => true} if options == :flatten
+
+    $activerdflog.debug("query: #{self.to_sp}")
     if block_given?
       FederationManager.query(self) do |*clauses|
         block.call(*clauses)
@@ -155,14 +167,10 @@ class Query
   private
   def parametrise s
     case s
-    when Symbol
+    when Symbol, RDFS::Resource, Literal, Class
 			s
-    when RDFS::Resource
-      s
 		when nil
 			nil
-    when Literal
-      s
     else
       '"' + s.to_s + '"'
     end

data/lib/active_rdf/queryengine/query2sparql.rb

@@ -15,11 +15,9 @@ class Query2SPARQL
       str << "ASK { #{where_clauses(query)} }"
     end
     
-    $activerdflog.debug "Query2SPARQL: translated the query to #{str}"
     return str
   end
 
-  private
   # concatenate each where clause using space (e.g. 's p o')
   # and concatenate the clauses using dot, e.g. 's p o . s2 p2 o2 .'
   def self.where_clauses(query)
@@ -31,17 +29,17 @@ class Query2SPARQL
   end
 
 	def self.construct_clause(term)
-		case term
-		when Symbol
-			'?' + term.to_s
-		when RDFS::Resource
-			'<' + term.uri + '>'
-		else
-			term.to_s
-		end
+    if term.respond_to? :uri
+      '<' + term.uri + '>'
+    else
+      case term
+      when Symbol
+        '?' + term.to_s
+      else
+        term.to_s
+      end
+    end
 	end
 	
-  #declare the class level methods as private with these directives
-  private_class_method :where_clauses
-  private_class_method :construct_clause
+  private_class_method :where_clauses, :construct_clause
 end

data/lib/active_rdf.rb

@@ -23,7 +23,7 @@ def load_adapter s
   begin
     require s
   rescue Exception => e
-    $activerdflog.warn "could not load adapter #{s}: #{e}"
+    $activerdflog.info "could not load adapter #{s}: #{e}"
   end
 end
 

data/lib/active_rdf_log.rb

@@ -1,7 +1,7 @@
 require 'logger'
 
 # use either $ACTIVE_RDF_LOG for logging or current directory
-location = ENV['ACTIVE_RDF_LOG'] || "#{Dir.pwd}/activerdf.log"
+location = ENV['ACTIVE_RDF_LOG'] || $stdout # "#{Dir.pwd}/activerdf.log"
 location = $stdout if location == "STDOUT"
 $activerdflog = Logger.new(location, 1, 100*1024)
     

data/test/common.rb

@@ -27,8 +27,12 @@ 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) and existing_adapter.class != RDFLite
-		ConnectionPool.add :type => :rdflite
+  if types.include?(:rdflite)
+    if existing_adapter.class == RDFLite
+      ConnectionPool.add :type => :rdflite, :unique => true
+    else
+      ConnectionPool.add :type => :rdflite
+    end
 	elsif types.include?(:redland) and existing_adapter.class != RedlandAdapter
 		ConnectionPool.add :type => :redland
 	elsif types.include?(:sparql) and existing_adapter.class != SparqlAdapter
@@ -78,8 +82,12 @@ 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) and existing_adapter.class != RDFLite
-		ConnectionPool.add :type => :rdflite
+	if types.include?(:rdflite)
+    if existing_adapter.class == RDFLite
+      ConnectionPool.add :type => :rdflite, :unique => true
+    else
+      ConnectionPool.add :type => :rdflite
+    end
 	elsif types.include?(:redland) and existing_adapter.class != RedlandAdapter
 		ConnectionPool.add :type => :redland
 	elsif types.include?(:yars) and existing_adapter.class != YarsAdapter

data/test/objectmanager/test_object_manager.rb

@@ -33,10 +33,10 @@ class TestObjectManager < Test::Unit::TestCase
 		Namespace.register(:test, 'http://activerdf.org/test/')
 		ObjectManager.construct_classes
 
-		assert(defined? TEST, "class construction should have created module TEST")
-		assert(defined? RDFS, "class construction should have created module RDFS")
-		assert(defined? TEST::Person, "class construction should have created TEST::Person")
-		assert(defined? RDFS::Class, "class construction should have created RDFS::Class")
+		assert(defined? TEST)
+		assert(defined? RDFS)
+		assert(defined? TEST::Person)
+		assert(defined? RDFS::Class)
   end
 
 	def test_class_construct_class
@@ -49,4 +49,16 @@ class TestObjectManager < Test::Unit::TestCase
 		assert_instance_of Class, person_class
 		assert_equal person_resource.uri, person_class.class_uri.uri
 	end
+
+  def test_class_uri
+		adapter = get_write_adapter
+		adapter.load "#{File.dirname(__FILE__)}/../test_person_data.nt"
+		Namespace.register(:test, 'http://activerdf.org/test/')
+		ObjectManager.construct_classes
+
+    assert_equal RDFS::Resource.new('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'), RDF::type
+    assert_equal RDF::type, RDFS::Resource.new('http://www.w3.org/1999/02/22-rdf-syntax-ns#type')
+    assert_equal TEST::Person, RDFS::Resource.new('http://activerdf.org/test/Person')
+    assert_equal RDFS::Resource.new('http://activerdf.org/test/Person'), TEST::Person
+  end
 end

data/test/objectmanager/test_resource_reading.rb

@@ -10,7 +10,8 @@ require "#{File.dirname(__FILE__)}/../common"
 class TestResourceReading < Test::Unit::TestCase
   def setup
 		ConnectionPool.clear
-    @adapter = get_read_only_adapter
+    @adapter = get_adapter
+    @adapter.load "#{File.dirname(__FILE__)}/../test_person_data.nt"
     Namespace.register(:test, 'http://activerdf.org/test/')
     ObjectManager.construct_classes
 
@@ -21,12 +22,12 @@ class TestResourceReading < Test::Unit::TestCase
   end
 
   def test_find_all_instances
-    assert_equal 36, RDFS::Resource.find_all.size
-    assert_equal [@eyal], TEST::Person.find_all
+    assert_equal 7, RDFS::Resource.find_all.size
+    assert_equal [TEST::eyal, TEST::other], TEST::Person.find_all
   end
 
   def test_class_predicates
-    assert_equal 10, RDFS::Resource.predicates.size
+    assert_equal 4, RDFS::Resource.predicates.size
   end
 
   def test_eyal_predicates
@@ -39,9 +40,9 @@ class TestResourceReading < Test::Unit::TestCase
 
 		# 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
+		# eyal.type: person and resource, has predicates age, eye
+		# not default rdfs:label, rdfs:comment, etc. because not using rdfs reasoning
+    assert_equal 4, class_preds.size
   end
 
   def test_eyal_types
@@ -54,9 +55,13 @@ class TestResourceReading < Test::Unit::TestCase
   def test_eyal_age
     # triple exists '<eyal> age 27'
     assert_equal '27', @eyal.age
+    assert_equal '27', @eyal.test::age
+    assert_equal ['27'], @eyal.all_age
 
     # Person has property car, but eyal has no value for it
     assert_equal nil, @eyal.car
+    assert_equal nil, @eyal.test::car
+    assert_equal [], @eyal.all_test::car
 
     # non-existent method should throw error
     assert_equal nil, @eyal.non_existing_method
@@ -67,6 +72,22 @@ class TestResourceReading < Test::Unit::TestCase
     assert_instance_of TEST::Person, @eyal
   end
 
+  def test_find_options
+    all = [Namespace.lookup(:test,:Person), Namespace.lookup(:rdfs, :Class), Namespace.lookup(:rdf, :Property), @eyal, TEST::car, TEST::age, TEST::eye]
+    found = RDFS::Resource.find
+    assert_equal all.sort, found.sort
+
+    properties = [TEST::car, TEST::age, TEST::eye]
+    found = RDFS::Resource.find(:where => {RDFS::domain => RDFS::Resource})
+    assert_equal properties.sort, found.sort
+
+    found = RDFS::Resource.find(:where => {RDFS::domain => RDFS::Resource, :prop => :any})
+    assert_equal properties.sort, found.sort
+
+    found = TEST::Person.find(:order => TEST::age)
+    assert_equal [TEST::other, TEST::eyal], found
+  end
+
   def test_find_methods
     assert_equal @eyal, RDFS::Resource.find_by_eye('blue')
     assert_equal @eyal, RDFS::Resource.find_by_test::eye('blue')
@@ -82,6 +103,8 @@ class TestResourceReading < Test::Unit::TestCase
 
   # test for writing if no write adapter is defined (like only sparqls)
   def test_write_without_write_adapter
-    assert_raises(ActiveRdfError) { @eyal.age = 18 }
+    ConnectionPool.clear
+    get_read_only_adapter
+    assert_raises(ActiveRdfError) { @eyal.test::age = 18 }
   end
 end

data/test/objectmanager/test_resource_writing.rb

@@ -18,9 +18,13 @@ class TestResourceWriting < Test::Unit::TestCase
 
     eyal = RDFS::Resource.new 'http://activerdf.org/test/eyal'
     assert_raises(ActiveRdfError) { eyal.age = 18 }
+
+    assert_nothing_raised { eyal.ar::age = 100 }
+    assert_equal '100', eyal.ar::age
+    assert_equal ['100'], eyal.all_ar::age
    
     adapter.load "#{File.dirname(__FILE__)}/../test_person_data.nt"
     assert_nothing_raised { eyal.age = 18 }
-    assert_equal ['18','27'], eyal.age
+    assert_equal ['100', '18', '27'], eyal.age
   end
 end

data/test/test_person_data.nt

@@ -2,6 +2,8 @@
 <http://activerdf.org/test/Person> <http://www.w3.org/2000/01/rdf-schema#subClassOf> <http://www.w3.org/2000/01/rdf-schema#Resource> .
 <http://activerdf.org/test/eyal> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://activerdf.org/test/Person> .
 <http://activerdf.org/test/eyal> <http://activerdf.org/test/age> "27" .
+<http://activerdf.org/test/other> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://activerdf.org/test/Person> .
+<http://activerdf.org/test/other> <http://activerdf.org/test/age> "21" .
 <http://activerdf.org/test/eyal> <http://activerdf.org/test/eye> "blue" .
 <http://activerdf.org/test/age> <http://www.w3.org/2000/01/rdf-schema#domain> <http://www.w3.org/2000/01/rdf-schema#Resource> .
 <http://activerdf.org/test/eye> <http://www.w3.org/2000/01/rdf-schema#domain> <http://www.w3.org/2000/01/rdf-schema#Resource> .

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: activerdf
 version: !ruby/object:Gem::Version 
-  version: "1.4"
-date: 2007-02-27 00:00:00 +00:00
+  version: "1.5"
+date: 2007-04-12 00:00:00 +01:00
 summary: Offers object-oriented access to RDF (with adapters to several datastores).
 require_paths: 
 - lib
@@ -38,36 +38,36 @@ files:
 - test/common.rb
 - test/test_adapters.rb
 - test/test_person_data.nt
-- test/federation/test_connection_pool.rb
 - test/federation/test_federation_manager.rb
+- test/federation/test_connection_pool.rb
+- test/objectmanager/test_resource_reading.rb
+- test/objectmanager/test_literal.rb
 - test/objectmanager/test_namespace.rb
 - test/objectmanager/test_object_manager.rb
-- test/objectmanager/test_resource_reading.rb
 - test/objectmanager/test_resource_writing.rb
-- test/objectmanager/test_literal.rb
+- test/queryengine/test_ntriples_parser.rb
 - test/queryengine/test_query.rb
 - test/queryengine/test_query2jars2.rb
 - test/queryengine/test_query2sparql.rb
 - test/queryengine/test_query_engine.rb
-- test/queryengine/test_ntriples_parser.rb
 - lib/active_rdf
 - lib/active_rdf.rb
-- lib/active_rdf_helpers.rb
 - lib/active_rdf_log.rb
+- lib/active_rdf_helpers.rb
 - lib/active_rdf/federation
 - lib/active_rdf/objectmanager
 - lib/active_rdf/queryengine
-- lib/active_rdf/federation/active_rdf_adapter.rb
 - lib/active_rdf/federation/connection_pool.rb
 - lib/active_rdf/federation/federation_manager.rb
-- lib/active_rdf/objectmanager/namespace.rb
-- lib/active_rdf/objectmanager/object_manager.rb
+- lib/active_rdf/federation/active_rdf_adapter.rb
 - lib/active_rdf/objectmanager/resource.rb
+- lib/active_rdf/objectmanager/namespace.rb
 - lib/active_rdf/objectmanager/literal.rb
+- lib/active_rdf/objectmanager/object_manager.rb
 - lib/active_rdf/queryengine/query.rb
-- lib/active_rdf/queryengine/query2jars2.rb
 - lib/active_rdf/queryengine/query2sparql.rb
 - lib/active_rdf/queryengine/ntriples_parser.rb
+- lib/active_rdf/queryengine/query2jars2.rb
 test_files: []
 
 rdoc_options: []