talia_core 0.5.0 → 0.5.1

data/lib/talia_core/rdf_resource.rb

@@ -7,7 +7,7 @@ module TaliaCore
   # of the pitfalls of the original class.
   class RdfResource
 
-    include RDFS::ResourceLike
+    include ActiveRDF::ResourceLike
     
     class << self
       
@@ -34,18 +34,18 @@ module TaliaCore
 
     # Direct writing of a predicate, with having to fetch a list first
     def direct_write_predicate(predicate, value)
-      FederationManager.add(self, predicate, value)
+      ActiveRDF::FederationManager.add(self, predicate, value)
     end
 
     # Clears all rdf for this resource. FIXME: Not context-aware.
     def clear_rdf
-      FederationManager.delete_all(self)
+      ActiveRDF::FederationManager.delete_all(self)
     end
 
     # Removes the given predicate (restrict to the triple with the
     # given value if a value is given).
     def remove(predicate, value = nil)
-      FederationManager.delete(self, predicate, value)
+      ActiveRDF::FederationManager.delete(self, predicate, value)
     end
 
     # Returns the value(s) of the given predicates as a PropertyList filled
@@ -53,7 +53,7 @@ module TaliaCore
     def [](predicate)
       predicate = N::URI.new(predicate) unless(predicate.kind_of?(N::URI))
       
-      property_list = Query.new(object_class).distinct(:o).where(self, predicate, :o).execute
+      property_list = ActiveRDF::Query.new(object_class).distinct(:o).where(self, predicate, :o).execute
       
       PropertyList.new(predicate, property_list, self, source_exists?)
     end
@@ -77,7 +77,7 @@ module TaliaCore
         
         def [](property)
           property = N::URI.new(property) unless(property.kind_of?(N::URI))
-          Query.new(@obj_class).distinct(:s).where(:s, property, @obj_uri).execute
+          ActiveRDF::Query.new(@obj_class).distinct(:s).where(:s, property, @obj_uri).execute
         end
         private(:type)
       end
@@ -93,13 +93,13 @@ module TaliaCore
     
     # Returns the predicates that are directly defined for this resource
     def direct_predicates
-      Query.new(N::Predicate).distinct(:p).where(self, :p, :o).execute
+      ActiveRDF::Query.new(N::Predicate).distinct(:p).where(self, :p, :o).execute
     end
     
     # Returns the "inverse" predicates for the resource. these are the predicates
     # for which this resource exists as an object
     def inverse_predicates
-      qry = Query.new.distinct.select(:p)
+      qry = ActiveRDF::Query.new.distinct.select(:p)
       qry.where(:s, :p, N::URI.new(uri.to_s))
       qry.execute.collect{ |res| N::Predicate.new(res.uri) }
     end
@@ -108,8 +108,8 @@ module TaliaCore
     # been optimized so that if only one RDF backend is present it won't do
     # any copying around.
     def save
-      if((ConnectionPool.read_adapters.size == 1) &&
-            (ConnectionPool.write_adapter == ConnectionPool.read_adapters.first))
+      if((ActiveRDF::ConnectionPool.read_adapters.size == 1) &&
+            (ActiveRDF::ConnectionPool.write_adapter == ActiveRDF::ConnectionPool.read_adapters.first))
         save_default_types # Only write the "default" types to the store
       else
         full_save # Do the full save operation
@@ -118,7 +118,7 @@ module TaliaCore
     
     # Returns the types of this resource as N::SourceClass objects
     def types
-      types = Query.new(N::SourceClass).distinct(:t).where(self,N::RDF::type,:t).execute
+      types = ActiveRDF::Query.new(N::SourceClass).distinct(:t).where(self,N::RDF::type,:t).execute
       # Add the "default" types if necessary
       self.class.default_types.each do |def_type|
         types << def_type unless(types.include?(def_type))
@@ -133,7 +133,7 @@ module TaliaCore
     # Saves the the "default" types of this resource to the writing adapter
     def save_default_types
       self.class.default_types.each do |t|
-        FederationManager.add(self, N::RDF::type, t)
+        ActiveRDF::FederationManager.add(self, N::RDF::type, t)
       end
     end
     
@@ -141,11 +141,11 @@ module TaliaCore
     # the writing adapter. This operation can be very slow.
     def full_save
       types.each do |t|
