activerdf 1.3.1 → 1.4

data/CHANGELOG

@@ -1,3 +1,7 @@
+== 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)
+
 == activerdf (1.3.1) Mon, 19 Feb 2007 17:04:57 +0000
   * fixed type-checking bug in query.rb
   * added language support to literals

data/lib/active_rdf/objectmanager/namespace.rb

@@ -10,6 +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?)
+    raise ActiveRdfError, "namespace uri should end with # or /" unless /\/|#/ =~ fullURI.to_s[-1..-1]
 		$activerdflog.info "Namespace: registering #{fullURI} to #{prefix}"
     @@namespaces[prefix.to_sym] = fullURI.to_s
     @@inverted_namespaces[fullURI.to_s] = prefix.to_sym

data/lib/active_rdf/objectmanager/resource.rb

@@ -67,42 +67,21 @@ module RDFS
       Query.new.distinct(:p).where(:p, domain, class_uri).execute || []
     end
 
-    # manages invocations such as Person.find_by_name
+    # manages invocations such as Person.find_by_name, 
+    # Person.find_by_foaf::name, Person.find_by_foaf::name_and_foaf::knows, etc.
     def Resource.method_missing(method, *args)
-      method_name = method.to_s
+      if /find_by_(.+)/.match(method.to_s)
+        $activerdflog.debug "constructing dynamic finder for #{method}"
 
-      $activerdflog.debug "RDFS::Resource: method_missing on class: called with method name #{method}"
+        # construct proxy to handle delayed lookups 
+        # (find_by_foaf::name_and_foaf::age)
+        proxy = DynamicFinderProxy.new($1, nil, *args)
 
-      # extract predicates on which to match
-      # e.g. find_by_name, find_by_name_and_age
-      if match = /find_by_(.+)/.match(method_name)
-        # find searched attributes, e.g. name, age
-        attributes = match[1].split('_and_')
-
-        # get list of possible predicates for this class
-        possible_predicates = predicates
-
-        # build query looking for all resources with the given parameters
-        query = Query.new.distinct(:s)
-
-        # add where clause for each attribute-value pair,
-        # looking into possible_predicates to figure out
-        # which full-URI to use for each given parameter (heuristic)
-
-        attributes.each_with_index do |atr,i|
-          possible_predicates.each do |pred|
-            query.where(:s, pred, args[i]) if Namespace.localname(pred) == atr
-          end
-        end
-
-        # execute query
-        $activerdflog.debug "RDFS::Resource: method_missing on class: executing query: #{query}"
-        return query.execute(:flatten => true)
+        # if proxy already found a value (find_by_name) we will not get a more 
+        # complex query, so return the value. Otherwise, return the proxy so that 
+        # subsequent lookups are handled
+        return proxy.value || proxy
       end
-
-      # otherwise, if no match found, raise NoMethodError (in superclass)
-      $activerdflog.warn 'RDFS::Resource: method_missing on class: method not matching find_by_*'
-      super
     end
 
     # returns array of all instances of this class (e.g. Person.find_all)
@@ -187,6 +166,7 @@ module RDFS
 						predicate = Namespace.lookup(@@uri, localname)
 						Query.new.distinct(:o).where(@@subject, predicate, :o).execute(:flatten => true)
 					end
+          private(:type)
 				end
 				return namespace
 			end
@@ -302,8 +282,8 @@ module RDFS
 			else
 				q = Query.new.select(:p)
 			end
-			direct = q.where(self,:p, :o).execute
-			return (direct + direct.collect {|d| ancestors(d)}).flatten.uniq
+			q.where(self,:p, :o).execute
+			#return (direct + direct.collect {|d| ancestors(d)}).flatten.uniq
 		end
 
 		def property_accessors
@@ -326,10 +306,10 @@ module RDFS
 
 		private
 
-		def ancestors(predicate)
-			subproperty = Namespace.lookup(:rdfs,:subPropertyOf)
-			Query.new.distinct(:p).where(predicate, subproperty, :p).execute
-		end
+#		def ancestors(predicate)
+#			subproperty = Namespace.lookup(:rdfs,:subPropertyOf)
+#			Query.new.distinct(:p).where(predicate, subproperty, :p).execute
+#		end
 
 		def predicate_invocation(predicate, args, update)
 			if update
