activerdf 1.6.8 → 1.6.9

data/CHANGELOG

@@ -1,3 +1,7 @@
+== activerdf (1.6.9) Fri, 08 Feb 2008 13:36:31 +0100
+  * automatic conversion from typed literals to Ruby internal datatypes
+  * added Resource#to_xml (José Ignacio)
+
 == activerdf (1.6.8) Thu, 01 Nov 2007 15:55:38 +0100
   * no need for ObjectManager.construct_classes (done during namespace registration)
   * small fix to running form source on jruby

data/lib/active_rdf/federation/federation_manager.rb

@@ -11,6 +11,13 @@ class FederationManager
     ConnectionPool.write_adapter.add(s,p,o)
   end
 
+  # delete triple s,p,o from the currently selected write adapter (s and p are 
+  # mandatory, o is optional, symbols are interpreted as wildcards)
+  def FederationManager.delete(s,p,o=:all)
+    raise ActiveRdfError, "cannot write without a write-adapter" unless ConnectionPool.write_adapter
+    ConnectionPool.write_adapter.delete(s,p,o)
+  end
+
   # executes read-only queries
   # by distributing query over complete read-pool
   # and aggregating the results

data/lib/active_rdf/instance_exec.rb

@@ -0,0 +1,13 @@
+module Kernel
+ # Like instace_eval but allows parameters to be passed.
+  def instance_exec(*args, &block)
+    mname = "__instance_exec_#{Thread.current.object_id.abs}_#{object_id.abs}"
+    Object.class_eval{ define_method(mname, &block) }
+    begin
+      ret = send(mname, *args)
+    ensure
+      Object.class_eval{ undef_method(mname) } rescue nil
+    end
+    ret
+  end
+end

data/lib/active_rdf/objectmanager/literal.rb

@@ -1,48 +1,65 @@
 require 'active_rdf'
 
-# Represents an RDF literal, optionally datatyped.
-# TODO: language tags
-class Literal
+module Literal
   Namespace.register :xsd, 'http://www.w3.org/2001/XMLSchema#'
+  def xsd_type
+    case self
+    when String
+      XSD::string
+    when Integer
+      XSD::integer
+    when TrueClass, FalseClass
+      XSD::boolean
+    when DateTime, Date, Time
+      XSD::date
+    end
+  end
 
-  attr_reader :value, :type, :language
-  @value, @type, @language = nil, nil, nil
+  def self.typed(value, type)
+    case type
+    when XSD::string
+      String.new(value)
+    when XSD::date
+      DateTime.parse(value)
+    when XSD::boolean
+      value == 'true' or value == 1
+    when XSD::integer
+      value.to_i
+    end
+  end
 
-  # Constructs literal with given datatype. If no datatype is given, automatic 
-  # conversion from Ruby to XSD datatype is tried.
-  def initialize(value, type_or_language=nil)
-    @value = value
-    
-    if type_or_language.nil?
-      # deduce type from the given value
-      @type = case value
-               when String
-                 XSD::string
-               when Date, Time, DateTime
-                 XSD::date
-               when TrueClass, FalseClass
-                 XSD::boolean
-               when Fixnum
-                 XSD::integer
-        end
-    elsif type_or_language[0..0] == "@"
-      # a language tag has been given
-      @language = type_or_language[1..type_or_language.length]
+  def to_ntriple
+    if $activerdf_without_xsdtype
+      "\"#{to_s}\""
     else
-      # the type_or_language was not empty and did not start with a @ so it must be a data type
-      @type = type_or_language
-    end  
+      "\"#{to_s}\"^^#{xsd_type}"
+    end
+  end
+end
+
+class String; include Literal; end
+class Integer; include Literal; end
+class DateTime; include Literal; end
+class Date; include Literal; end
+class Time; include Literal; end
+class TrueClass; include Literal; end
+class FalseClass; include Literal; end
+
+class LocalizedString < String
+  include Literal
+  attr_reader :lang
+  def initialize value, lang=nil
+    super(value)
 
+    @lang = lang
+    @lang = lang[1..-1] if @lang[0..0] == '@'
   end
 