-        FederationManager.add(self, N::RDF::type, t)
+        ActiveRDF::FederationManager.add(self, N::RDF::type, t)
       end
 
-      Query.new(N::URI).distinct(:p,:o).where(self, :p, :o).execute do |p, o|
-        FederationManager.add(self, p, o)
+      ActiveRDF::Query.new(N::URI).distinct(:p,:o).where(self, :p, :o).execute do |p, o|
+        ActiveRDF::FederationManager.add(self, p, o)
       end
     end
     

data/lib/talia_util/rake_tasks.rb

@@ -141,7 +141,7 @@ namespace :talia_core do
 
     rdf_cfg[:new] = "yes"
 
-    ConnectionPool.add_data_source(rdf_cfg)
+    ActiveRDF::ConnectionPool.add_data_source(rdf_cfg)
   end
 
   # Help info

data/lib/talia_util/rdf_update.rb

@@ -36,15 +36,15 @@ module TaliaUtil
       # number of blank nodes
       def rdfs_from_owl
         # Remove previous auto rdfs triples
-        FederationManager.clear(N::TALIA.auto_rdfs.context)
+        ActiveRDF::FederationManager.clear(N::TALIA.auto_rdfs.context)
         
         # This gets all OWL classes in the store
-        all_qry = Query.new(N::URI).distinct.select(:class)
+        all_qry = ActiveRDF::Query.new(N::URI).distinct.select(:class)
         all_qry.where(:class, N::RDF::type, N::OWL.Class)
         all_owl = all_qry.execute
         
         # This gets all OWL classes that already have an RDF class attached
-        qry_rdfs = Query.new(N::URI).distinct.select(:class)
+        qry_rdfs = ActiveRDF::Query.new(N::URI).distinct.select(:class)
         qry_rdfs.where(:class, N::RDF::type, N::OWL.Class)
         qry_rdfs.where(:class, N::RDF::type, N::RDFS.Class)
         classes_with_rdfs = qry_rdfs.execute
@@ -76,7 +76,7 @@ module TaliaUtil
         class_hash.each do |klass, status|
           if(status == :has_rdfs_class)
             modified = modified + 1
-            FederationManager.add(N::URI.new(klass), N::RDF.type, N::RDFS.Class, N::TALIA.auto_rdfs_context)
+            ActiveRDF::FederationManager.add(N::URI.new(klass), N::RDF.type, N::RDFS.Class, N::TALIA.auto_rdfs_context)
           end
           yield(class_hash.size) if(block_given?)
         end

data/lib/talia_util/uri_helper.rb