@@ -366,3 +346,80 @@ module RDFS
 		end
 	end
 end
+
+# proxy to manage find_by_ invocations
+class DynamicFinderProxy
+  @ns = nil
+  @where = nil
+  @value = nil
+  attr_reader :value
+
+  # construct proxy from find_by text
+  # foaf::name
+  def initialize(find_string, where, *args)
+    @where = where || []
+    parse_attributes(find_string, *args)
+  end
+
+  def method_missing(method, *args)
+    # we store the ns:name for later (we need to wait until we have the 
+    # arguments before actually constructing the where clause): now we just 
+    # store that a where clause should appear about foaf:name
+
+    # if this method is called name_and_foaf::age we add ourself to the query
+    # otherwise, the query is built: we execute it and return the results
+    if method.to_s.include?('_and_')
+      parse_attributes(method.to_s, *args)
+    else
+      @where << Namespace.lookup(@ns, method.to_s)
+      query(*args)
+    end
+  end
+
+  private 
+  # split find_string by occurrences of _and_
+  def parse_attributes string, *args
+    attributes = string.split('_and_')
+    attributes.each do |atr|
+      # attribute can be:
+      # - a namespace prefix (foaf): store prefix in @ns to prepare for method_missing
+      # - name (attribute name): store in where to prepare for method_missing
+      if Namespace.abbreviations.include?(atr.to_sym)
+        @ns = atr.to_s.downcase.to_sym
+      else
+        # found simple attribute label, e.g. 'name'
+        # find out candidate (full) predicate for this localname: investigate 
+        # all possible predicates and select first one with matching localname
+        candidates = Query.new.distinct(:p).where(:s,:p,:o).execute
+        @where << candidates.select {|cand| Namespace.localname(cand) == atr}.first
+      end
+    end
+
+    # if the last attribute was a prefix, return this dynamic finder (we'll 
+    # catch the following method_missing and construct the real query then)
+    # if the last attribute was a localname, construct the query now and return 
+    # the results
+    if Namespace.abbreviations.include?(attributes.last.to_sym)
+      return self
+    else
+      return query(*args)
+    end
+  end
+
+  # construct and execute finder query
+  def query(*args)
+    query = Query.new.distinct(:s)
+    @where.each_with_index do |predicate, i|
+      query.where(:s, predicate, args[i])
+    end
+
+    $activerdflog.debug "executing dynamic finder: #{query.to_sp}"
+
+    # store the query results so that caller (Resource.method_missing) can 
+    # retrieve them (we cannot return them here, since we were invoked from 
+    # the initialize method so all return values are ignored, instead the proxy 
+    # itself is returned)
+    @value = query.execute(:flatten => true)
+    return value
+  end
+end

data/lib/active_rdf/queryengine/ntriples_parser.rb

@@ -3,38 +3,48 @@
 # License:: LGPL
 require 'active_rdf'
 require 'uuidtools'
+require 'strscan'
 
 # ntriples parser
 class NTriplesParser
   # parses an input string of ntriples and returns a nested array of [s, p, o] 
   # (which are in turn ActiveRDF objects)
   def self.parse(input)
-
 		# need unique identifier for this batch of triples (to detect occurence of 
 		# same bnodes _:#1
 		uuid = UUID.random_create.to_s
 
     input.collect do |triple|
-			nodes = triple.scan(Node)
+      nodes = []
+      scanner = StringScanner.new(triple)
+      scanner.skip(/\s+/)
+      while not scanner.eos?
+        nodes << scanner.scan(Node)
+        scanner.skip(/\s+/)
+        scanner.terminate if nodes.size == 3 
+      end
 
 			# handle bnodes if necessary (bnodes need to have uri generated)
 			subject = case nodes[0]
 								when BNode
 									RDFS::Resource.new("http://www.activerdf.org/bnode/#{uuid}/#$1")
-								else
-									RDFS::Resource.new(nodes[0])
+                when Resource
+									RDFS::Resource.new($1)
 								end
 