-  # returns string serialisation of literal, e.g. "test"^^xsd:string
-  def to_s
-    if type
-      "\"#{value}\"^^#{type.to_s}"
-    elsif language
-      "\"#{value}\"@#{language}"
+  def to_ntriple
+    if @lang
+      "\"#{to_s}\"@#@lang"
     else
-      "\"value\""
+      super
     end
   end
 end

data/lib/active_rdf/objectmanager/resource.rb

@@ -2,9 +2,7 @@ require 'active_rdf'
 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.
+require 'instance_exec'
 
 module RDFS
 	# Represents an RDF resource and manages manipulations of that resource,
@@ -28,7 +26,7 @@ module RDFS
             # allow Resource.new(other_resource)
             when RDFS::Resource
              uri.uri
-            # allow Resource.new(<uri>) by stripping out <>
+            # allow Resource.new('<uri>') by stripping out <>
             when /^<([^>]*)>$/
               $1
             # allow Resource.new('uri')
@@ -55,21 +53,53 @@ module RDFS
     ##### start of instance-level code
     #####                        ######
 
+    def abbreviation; [Namespace.prefix(uri).to_s, localname]; end
     # a resource is same as another if they both represent the same uri
-    def ==(other)
+    def ==(other);
       other.respond_to?(:uri) ? other.uri == self.uri : false
     end
     alias_method 'eql?','=='
 
     # overriding hash to use uri.hash
     # needed for array.uniq
-    def hash
-      uri.hash
-    end
+    def hash; uri.hash; end
 
     # overriding sort based on uri
-    def <=>(other)
-      uri <=> other.uri
+    def <=>(other); uri <=> other.uri; end
+    def to_ntriple; "<#{uri}>"; end
+    def self.to_ntriple; "<#{class_uri.uri}>"; end
+
+    def to_xml
+      base = Namespace.expand(Namespace.prefix(self),'').chop
+
+      xml = "<?xml version=\"1.0\"?>\n"
+      xml += "<rdf:RDF xmlns=\"#{base}\#\"\n"
+      Namespace.abbreviations.each { |p| uri = Namespace.expand(p,''); xml += "  xmlns:#{p.to_s}=\"#{uri}\"\n" if uri != base + '#' }
+      xml += "  xml:base=\"#{base}\">\n"
+
+      xml += "<rdf:Description rdf:about=\"\##{localname}\">\n"
+      direct_predicates.each do |p|
+        objects = Query.new.distinct(:o).where(self, p, :o).execute
+        objects.each do |obj|
+          prefix, localname = Namespace.prefix(p), Namespace.localname(p)
+          pred_xml = if prefix
+                       "%s:%s" % [prefix, localname]
+                     else
+                       p.uri
+                     end
+
+          case obj
+          when RDFS::Resource
+            xml += "  <#{pred_xml} rdf:resource=\"#{obj.uri}\"/>\n"
+          when LocalizedString
+            xml += "  <#{pred_xml} xml:lang=\"#{obj.lang}\">#{obj}</#{pred_xml}>\n"
+          else
+            xml += "  <#{pred_xml} rdf:datatype=\"#{obj.xsd_type.uri}\">#{obj}</#{pred_xml}>\n"
+          end
+        end
+      end
+      xml += "</rdf:Description>\n"
+      xml += "</rdf:RDF>"
     end
 
     #####                   	#####
@@ -217,7 +247,11 @@ module RDFS
 
 			# check possibility (5)
 			if @predicates.include?(methodname)
-				return predicate_invocation(@predicates[methodname], args, update, flatten)
+        if update
+          return set_predicate(@predicates[methodname], args)
+        else
+          return get_predicate(@predicates[methodname])
+        end
 			end
 
 			# check possibility (6)
@@ -229,16 +263,18 @@ module RDFS
 
         # 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) }
+          def method_missing(localname, *values)
+            update = localname.to_s[-1..-1] == '='
+            predicate = if update 
+                          Namespace.lookup(@@uri, localname.to_s[0..-2])
+                        else
+                          Namespace.lookup(@@uri, localname)
+                        end
+            
+            if update
+              @@subject.set_predicate(predicate, values)
             else