@@ -0,0 +1,20 @@
+module TaliaUtil
+  
+  # Some helper methods to deal with URI and IRI strings
+  module UriHelper
+    
+    # Removes all characters that are illegal in IRIs, so that the
+    # URIs can be imported
+    def irify(uri)
+      N::URI.new(uri.to_s.gsub( /[<>"{}|\\^`\s]/, '+')).to_s
+    end
+    
+    # Sanitize an URI to be passed into SPARQL queries
+    def sanitize_sparql(uri_or_string)
+      uri_or_string = uri_or_string.to_s.gsub( /[<>"{}|\\^`\s]/, '') # Remove forbidden chars that we know of
+      URI.escape(uri_or_string) # Escape everything else
+      uri_or_string.gsub('%23', '#') # Revert the hash character, we need that intact
+    end
+    
+  end
+end

data/lib/talia_util/util.rb

@@ -25,7 +25,7 @@ module TaliaUtil
       # Set up the ontologies from the given folder
       def setup_ontologies
         # Clear the ontologies from RDF, if possible
-        adapter = ConnectionPool.write_adapter
+        adapter = ActiveRDF::ConnectionPool.write_adapter
         if(adapter.supports_context?)
           TaliaCore::RdfImport.clear_file_contexts
         else
@@ -108,7 +108,7 @@ module TaliaUtil
 
       # Flush the RDF store
       def flush_rdf
-        ConnectionPool.write_adapter.clear
+        ActiveRDF::ConnectionPool.write_adapter.clear
       end
 
       # Remove the data directories
@@ -145,7 +145,7 @@ module TaliaUtil
           else
             rec.property_value
           end
-          FederationManager.add(subject, predicate, object)
+          ActiveRDF::FederationManager.add(subject, predicate, object)
           yield if(block_given?)
         end
 
@@ -155,7 +155,7 @@ module TaliaUtil
         # are defined outside the core.
         TaliaCore::ActiveSource.find(:all, :select => 'uri, type AS runtime_type').each do |src|
           type = (src.runtime_type || 'ActiveSource')
-          FederationManager.add(src, N::RDF.type, N::TALIA + type)
+          ActiveRDF::FederationManager.add(src, N::RDF.type, N::TALIA + type)
           yield if(block_given?)
         end
       end

data/lib/talia_util/xml/base_builder.rb

@@ -0,0 +1,47 @@
+module TaliaUtil
+  module Xml
+    
+    # Base class for builders that create XML representations. This uses a Builder::XmlMarkup object
+    # in the background which does the actual XML writing.
+    # 
+    # All builders will be used through the #open method, which can be passed either a Builder::XmlMarkup
+    # object, or the options to create one.
+    #
+    # Subclasses must provide a build_structure method that creates the outer structure of the XML
+    class BaseBuilder
+      
+      # Creates a new builder. The options are equivalent for the options of the
+      # underlying Xml builder. The builder itself will be passed to the block that
+      # is called by this method.
+      # If you pass a :builder option instead, it will use the given builder instead
+      # of creating a new one
+      def self.open(options)
+        my_builder = self.new(options)
+        my_builder.send(:build_structure) do
+          yield(my_builder)
+        end
+      end
+      
+      # Builds to a string, using a default builder. This returns the string and otherwise 
+      # works like #open
+      def self.make_xml_string
+        xml = ''
+        open(:target => xml, :indent => 2) do |builder|
+          yield(builder)
+        end
+        
+        xml
+      end
+      
+      private
+      
+      # Create a new builder
+      def initialize(options)
+        @builder = options[:builder]
+        @builder ||= Builder::XmlMarkup.new(options)
+      end
+      
+    end
+    
+  end
+end

data/lib/talia_util/xml/rdf_builder.rb

@@ -0,0 +1,172 @@
+module TaliaUtil
+  module Xml
+    # Class for creating xml-rdf data
+    class RdfBuilder < BaseBuilder
+
+      # Writes a simple "flat" triple. If the object is a string, it will be
+      # treated as a "value" while an object (ActiveSource or N::URI) will be treated
+      # as a "link".
+      #
+      # Throws an exception if the predicate cannot be turned into a namespaced
+      # representation
+      def write_triple(subject, predicate, object)
+        subject = subject.respond_to?(:uri) ? subject.uri.to_s : subject
+        predicate = predicate.respond_to?(:uri) ? predicate : N::URI.new(predicate) 
+        @builder.rdf :Description, "rdf:about" => subject do
+          write_predicate(predicate, [ object ])
+        end
+      end
+
+      # Writes all the given triples.
+      def write_triples(triples)
+        triples.each do |triple|
+          write_triple(*triple)
+        end
+      end
+      
+      # 
+      def self.open_for_triples(triples, options = nil)
+        my_builder = self.new(options)
+        
+        triple_hash = my_builder.send(:prepare_triples, triples)
+        
+        my_builder.send(:build_structure) do
+          my_builder.send(:write_for_triples, triple_hash)
+        end
+      end
+      
+
+      def self.xml_string_for_triples(triples)
+        xml = ''
+        open_for_triples(triples, :target => xml, :indent => 2)
+        xml
+      end
+
+      private 
+      
+      
+      def prepare_triples(triples)
+        triple_hash = {}
+        triples.each do |triple|
+          subject = triple.shift
+          subject = subject.to_s
+          predicate = triple.first.to_uri
+          namespaced_predicate = predicate.to_name_s
+          if(predicate == namespaced_predicate)
+            # We have an unknown namespace
+            namespaced_predicate = make_predicate_namespace(predicate)
+          end
+          triple_hash[subject] ||= {}
+          triple_hash[subject][N::URI.new(namespaced_predicate)] ||= [] 
+          triple_hash[subject][N::URI.new(namespaced_predicate)] << triple.last
+        end
+        triple_hash
+      end
+      
+      # Write for the open_for_triples
+      def write_for_triples(triple_hash)
+        triple_hash.each do |subject, values|
+          @builder.rdf :Description, 'rdf:about' => subject.to_uri.to_name_s do # Element describing this resource
+            values.each do |predicate, objects|
+              write_predicate(predicate, objects, false)
+            end
+          end
+        end
+      end
+      
+      def make_predicate_namespace(predicate)
+        pred_uri = URI.parse(predicate.to_s)
+        path_parts = split_uri!(pred_uri)
+        raise(ArgumentError, "Illegal predicate URL #{predicate}") if(path_parts[0].blank? || path_parts[1].blank?)
+        namespace = make_namespace(pred_uri)
+        "#{namespace}:#{path_parts[1]}"
+      end
+
+      def split_uri!(uri)
+        if(uri.fragment)
+          fragment = uri.fragment
+          uri.fragment = '' 
+          [uri.path, fragment]
+        else
+          path_parts = /\A(.*[\/#])([^\/#]+)\Z/.match(uri.path)
+          uri.path = path_parts[1]
+          [ path_parts[1], path_parts[2] ]
+        end
+      end
+
+      def make_namespace(namespace_uri)
+        candidate = /([^\.]+)(\.[^\.]*)?\Z/.match(namespace_uri.host)[1]
+        raise(ArgumentError, "Illegal namespace #{namespace_uri.to_s}") if(candidate.blank?)
+        first_candidate = candidate.downcase
+        candidate = first_candidate
+        counter = 1
+        additional_namespaces[candidate.to_sym] ||= namespace_uri.to_s
+        while(additional_namespaces[candidate.to_sym] != namespace_uri.to_s)
+          counter += 1
+          candidate = "#{first_candidate}#{counter}"
+          additional_namespaces[candidate.to_sym] ||= namespace_uri.to_s
+        end
+        candidate
+      end
+
+      # Build the structure for the XML file and pass on to
+      # the given block
+      def build_structure
+        @builder.rdf :RDF, namespaces do 
+          yield
+        end
+      end
+      
+      def additional_namespaces
+        @additional_namespaces ||= {}
+      end
+      
+      def namespaces
+        namespaces = self.class.namespaces
+        additional_namespaces.each { |key, value| namespaces["xmlns:#{key.to_s}"] = value.to_s }
+        namespaces
+      end
+
+      def self.namespaces
+        @namespaces ||= begin
+          namespaces = {}
+          N::Namespace.shortcuts.each { |key, value| namespaces["xmlns:#{key.to_s}"] = value.to_s }
+          namespaces
+        end
+      end
+
+      # Build an rdf/xml string for one predicate, with the given values
+      def write_predicate(predicate, values, check_predicate = true)
+        values.each { |val| write_single_predicate(predicate, val, check_predicate) }
+      end # end method
+
+      def write_single_predicate(predicate, value, check_predicate = true)
+        is_property = value.respond_to?(:uri)
+        value_properties = is_property ? { 'value' => value } : extract_values(value.to_s)
+        value = value_properties.delete('value')
+        predicate_name = predicate.to_name_s
+        raise(ArgumentError, "Cannot turn predicate #{predicate} into namespace name") if(check_predicate && (predicate == predicate_name))
+        @builder.tag!(predicate.to_name_s, value_properties) do
+          if(is_property)
+            @builder.rdf :Description, 'rdf:about' => value.uri.to_s
+          else
+            @builder.text!(value)
+          end
+        end
+      end
+
+      # Splits up the value, extracting encoded language codes and RDF data types. The 
+      # result will be returned as a hash, with the "true" value being "value"
+      def extract_values(value)
+        prop_string = TaliaCore::PropertyString.parse(value)
+        result = {}
+        result['value'] = prop_string
+        result['rdf:datatype'] = prop_string.type if(prop_string.type)
+        result['xml:lang'] = prop_string.lang if(prop_string.lang)
+
+        result
+      end
+
+    end
+  end
+end

data/test/swicky/json_encoder_test.rb

@@ -0,0 +1,116 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+require 'rexml/document'
+
+module Swicky
+  
+  class JsonEncoderTest < ActiveSupport::TestCase
+    
+    def setup
+      @encoder = JsonEncoder.new(test_triples)
+    end
+    
+    def test_make_predicate_local
+      local = @encoder.send(:make_predicate_local, N::TALIA.foobar)
+      assert_equal('foobar', local)
+      assert_equal({ 'foobar' => { 'uri' => N::TALIA.foobar.to_s, 'valueType' => 'item' } }, @encoder.instance_variable_get(:@properties_hash))
+    end
+    
+    def test_make_predicate_local_multi
+      @encoder.send(:make_predicate_local, N::TALIA.foobar)
+      @encoder.send(:make_predicate_local, N::LOCAL.foobar)
+      @encoder.send(:make_predicate_local, N::TALIA.foobar)
+      local = @encoder.send(:make_predicate_local, N::RDF.foobar)
+      assert_equal('foobar3', local)
+    end
+    
+    def test_make_type_local
+      local = @encoder.send(:make_type_local, N::TALIA.Foobar)
+      assert_equal('Foobar', local)
+      assert_equal({ 'Foobar' => { 'uri' => N::TALIA.Foobar.to_s } }, @encoder.instance_variable_get(:@types_hash))
+    end
+    
+    def test_build_item
+      item = @encoder.send(:build_item, N::LOCAL.Foo, {
+        N::RDF.type => [ N::TALIA.Foobar ],
+        N::TALIA.hasIt => ['blarg', 'bar'],
+        N::TALIA.strangeThing => ['what'],
+        'label' => 'bar'
+      })
+      assert_equal([{
+        'uri' => N::LOCAL.Foo.to_s,
+        'type' => [ 'Foobar' ],
+        'label' => 'bar',
+        'hasIt' => ['blarg', 'bar'],
+        'strangeThing' => 'what'
+      }], item)
+    end
+    
+    def test_to_json
+      assert_equal(expected_result.to_json, @encoder.to_json)
+    end
+    
+    private
+    
+    def expected_result
+      {
+        "items" => [
+          {
+            "uri"=>N::LOCAL.foobar.to_s, 
+            "type"=>["MyType"], 
+            "label"=>"foobar",
+            "first"=>["worksit", "worksit2"]
+          }, 
+          {
+            "uri"=>N::TALIA.whatever.to_s, 
+            "type"=>["Resource"], 
+            "label"=>"whatever",
+            "predicate"=>"The cool thing", 
+            "first2"=>"The cool thing"
+          },
+          {
+            "uri"=>"http://www.barbaa.com/fun",
+            "type"=>["Resource"],
+            "label"=>"The cool thing",
+            "predicate"=>"whatever"
+          }
+        ], 
+        "types" => {
+          "MyType"=>
+          {
+            "uri"=>N::TALIA.MyType.to_s
+          }, 
+          "Resource"=> {
+            "uri"=>"http://www.w3.org/1999/02/22-rdf-syntax-ns#Resource"
+          }
+        }, 
+        "properties"=> {
+          "first"=> {
+            "uri"=>"http://www.foobar.com/bar/moo/first", 
+            "valueType"=>"item"
+          }, 
+          "predicate"=>{
+            "uri"=>N::TALIA.predicate.to_s, 
+            "valueType"=>"item"
+          }, 
+          "first2"=>{
+            "uri"=>"http://www.foobar.com/bar/moo#first", "valueType"=>"item"
+          }
+        }
+      }
+    end
+    
+    
+    def test_triples
+      [
+        [ N::LOCAL.foobar, 'http://www.foobar.com/bar/moo/first', "worksit"],
+        [ N::LOCAL.foobar, 'http://www.foobar.com/bar/moo/first', "worksit2"],
+        [ N::LOCAL.foobar, N::RDF.type, N::TALIA.MyType ],
+        [ N::TALIA.whatever, N::TALIA.predicate, N::URI.new('http://www.barbaa.com/fun')],
+        [ N::TALIA.whatever, 'http://www.foobar.com/bar/moo#first', N::URI.new('http://www.barbaa.com/fun')],
+        [ "http://www.barbaa.com/fun".to_uri, N::RDFS.label, "The cool thing"],
+        [ "http://www.barbaa.com/fun".to_uri, N::TALIA.predicate, N::TALIA.whatever]
+      ]
+    end
+  end
+  
+end

data/test/swicky/notebook_test.rb

@@ -0,0 +1,107 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+require 'rexml/document'
+
+module Swicky
+  
+  # Test the ActiveSource
+  class NotebookTest < ActiveSupport::TestCase
+    
+    
+    def setup
+      setup_once(:flush) { TaliaCore::TestHelper::flush_store }
+      @notebook = Notebook.new('dan', 'booky')
+      @testpointer = "http://dbin.org/swickynotes/demo/HanselAndGretel.htm#xpointer(start-point(string-range(//DIV[@id='http://dbin.org/swickynotes/demo/HG_1']/P[1]/SPAN[1]/text()[1],'',0))/range-to(string-range(//DIV[@id='http://dbin.org/swickynotes/demo/HG_1']/P[1]/SPAN[1]/text()[1],'',266)))"
+    end
+    
+    def teardown
+      @notebook.delete
+    end
+    
+    def test_url
+      assert_equal(@notebook.url, N::LOCAL + 'users/dan/swicky_notebooks/booky')
+    end
+    
+    def test_user_url
+      assert_equal(@notebook.user_url, N::LOCAL + 'users/dan')
+    end
+    
+    def test_load
+      assert_notebook_empty
+      load_notebook
+      assert_notebook_full
+    end
+    
+    def test_delete
+      load_notebook
+      @notebook.delete
+      assert_notebook_empty
+    end
+    
+    def test_data
+      load_notebook
+      assert_equal(@notebook.data.size, 236)
+    end
+    
+    def test_xml_data
+      load_notebook
+      xml_data = @notebook.xml_data
+      assert_kind_of(String, xml_data)
+      assert_not_equal('', xml_data)
+      # Check xml validity
+      assert_nothing_raised { REXML::Document.new(xml_data) }
+    end
+    
+    def test_find_all_empty
+      assert_equal([], Notebook.find_all)
+    end
+      
+    def test_find_all_existing
+      load_notebook
+      assert_equal([@notebook.url], Notebook.find_all)
+    end
+      
+    def test_find_all_user
+      load_notebook
+      assert_equal([@notebook.url], Notebook.find_all('dan'))
+    end
+    
+    def test_find_all_user_nonexistent
+      load_notebook
+      assert_equal([], Notebook.find_all('mic'))
+    end
+    
+    def test_get_coordinates
+      load_notebook
+      coords = Notebook.coordinates_for("http://dbin.org/swickynotes/demo/HanselAndGretel.htm")
+      assert_equal([ @testpointer ], coords)
+    end
+    
+    def test_annotations_for_url
+      load_notebook
+      assert_equal(180, Notebook.annotations_for_url("http://discovery-project.eu/ontologies/philoSpace/SourceFragment#ec9796a5349b290a7610763dcbc47af2").size)
+    end
+    
+    def test_annotations_for_xpointer
+      load_notebook
+      assert_equal(180, Notebook.annotations_for_xpointer(@testpointer).size)
+    end
+    
+    private
+    
+    def assert_notebook_empty
+      assert_equal(0, ActiveRDF::Query.new(N::URI).select(:s, :p, :o).distinct.where(:s, :p, :o, @notebook.url).execute.size)
+      assert_equal(0, ActiveRDF::Query.new(N::URI).select(:user).where(:user, N::TALIA.hasSwickyNotebook, :notebook).where(:notebook, N::RDF.type, N::TALIA.SwickyNotebook).execute.size)
+    end
+    
+    def assert_notebook_full
+      assert_equal(236, ActiveRDF::Query.new(N::URI).select(:s, :p, :o).distinct.where(:s, :p, :o, @notebook.url).execute.size)
+      assert_equal(1, ActiveRDF::Query.new(N::URI).select(:user).where(:user, N::TALIA.hasSwickyNotebook, :notebook).where(:notebook, N::RDF.type, N::TALIA.SwickyNotebook).execute.size)
+    end
+    
+    def load_notebook
+      @notebook.load(TaliaCore::TestHelper.fixture_file("notebook.rdf"))
+    end
+    
+  end
+  
+end

data/test/talia_core/rdf_resource_test.rb

@@ -84,7 +84,7 @@ module TaliaCore
       res.save
       
       # Check if the defaul type was written
-      rdfs_prop = Query.new(N::SourceClass).distinct(:t).where(res,N::RDF::type,:t).execute
+      rdfs_prop = ActiveRDF::Query.new(N::SourceClass).distinct(:t).where(res,N::RDF::type,:t).execute
       assert_equal(2, rdfs_prop.size)
       assert(rdfs_prop.include?(N::RDFS.Resource))
     end