-			predicate = RDFS::Resource.new(nodes[1])
+      predicate = case nodes[1]
+                  when Resource
+                    RDFS::Resource.new($1)
+                  end
 
 			# handle bnodes and literals if necessary (literals need unicode fixing)
 			object = case nodes[2]
 							 when BNode
 								 RDFS::Resource.new("http://www.activerdf.org/bnode/#{uuid}/#$1")
 							 when Literal
-								 fix_unicode(nodes[2])
-							 else
-								 RDFS::Resourec.new(nodes[2])
+								 fix_unicode($1)
+               when Resource
+								 RDFS::Resource.new($1)
 							 end
 
       # collect s, p, o into array to be returned
@@ -44,10 +54,10 @@ class NTriplesParser
 
 	private
 	# constants for extracting resources/literals from sql results
-	Node = Regexp.union(/_:\S*/,/<[^>]*>/,/"[^"]*"/)
+	Node = Regexp.union(/"(?:\\"|[^"])*"/,/_:\S*/,/<[^>]*>/)
 	BNode = /_:(\S*)/
 	Resource = /<([^>]*)>/
-	Literal = /"([^"]*)"/
+	Literal = /"((?:\\"|[^"])*)"/
 
 	# fixes unicode characters in literals (because we parse them wrongly somehow)
 	def self.fix_unicode(str)

data/test/objectmanager/test_resource_reading.rb

@@ -11,7 +11,7 @@ class TestResourceReading < Test::Unit::TestCase
   def setup
 		ConnectionPool.clear
     @adapter = get_read_only_adapter
-    Namespace.register(:ar, 'http://activerdf.org/test/')
+    Namespace.register(:test, 'http://activerdf.org/test/')
     ObjectManager.construct_classes
 
     @eyal = RDFS::Resource.new 'http://activerdf.org/test/eyal'
@@ -22,7 +22,7 @@ class TestResourceReading < Test::Unit::TestCase
 
   def test_find_all_instances
     assert_equal 36, RDFS::Resource.find_all.size
-    assert_equal [@eyal], AR::Person.find_all
+    assert_equal [@eyal], TEST::Person.find_all
   end
 
   def test_class_predicates
@@ -47,7 +47,7 @@ class TestResourceReading < Test::Unit::TestCase
   def test_eyal_types
     types = @eyal.type
 		assert_equal 2, types.size
-		assert types.include?(AR::Person)
+		assert types.include?(TEST::Person)
 		assert types.include?(RDFS::Resource)
   end
 
@@ -64,15 +64,20 @@ class TestResourceReading < Test::Unit::TestCase
 
   def test_eyal_type
     assert_instance_of RDFS::Resource, @eyal
-    assert_instance_of AR::Person, @eyal
+    assert_instance_of TEST::Person, @eyal
   end
 
   def test_find_methods
-    found_eyal = RDFS::Resource.find_by_eye('blue')
-    assert_not_nil found_eyal
-    assert_equal @eyal, found_eyal
-    assert_equal 'blue', RDFS::Resource.find_by_age(27).eye
-    assert_equal @eyal, RDFS::Resource.find_by_age_and_eye(27,'blue')
+    assert_equal @eyal, RDFS::Resource.find_by_eye('blue')
+    assert_equal @eyal, RDFS::Resource.find_by_test::eye('blue')
+
+    assert_equal @eyal, RDFS::Resource.find_by_age(27)
+    assert_equal @eyal, RDFS::Resource.find_by_test::age(27)
+
+    assert_equal @eyal, RDFS::Resource.find_by_age_and_eye(27, 'blue')
+    assert_equal @eyal, RDFS::Resource.find_by_test::age_and_test::eye(27, 'blue')
+    assert_equal @eyal, RDFS::Resource.find_by_test::age_and_eye(27, 'blue')
+    assert_equal @eyal, RDFS::Resource.find_by_age_and_test::eye(27, 'blue')
   end
 
   # test for writing if no write adapter is defined (like only sparqls)

data/test/queryengine/test_ntriples_parser.rb

@@ -14,18 +14,43 @@ class TestNTriplesParser < Test::Unit::TestCase
   def teardown
   end
 
-  def test_the_parser
+  def test_simple_triples
     str = <<EOF
 <http://www.johnbreslin.com/blog/author/cloud/#foaf> <http://xmlns.com/foaf/0.1/surname> "Breslin" .
 <http://www.johnbreslin.com/blog/author/cloud/#foaf> <http://xmlns.com/foaf/0.1/firstName> "John" .
 <http://www.johnbreslin.com/blog/author/cloud/> <http://purl.org/dc/terms/created> "1999-11-30T00:00:00" .  				
 EOF
     
-    results = NTriplesParser.parse(str)
-    assert_equal 9, results.flatten.size
-    assert_equal 3, results[0].size
+    triples = NTriplesParser.parse(str)
+    assert_equal 9, triples.flatten.size
+    assert_equal 3, triples[0].size
 
-    assert_equal RDFS::Resource, results[0][0].class
-    assert_equal String, results[0][2].class
+    assert_equal RDFS::Resource.new('http://www.johnbreslin.com/blog/author/cloud/#foaf'), triples[0][0]
+    assert_equal RDFS::Resource.new('http://xmlns.com/foaf/0.1/surname'), triples[0][1]
+    assert_equal 'Breslin', triples[0][2]
+  end
+
+  def test_encoded_content
+    str = <<'EOF'
+  <http://b4mad.net/datenbrei/archives/2004/07/15/brainstream-his-own-foafing-in-wordpress/#comment-10> <http://purl.org/rss/1.0/modules/content/encoded> "<p>Heh - excellent. Are we leaving Morten in the dust? :) I know he had some bu gs to fix in his version.</p>\n<p>Also, I think we should really add the foaf: in front of the foaf properties to ma ke it easier to read. </p>\n<p>Other hack ideas:</p>\n<p>* Birthdate in month/date/year (seperate fields) to add bio :Event/ bio:Birth and then say who can see the birth year, birth day/mo and full birth date.<br />\n* Add trust leve ls to friends<br />\n* Storing ones PGP key/key fingerprint in Wordpress and referencing it as user_pubkey/user_pubk eyprint respectively<br />\n* Add gender, depiction picture for profile, myers-brigs, astrological sign fields to Pr ofile.<br />\n* Add the option to create Projects/Groups user is involved with re: their Profile.<br />\n* Maybe add phone numbers/address/geo location? Essentially make it a VCard that can be foafified.\n</p>\n" .
+EOF
+    literal = '<p>Heh - excellent. Are we leaving Morten in the dust? :) I know he had some bu gs to fix in his version.</p>\n<p>Also, I think we should really add the foaf: in front of the foaf properties to ma ke it easier to read. </p>\n<p>Other hack ideas:</p>\n<p>* Birthdate in month/date/year (seperate fields) to add bio :Event/ bio:Birth and then say who can see the birth year, birth day/mo and full birth date.<br />\n* Add trust leve ls to friends<br />\n* Storing ones PGP key/key fingerprint in Wordpress and referencing it as user_pubkey/user_pubk eyprint respectively<br />\n* Add gender, depiction picture for profile, myers-brigs, astrological sign fields to Pr ofile.<br />\n* Add the option to create Projects/Groups user is involved with re: their Profile.<br />\n* Maybe add phone numbers/address/geo location? Essentially make it a VCard that can be foafified.\n</p>\n'
+
+    triples = NTriplesParser.parse(str)
+    assert_equal 1, triples.size
+
+    encoded_content = triples.first[2]
+    assert_equal literal, encoded_content
+    assert_equal String, encoded_content.class
+    assert encoded_content.include?('PGP')
+  end
+
+  def test_escaped_quotes
+    string = '<subject> <predicate> "test string with \n breaks and \" escaped quotes" .'
+    literal = 'test string with \n breaks and \" escaped quotes'
+    triples = NTriplesParser.parse(string)
+
+    assert_equal 1, triples.size
+    assert_equal literal, triples.first[2] 
   end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: activerdf
 version: !ruby/object:Gem::Version 
-  version: 1.3.1
-date: 2007-02-19 00:00:00 +00:00
+  version: "1.4"
+date: 2007-02-27 00:00:00 +00:00
 summary: Offers object-oriented access to RDF (with adapters to several datastores).
 require_paths: 
 - lib