-              # read value
-              predicate = Namespace.lookup(@@uri, localname)
-              Query.new.distinct(:o).where(@@subject, predicate, :o).execute(:flatten => @@flatten)
+              @@subject.get_predicate(predicate, @@flatten)
             end
           end
           private(:type)
@@ -255,7 +291,11 @@ module RDFS
 			# checking possibility (1) and (3)
 			candidates.each do |pred|
 				if Namespace.localname(pred) == methodname
-					return predicate_invocation(pred, args, update, flatten)
+          if update
+            return set_predicate(pred, args)
+          else
+            return get_predicate(pred, flatten)
+          end
 				end
 			end
 			
@@ -357,12 +397,10 @@ module RDFS
 		# returns all predicates that are directly defined for this resource
 		def direct_predicates(distinct = true)
 			if distinct
-				q = Query.new.distinct(:p)
+				Query.new.distinct(:p).where(self, :p, :o).execute
 			else
-				q = Query.new.select(:p)
+				Query.new.select(:p).where(self, :p, :o).execute
 			end
-			q.where(self,:p, :o).execute
-			#return (direct + direct.collect {|d| ancestors(d)}).flatten.uniq
 		end
 
 		def property_accessors
@@ -378,28 +416,44 @@ module RDFS
 			"<#{uri}>"
 		end
 
-    ## TODO: ensure that we don't use this anywhere before removing it!!
-    #def Resource.to_s
-    #  "<#{uri}>"
-    #end
+		def set_predicate(predicate, values)
+      FederationManager.delete(self, predicate)
+      values.flatten.each {|v| FederationManager.add(self, predicate, v) }
+      values
+    end
 
-		private
+    def get_predicate(predicate, flatten=false)
+      values = Query.new.distinct(:o).where(self, predicate, :o).execute(:flatten => flatten)
+
+      # TODO: fix '<<' for Fixnum values etc (we cannot use values.instance_eval 
+      # because Fixnum cannot do instace_eval, they're not normal classes)
+      if values.is_a?(RDFS::Resource) and !values.nil?
+        # prepare returned values for accepting << later, eg. in
+        # eyal.foaf::knows << knud
+        #
+        # store @subject, @predicate in returned values
+        values.instance_exec(self, predicate) do |s,p|
+          @subj = s
+          @pred = p
+        end
 
+        # overwrite << to add triple to db
+        values.instance_eval do
+          def <<(value)
+            FederationManager.add(@subj, @pred, value)
+          end
+        end
+      end
+
+      values
+    end
+
+		private
 #		def ancestors(predicate)
 #			subproperty = Namespace.lookup(:rdfs,:subPropertyOf)
 #			Query.new.distinct(:p).where(predicate, subproperty, :p).execute
 #		end
 
-		def predicate_invocation(predicate, args, update, flatten)
-			if update
-				args.each do |value|
-					FederationManager.add(self, predicate, value)
-				end
-				args
-			else
-        Query.new.distinct(:o).where(self, predicate, :o).execute(:flatten => flatten)
-			end
-		end
 
 		# returns all rdf:types of this resource but without a conversion to 
 		# Ruby classes (it returns an array of RDFS::Resources)
@@ -519,6 +573,6 @@ class DynamicFinderProxy
     # the initialize method so all return values are ignored, instead the proxy 
     # itself is returned)
     @value = query.execute
-    return value
+    return @value
   end
 end

data/lib/active_rdf/queryengine/ntriples_parser.rb

@@ -7,6 +7,24 @@ require 'strscan'
 
 # ntriples parser
 class NTriplesParser
+  def self.parse_node input
+    case input
+    when MatchBNode
+      RDFS::Resource.new("http://www.activerdf.org/bnode/#{UUID.random_create}/#$1")
+    when MatchLiteral
+      value = fix_unicode($1)
+      if $2
+        Literal.typed(value, RDFS::Resource.new($2))
+      else
+        value
+      end
+    when MatchResource
+      RDFS::Resource.new($1)
+    else
+      nil
+    end
+  end
+
   # 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)
@@ -19,31 +37,36 @@ class NTriplesParser
       scanner = StringScanner.new(triple)
       scanner.skip(/\s+/)
       while not scanner.eos?
-        nodes << scanner.scan(Node)
+        nodes << scanner.scan(MatchNode)
         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
+								when MatchBNode
 									RDFS::Resource.new("http://www.activerdf.org/bnode/#{uuid}/#$1")
-                when Resource
+                when MatchResource
 									RDFS::Resource.new($1)
 								end
 
       predicate = case nodes[1]
-                  when Resource
+                  when MatchResource
                     RDFS::Resource.new($1)
                   end
 
 			# handle bnodes and literals if necessary (literals need unicode fixing)
 			object = case nodes[2]
-							 when BNode
+							 when MatchBNode
 								 RDFS::Resource.new("http://www.activerdf.org/bnode/#{uuid}/#$1")
-							 when Literal
-								 fix_unicode($1)
-               when Resource
+							 when MatchLiteral
+                 value = fix_unicode($1)
+                 if $2
+                   Literal.typed(value, RDFS::Resource.new($2))
+                 else
+                   value
+                 end
+               when MatchResource
 								 RDFS::Resource.new($1)
 							 end
 
@@ -54,10 +77,10 @@ class NTriplesParser
 
 	private
 	# constants for extracting resources/literals from sql results
-	Node = Regexp.union(/"(?:\\"|[^"])*"/,/_:\S*/,/<[^>]*>/)
-	BNode = /_:(\S*)/
-	Resource = /<([^>]*)>/
-	Literal = /"((?:\\"|[^"])*)"/
+	MatchNode = Regexp.union(/"(?:\\"|[^"])*"(?:\^\^\S+)?/,/_:\S*/,/<[^>]*>/)
+	MatchBNode = /_:(\S*)/
+	MatchResource = /<([^>]*)>/
+	MatchLiteral = /"((?:\\"|[^"])*)"(?:\^\^<(\S+)>)?/
 
 	# fixes unicode characters in literals (because we parse them wrongly somehow)
 	def self.fix_unicode(str)

data/lib/active_rdf/queryengine/query2sparql.rb

@@ -57,15 +57,10 @@ class Query2SPARQL
   end
 
 	def self.construct_clause(term)
-    if term.respond_to? :uri
-      term.to_s
+    if term.is_a?(Symbol)
+      "?#{term}"
     else
-      case term
-      when Symbol
-        '?' + term.to_s
-      else
-        term.to_s
-      end
+      term.to_ntriple
     end
 	end
 

data/test/objectmanager/test_literal.rb

@@ -16,38 +16,37 @@ class TestLiteral < Test::Unit::TestCase
   end
 
   def test_xsd_string
-    # test with explicit datatype
-    test = Literal.new('test', XSD::string)
-    assert_equal '"test"^^<http://www.w3.org/2001/XMLSchema#string>', test.to_s
+    test = Literal.typed('test', XSD::string)
+    assert_equal '"test"^^<http://www.w3.org/2001/XMLSchema#string>', test.to_ntriple
   end
 
   def test_automatic_conversion
     # infer string
-    test = Literal.new('test')
-    assert_equal '"test"^^<http://www.w3.org/2001/XMLSchema#string>', test.to_s
+    test = 'test'
+    assert_equal '"test"^^<http://www.w3.org/2001/XMLSchema#string>', test.to_ntriple
 
     # infer integer
-    test = Literal.new(18)
-    assert_equal '"18"^^<http://www.w3.org/2001/XMLSchema#integer>', test.to_s
+    test = 18
+    assert_equal '"18"^^<http://www.w3.org/2001/XMLSchema#integer>', test.to_ntriple
 
     # infer boolean
-    test = Literal.new(true)
-    assert_equal '"true"^^<http://www.w3.org/2001/XMLSchema#boolean>', test.to_s
+    test = true
+    assert_equal '"true"^^<http://www.w3.org/2001/XMLSchema#boolean>', test.to_ntriple
   end
   
   def test_equality
-    test1 = Literal.new('test')
-    test2 = Literal.new('test', XSD::string)  
-    assert_equal test2.to_s, test1.to_s
+    test1 = 'test'
+    test2 = Literal.typed('test', XSD::string)  
+    assert_equal test2.to_ntriple, test1.to_ntriple
   end
   
   def test_language_tag
-    cat = Literal.new('cat')
-    cat_en = Literal.new('cat', '@en')
-    assert_equal '"cat"@en', cat_en.to_s
-    assert_not_equal cat.to_s, cat_en.to_s
+    cat = 'cat'
+    cat_en = LocalizedString.new('cat', '@en')
+    assert_equal '"cat"@en', cat_en.to_ntriple
+    assert_not_equal cat.to_ntriple, cat_en.to_ntriple
 
-    assert_equal '"dog"@en-GB', Literal.new('dog', '@en-GB').to_s
-    assert_equal '"dog"@en@test', Literal.new('dog', '@en@test').to_s
+    assert_equal '"dog"@en-GB', LocalizedString.new('dog', '@en-GB').to_ntriple
+    assert_equal '"dog"@en@test', LocalizedString.new('dog', '@en@test').to_ntriple
   end
 end

data/test/objectmanager/test_object_manager.rb

@@ -65,4 +65,30 @@ class TestObjectManager < Test::Unit::TestCase
     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
+
+  def test_to_xml
+    get_adapter.load "#{File.dirname(__FILE__)}/../test_person_data.nt"
+    Namespace.register(:test, 'http://activerdf.org/test/')
+
+    eyal = RDFS::Resource.new 'http://activerdf.org/test/eyal'
+    eyal.age = 29
+    assert_equal 29, eyal.age
+    snippet =
+'<rdf:Description rdf:about="#eyal">
+  <test:age rdf:datatype="http://www.w3.org/2001/XMLSchema#integer">29</test:age>
+  <test:eye rdf:datatype="http://www.w3.org/2001/XMLSchema#string">blue</test:eye>
+  <rdf:type rdf:resource="http://activerdf.org/test/Person"/>
+  <rdf:type rdf:resource="http://www.w3.org/2000/01/rdf-schema#Resource"/>
+</rdf:Description>
+</rdf:RDF>'
+    assert eyal.to_xml.include?(snippet)
+
+
+    url = 'http://gollem.swi.psy.uva.nl/cgi-bin/rdf-parser'
+    uri = URI.parse(url)
+    req = Net::HTTP::Post.new(url)
+    req.set_form_data('rdf' => eyal.to_xml)
+    res = Net::HTTP.new(uri.host, uri.port).start { |http| http.request(req) }
+    assert_match /RDF statement parsed successfully/, res.body, "SWI-Prolog failed to parse XML output"
+  end
 end

data/test/objectmanager/test_resource_reading.rb

@@ -53,9 +53,9 @@ 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
+    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

data/test/objectmanager/test_resource_writing.rb

@@ -19,12 +19,16 @@ 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
+    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 ['100', '18', '27'], eyal.age
+    # << fails on Fixnums , because Ruby doesn't allow us to change behaviour of 
+    # << on Fixnums 
+    eyal.age << 18
+    assert_equal 100, eyal.age
+
+    eyal.ar::age = [100, 80]
+    assert_equal [100, 80], eyal.ar::age
   end
 end

data/test/queryengine/test_ntriples_parser.rb

@@ -51,6 +51,21 @@ EOF
     triples = NTriplesParser.parse(string)
 
     assert_equal 1, triples.size
-    assert_equal literal, triples.first[2] 
+    assert_equal literal, triples.first[2]
+  end
+
+  def test_datatypes
+    string =<<EOF
+<s> <p> "blue" .
+<s> <p> "29"^^<http://www.w3.org/2001/XMLSchema#integer> .
+<s> <p> "false"^^<http://www.w3.org/2001/XMLSchema#boolean> .
+<s> <p> "2002-10-10T00:00:00+13"^^<http://www.w3.org/2001/XMLSchema#date> .
+EOF
+    triples = NTriplesParser.parse(string)
+    assert_equal 4, triples.size
+    assert_equal 'blue', triples[0][2]
+    assert_equal 29, triples[1][2]
+    assert_equal triples[2][2], false
+    assert_equal triples[3][2], DateTime.parse('2002-10-10T00:00:00+13')
   end
 end

data/test/queryengine/test_query2sparql.rb

@@ -8,22 +8,18 @@ require 'queryengine/query2sparql'
 require "#{File.dirname(__FILE__)}/../common"
 
 class TestQuery2Sparql < Test::Unit::TestCase
-  def setup
-  end
-
-  def teardown
-  end
+  def setup; end
+  def teardown; 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')
+    query.where(:s, RDFS::Resource.new('predicate'), 30)
 
     generated = Query2SPARQL.translate(query)
-    expected = "SELECT ?s WHERE { ?s <predicate> \"30\" . } "
+    expected = "SELECT ?s WHERE { ?s <predicate> \"30\"^^<http://www.w3.org/2001/XMLSchema#integer> . } "
     assert_equal expected, generated
 
     query = Query.new
@@ -33,13 +29,15 @@ class TestQuery2Sparql < 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

data/test/queryengine/test_query_engine.rb

@@ -21,10 +21,10 @@ class TestQueryEngine < Test::Unit::TestCase
 
     query = Query.new
     query.select(:s)
-    query.where(:s, RDFS::Resource.new('predicate'), '30')
+    query.where(:s, RDFS::Resource.new('predicate'), 30)
 
     generated = Query2SPARQL.translate(query)
-    expected = "SELECT ?s WHERE { ?s <predicate> \"30\" . } "
+    expected = "SELECT ?s WHERE { ?s <predicate> \"30\"^^<http://www.w3.org/2001/XMLSchema#integer> . } "
     assert_equal expected, generated
 
     query = Query.new

data/test/test_adapters.rb

@@ -42,11 +42,18 @@ class TestAdapter < Test::Unit::TestCase
     Namespace.register(:test, 'http://activerdf.org/test/')
     eyal = Namespace.lookup(:test, :eyal)
 
-    assert_equal '27', eyal.age
-    eyal.age = 30
-
-    assert eyal.age.include?('30')
-    assert eyal.age.include?('27')
+    assert_equal 1, eyal.all_age.size
+    assert_equal 27, eyal.age
+
+    # << doesn't work on Fixnums
+    eyal.age << 30
+    assert_equal 1, eyal.all_age.size
+    assert !eyal.all_age.include?(30)
+    assert eyal.all_age.include?(27)
+
+    eyal.age = 40
+    assert_equal 1, eyal.all_age.size
+    assert eyal.age == 40
   end
 end
 

data/test/test_person_data.nt

@@ -1,9 +1,9 @@
 <http://activerdf.org/test/Person> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2000/01/rdf-schema#Class> .
 <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/eyal> <http://activerdf.org/test/age> "27"^^<http://www.w3.org/2001/XMLSchema#integer> .
 <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/other> <http://activerdf.org/test/age> "21"^^<http://www.w3.org/2001/XMLSchema#integer>  .
 <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.4
 specification_version: 1
 name: activerdf
 version: !ruby/object:Gem::Version 
-  version: 1.6.8
-date: 2007-11-01 00:00:00 +01:00
+  version: 1.6.9
+date: 2008-02-11 00:00:00 +01:00
 summary: Offers object-oriented access to RDF (with adapters to several datastores).
 require_paths: 
 - lib
@@ -32,42 +32,41 @@ files:
 - LICENSE
 - README
 - CHANGELOG
+- test/small-two.nt
+- test/queryengine
+- test/queryengine/test_query_engine.rb
+- test/queryengine/test_ntriples_parser.rb
+- test/queryengine/test_query2sparql.rb
+- test/test_person_data.nt
 - test/federation
-- test/federation/test_federation_manager.rb
 - test/federation/test_connection_pool.rb
+- test/federation/test_federation_manager.rb
+- test/small-one.nt
+- test/test_adapters.rb
+- test/common.rb
 - test/objectmanager
-- 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/queryengine
-- 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/common.rb
-- test/test_adapters.rb
-- test/test_person_data.nt
-- test/small-one.nt
-- test/small-two.nt
+- test/objectmanager/test_namespace.rb
 - lib/active_rdf
+- lib/active_rdf/queryengine
+- lib/active_rdf/queryengine/ntriples_parser.rb
+- lib/active_rdf/queryengine/query.rb
+- lib/active_rdf/queryengine/query2sparql.rb
+- lib/active_rdf/queryengine/query2jars2.rb
 - lib/active_rdf/federation
+- 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/federation/active_rdf_adapter.rb
+- lib/active_rdf/instance_exec.rb
 - lib/active_rdf/objectmanager
 - 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/objectmanager/bnode.rb
-- lib/active_rdf/queryengine
-- lib/active_rdf/queryengine/query.rb
-- lib/active_rdf/queryengine/query2sparql.rb
-- lib/active_rdf/queryengine/ntriples_parser.rb
-- lib/active_rdf/queryengine/query2jars2.rb
+- lib/active_rdf/objectmanager/namespace.rb
+- lib/active_rdf/objectmanager/object_manager.rb
 - lib/active_rdf.rb
 - lib/active_rdf_log.rb
 - lib/active_rdf_helpers.rb

data/test/queryengine/test_query.rb

@@ -1,55 +0,0 @@
-# Author:: Eyal Oren
-# Copyright:: (c) 2005-2006
-# License:: LGPL
-
-require 'test/unit'
-require 'active_rdf'
-require 'queryengine/query'
-require "#{File.dirname(__FILE__)}/../common"
-
-class TestQuery < Test::Unit::TestCase
-  def setup
-  end
-
-  def teardown
-  end
-
-  def test_sparql_generation
-    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
-
-    query = Query.new
-    query.select(:s)
-    query.where(:s, RDFS::Resource.new('foaf:age'), :a)
-    query.where(:a, RDFS::Resource.new('rdf:type'), RDFS::Resource.new('xsd:int'))
-    generated = Query2SPARQL.translate(query)
-    expected = "SELECT ?s WHERE { ?s <foaf:age> ?a . ?a <rdf:type> <xsd:int> . } "
-    assert_equal expected, generated
-	end
-
-	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
-    # can define multiple select clauses at once or separately
-    q1 = Query.new.select(:s,:a)
-    q2 = Query.new.select(:s).select(:a)
-    assert_equal Query2SPARQL.translate(q1),Query2SPARQL.translate(q2)
-  end
-
-	def test_query_refuses_string_in_where_clause_subject_or_predicate
-    assert_raises(ActiveRdfError)do
-      Query.new.select(:s).where("http://test.org/uri",:p, :o).execute
-    end
-  end
-end

data/test/queryengine/test_query2jars2.rb

@@ -1,51 +0,0 @@
-# Author:: Eyal Oren
-# Copyright:: (c) 2005-2006
-# License:: LGPL
-
-require 'test/unit'
-require 'active_rdf'
-require 'queryengine/query2jars2'
-require "#{File.dirname(__FILE__)}/../common"
-
-class TestQuery2Jars2 < Test::Unit::TestCase
-  def setup
-  end
-
-  def teardown
-  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
-
-    query = Query.new
-    query.select(:s)
-    query.where(:s, RDFS::Resource.new('foaf:age'), :a)
-    query.where(:a, RDFS::Resource.new('rdf:type'), RDFS::Resource.new('xsd:int'))
-    generated = Query2SPARQL.translate(query)
-    expected = "SELECT ?s WHERE { ?s <foaf:age> ?a . ?a <rdf:type> <xsd:int> . } "
-    assert_equal expected, generated
-
-    #		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
-  end
-
-  def test_query_omnipotent
-    # can define multiple select clauses at once or separately
-    q1 = Query.new.select(:s,:a)
-    q2 = Query.new.select(:s).select(:a)
-    assert_equal Query2SPARQL.translate(q1),Query2SPARQL.translate(q2)
-  end
-end