rdf_context 0.5.3 → 0.5.5

data/lib/rdf_context/serializer/recursive_serializer.rb

@@ -66,16 +66,12 @@ module RdfContext
     # Return a QName for the URI, or nil. Adds namespace of QName to defined namespaces
     def get_qname(uri)
       if uri.is_a?(URIRef)
-        begin
-          qn = @graph.qname(uri)
-        rescue RdfException
-          return false  # no namespace
-        end
+        qn = @graph.qname(uri)
         # Local parts with . will mess up serialization
-        return false if qn.index('.')
+        return false if qn.nil? || qn.index('.')
         
         add_namespace(uri.namespace)
-        return qn
+        qn
       end
     end
     

data/lib/rdf_context/serializer/xml_serializer.rb

@@ -32,6 +32,8 @@ module RdfContext
       
       doc = Nokogiri::XML::Document.new
 
+      puts "\nserialize: graph namespaces: #{@graph.nsbinding.inspect}" if $DEBUG
+
       preprocess
 
       predicates = @graph.predicates.uniq
@@ -40,13 +42,12 @@ module RdfContext
       required_namespaces = {}
       possible.each do |res|
         next unless res.is_a?(URIRef)
-        if !get_qname(res)  # Creates Namespace mappings
-          [RDF_NS, DC_NS, OWL_NS, LOG_NS, RDF_NS, RDFS_NS, XHV_NS, XML_NS, XSD_NS, XSI_NS].each do |ns|
-            # Bind a standard namespace to the graph and try the lookup again
-            @graph.bind(ns) if ns.uri == res.base
-            required_namespaces[res.base] = true if !get_qname(res) && predicates.include?(res)
-          end
+        if res.namespace
+          add_namespace(res.namespace)
+        else
+          required_namespaces[res.base] = true
         end
+        #puts "possible namespace for #{res}: #{res.namespace || %(<#{res.base}>)}"
       end
       add_namespace(RDF_NS)
       add_namespace(XML_NS) if @base || @lang
@@ -64,7 +65,7 @@ module RdfContext
       # Add bindings for predicates not already having bindings
       tmp_ns = "ns0"
       required_namespaces.keys.each do |uri|
-        puts "serialize: create temporary namespace for <#{uri}>" if $DEBUG
+        puts "create namespace definition for #{uri}" if $DEBUG
         add_namespace(Namespace.new(uri, tmp_ns))
         tmp_ns = tmp_ns.succ
       end
@@ -103,7 +104,8 @@ module RdfContext
         if rdf_type.is_a?(URIRef)
           element = get_qname(rdf_type)
           properties[RDF_TYPE.to_s] = rest
-          if rdf_type.namespace && @default_ns && rdf_type.namespace.uri == @default_ns.uri
+          type_ns = rdf_type.namespace rescue nil
+          if type_ns && @default_ns && type_ns.uri == @default_ns.uri
             properties[RDF_TYPE.to_s] = rest
             element = rdf_type.short_name
           end
@@ -143,6 +145,7 @@ module RdfContext
     # If _is_unique_ is true, this predicate may be able to be serialized as an attribute
     def predicate(prop, object, node, is_unique)
       qname = prop.to_qname(uri_binding)
+      raise RdfException, "No qname generated for <#{prop}>" unless qname
 
       # See if we can serialize as attribute.
       # * untyped attributes that aren't duplicated where xml:lang == @lang
@@ -233,5 +236,15 @@ module RdfContext
       end
       node.add_child(pred_node) if pred_node
     end
+
+    def preprocess_triple(triple)
+      super
+      
+      # Pre-fetch qnames, to fill namespaces
+      get_qname(triple.predicate)
+      get_qname(triple.object) if triple.predicate == RDF_TYPE
+
+      @references[triple.predicate] = ref_count(triple.predicate) + 1
+    end
   end
 end

data/lib/rdf_context/store/abstract_store.rb

@@ -35,7 +35,6 @@ module RdfContext
 
     # Bind namespace to store, returns bound namespace
     def bind(namespace)
-      puts "bind #{namespace.inspect}"
       # Over-write an empty prefix
       uri = namespace.uri.to_s
       @uri_binding.delete(uri)

data/lib/rdf_context/uriref.rb

@@ -47,14 +47,17 @@ module RdfContext
     # short_name of URI for creating QNames.
     #   "#{base]{#short_name}}" == uri
     def short_name
-      @short_name ||= if @namespace
-        self.to_s.sub(@namespace.uri.to_s, "")
-      elsif @uri.fragment()
-        @uri.fragment()
-      elsif @uri.path.split("/").last.class == String and @uri.path.split("/").last.length > 0
-        @uri.path.split("/").last
-      else
-        false
+      @short_name ||= begin
+        path = @uri.path.split("/")
+        if @namespace
+          self.to_s.sub(@namespace.uri.to_s, "")
+        elsif @uri.fragment
+          @uri.fragment
+        elsif path && path.length > 1 && path.last.class == String && path.last.length > 0 && path.last.index("/") != 0
+          path.last
+        else
+          false
+        end
       end
     end
     
@@ -63,7 +66,7 @@ module RdfContext
     def base
       @base ||= begin
         uri_base = self.to_s
-        sn = short_name.to_s
+        sn = short_name ? short_name.to_s : ""
         uri_base[0, uri_base.length - sn.length]
       end
     end
@@ -90,21 +93,24 @@ module RdfContext
     alias_method :to_ntriples, :to_n3
   
     # Output URI as QName using URI binding
-    def to_qname(uri_binding = {})
-      ns = namespace(uri_binding)
-      "#{ns.prefix}:#{short_name}"
+    def to_qname(uri_binding = [])
+      namespaces = case uri_binding
+      when Hash then uri_binding.values
+      when Array then uri_binding
+      else []
+      end
+      ns = namespace(namespaces)
+      "#{ns.prefix}:#{short_name}" if ns
     end
     
-    def namespace(uri_binding = {})
-      @namespace ||= begin
-        uri = uri_binding.keys.detect {|u| self.to_s.index(u) == 0 }
-        raise RdfException, "Couldn't find namespace for #{@uri}" unless uri
-        uri_binding[uri]
-      end
+    # Look at namespaces and find first that matches this URI, ordering by longest URI first
+    def namespace(namespaces = [])
+      @namespace ||=
+        namespaces.sort_by {|ns| -ns.uri.to_s.length}.detect {|ns| self.to_s.index(ns.uri.to_s) == 0}
     end
     
     def inspect
-      "#{self.class}[#{self.to_n3}]"
+      "#{self.class}[#{self.to_n3}, ns=#{namespace.inspect}]"
     end
     
     # Output URI as resource reference for RDF/XML

data/spec/graph_spec.rb

@@ -120,13 +120,13 @@ describe "Graphs" do
   
   describe "with XML Literal objects" do
     subject {
-      dc = Namespace.new("http://purl.org/dc/elements/1.1/", "dc")
+      dc = Namespace.new("http://purl.org/dc/terms/", "dc")
       xhtml = Namespace.new("http://www.w3.org/1999/xhtml", "")
       g = Graph.new(:store => ListStore.new)
       g << Triple.new(
         URIRef.new("http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml"),
-        URIRef.new("http://purl.org/dc/elements/1.1/title"),
-        Literal.typed("E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">2</sup>: The Most Urgent Problem of Our Time",
+        URIRef.new("http://purl.org/dc/terms/title"),
+        Literal.typed("E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/terms/\">2</sup>: The Most Urgent Problem of Our Time",
                       "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
                       g.nsbinding)
       )
@@ -136,20 +136,20 @@ describe "Graphs" do
     }
     
     it "should output NTriple" do
-      nt = '<http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml> <http://purl.org/dc/elements/1.1/title> "E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">2</sup>: The Most Urgent Problem of Our Time"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral> .' + "\n"
+      nt = '<http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml> <http://purl.org/dc/terms/title> "E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/terms/\">2</sup>: The Most Urgent Problem of Our Time"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral> .' + "\n"
       subject.to_ntriples.should == nt
     end
 
     it "should output RDF/XML" do
       rdfxml = <<-HERE
 <?xml version="1.0" encoding="UTF-8"?>
-<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:xml=\"http://www.w3.org/XML/1998/namespace\" xmlns:rdfs=\"http://www.w3.org/2000/01/rdf-schema#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:xhv=\"http://www.w3.org/1999/xhtml/vocab#\">
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:xml=\"http://www.w3.org/XML/1998/namespace\" xmlns:rdfs=\"http://www.w3.org/2000/01/rdf-schema#\" xmlns:dc=\"http://purl.org/dc/terms/\" xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:xhv=\"http://www.w3.org/1999/xhtml/vocab#\">
   <rdf:Description rdf:about="http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml">
-    <dc:title rdf:parseType="Literal">E = mc<sup xmlns="http://www.w3.org/1999/xhtml" xmlns:dc="http://purl.org/dc/elements/1.1/">2>/sup>: The Most Urgent Problem of Our Time</dc:title>
+    <dc:title rdf:parseType="Literal">E = mc<sup xmlns="http://www.w3.org/1999/xhtml" xmlns:dc="http://purl.org/dc/terms/">2>/sup>: The Most Urgent Problem of Our Time</dc:title>
   </rdf:Description>
 </rdf:RDF>
 HERE
-      subject.to_rdfxml.should include("E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">2</sup>: The Most Urgent Problem of Our Time")
+      subject.to_rdfxml.should include("E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/terms/\">2</sup>: The Most Urgent Problem of Our Time")
     end
   end
   
@@ -328,6 +328,15 @@ HERE
         subject.properties(@ex.a).has_key?(@ex.b.to_s).should be_true
         subject.properties(@ex.a)[@ex.b.to_s].should include(@ex.c, @ex.d, @ex.e)
       end
+      
+      it "should get asserted properties for a BNode" do
+        bn = BNode.new
+        subject.add_triple(bn, @ex.b, @ex.c)
+        subject.properties(bn).should be_a(Hash)
+        subject.properties(bn).size.should == 1
+        subject.properties(bn).has_key?(@ex.b.to_s).should be_true
+        subject.properties(bn)[@ex.b.to_s].should == [@ex.c]
+      end
 
       it "should get asserted type with single type" do
         subject.add_triple(@ex.a, RDF_TYPE, @ex.Audio)

data/spec/literal_spec.rb

@@ -269,7 +269,7 @@ describe "Literals: " do
     describe "with a namespace" do
       subject {
         Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
-                      :namespaces => {"dc" => Namespace.new("http://purl.org/dc/elements/1.1/", "dc")})
+                      :namespaces => {"dc" => Namespace.new("http://purl.org/dc/terms/", "dc")})
       }
     
       describe "encodings" do
@@ -282,7 +282,7 @@ describe "Literals: " do
       describe "and language" do
         subject {
           Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
-                        :namespaces => {"dc" => Namespace.new("http://purl.org/dc/elements/1.1/", "dc")},
+                        :namespaces => {"dc" => Namespace.new("http://purl.org/dc/terms/", "dc")},
                         :language => "fr")
         }
 
@@ -315,7 +315,7 @@ describe "Literals: " do
           <?xml version="1.0" encoding="UTF-8"?>
           <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">
           <html xmlns="http://www.w3.org/1999/xhtml"
-                xmlns:dc="http://purl.org/dc/elements/1.1/"
+                xmlns:dc="http://purl.org/dc/terms/"
           	  xmlns:ex="http://example.org/rdf/"
           	  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
           	  xmlns:svg="http://www.w3.org/2000/svg">
@@ -334,7 +334,7 @@ describe "Literals: " do
                         "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
                         :namespaces => {
                           "svg" => Namespace.new("http://www.w3.org/2000/svg", "svg"),
-                          "dc" => Namespace.new("http://purl.org/dc/elements/1.1/", "dc")
+                          "dc" => Namespace.new("http://purl.org/dc/terms/", "dc")
                         })
         }
         it "should return xml_args" do subject.xml_args.should == ["<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"></svg:svg>", {"rdf:parseType" => "Literal"}] end
@@ -353,23 +353,23 @@ describe "Literals: " do
     describe "with a default namespace" do
       subject {
         Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
-                      :namespaces => {"" => Namespace.new("http://purl.org/dc/elements/1.1/", "")})
+                      :namespaces => {"" => Namespace.new("http://purl.org/dc/terms/", "")})
       }
     
       describe "encodings" do
-        it "should return n3" do subject.to_n3.should == "\"foo <sup xmlns=\\\"http://purl.org/dc/elements/1.1/\\\">bar</sup> baz!\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+        it "should return n3" do subject.to_n3.should == "\"foo <sup xmlns=\\\"http://purl.org/dc/terms/\\\">bar</sup> baz!\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
         it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
-        it "should return xml_args" do subject.xml_args.should == ["foo <sup xmlns=\"http://purl.org/dc/elements/1.1/\">bar</sup> baz!", {"rdf:parseType" => "Literal"}] end
-        it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup xmlns=\"http://purl.org/dc/elements/1.1/\">bar</sup> baz!</typedLiteral>" end
+        it "should return xml_args" do subject.xml_args.should == ["foo <sup xmlns=\"http://purl.org/dc/terms/\">bar</sup> baz!", {"rdf:parseType" => "Literal"}] end
+        it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup xmlns=\"http://purl.org/dc/terms/\">bar</sup> baz!</typedLiteral>" end
       end
     end
     
     describe "with multiple namespaces" do
       subject {
-        Literal.typed("foo <sup <sup xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+        Literal.typed("foo <sup <sup xmlns:dc=\"http://purl.org/dc/terms/\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
       }
       it "should ignore namespace order" do
-        g = Literal.typed("foo <sup <sup xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+        g = Literal.typed("foo <sup <sup xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns:dc=\"http://purl.org/dc/terms/\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
         should == g
       end
     end

data/spec/matchers.rb

@@ -110,6 +110,7 @@ module Matchers
         ntriples_parser.parse_string_into_model(model, actual.to_ntriples, "http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/")
 
         @results = @query.execute(model)
+        #puts "Redland query results: #{@results.inspect}"
         if @expected_results
           @results.is_boolean? && @results.get_boolean?
         else

data/spec/n3parser_spec.rb

@@ -72,7 +72,7 @@ describe "N3 parser" do
 
       it "should parse multi-line literal" do
         @parser.parse(%(
-  <http://www.example.com/books#book12345> <http://purl.org/dc/elements/1.1/title> """
+  <http://www.example.com/books#book12345> <http://purl.org/dc/terms/title> """
           Foo
           <html:b xmlns:html="http://www.w3.org/1999/xhtml" html:a="b">bar<rdf:Thing xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"><a:b xmlns:a="foo:"></a:b>here<a:c xmlns:a="foo:"></a:c></rd
   f:Thing></html:b>
@@ -261,7 +261,7 @@ describe "N3 parser" do
       it "should map <> to document uri" do
         n3doc = "@prefix : <> ."
         @parser.parse(n3doc, "http://the.document.itself")
-        @parser.graph.nsbinding.should == {"" => Namespace.new("http://the.document.itself", "", true)}
+        @parser.graph.nsbinding.should == {"" => Namespace.new("http://the.document.itself#", "")}
       end
 
       it "should use <> as a prefix and as a triple node" do

data/spec/namespaces_spec.rb

@@ -9,8 +9,8 @@ describe "Namespace" do
     end
     
     it "should create URIRef for frag" do
-      foaf_frag = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf", true)
-      foaf_frag.knows.to_s.should == "http://xmlns.com/foaf/0.1/#knows"
+      foaf_frag = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+      foaf_frag.knows.to_s.should == "http://xmlns.com/foaf/0.1/knows"
     end
   end
   
@@ -50,6 +50,20 @@ describe "Namespace" do
     subject.foo.should == "http://xmlns.com/foaf/0.1/foo"
   end
   
+  describe "no URI normalization" do
+    specify {Namespace.new("http://foo", "foo").uri.should == "http://foo"}
+    specify {Namespace.new("http://foo#", "foo").uri.should == "http://foo#"}
+    specify {Namespace.new("http://foo/", "foo").uri.should == "http://foo/"}
+    specify {Namespace.new("xyz:foo", "foo").uri.should == "xyz:foo"}
+  end
+  
+  it "should not normalize URI" do
+  end
+  
+  describe "serialization" do
+    specify {subject.to_s.should == "foaf: http://xmlns.com/foaf/0.1/"}
+  end
+
   describe '#+' do
     it "should construct URI with +" do
       (subject + "foo").class.should == URIRef

data/spec/rdfa_helper.rb

@@ -3,11 +3,6 @@ module RdfaHelper
   class TestCase
     include Matchers
     
-    TEST_DIR = File.join(File.dirname(__FILE__), 'rdfa-test-suite')
-    NT_DIR = File.join(File.dirname(__FILE__), 'rdfa-triples')
-    BASE_MANIFEST_URL = "http://rdfa.digitalbazaar.com/test-suite/"
-    BASE_TEST_CASE_URL = "#{BASE_MANIFEST_URL}test-cases/"
-    
     HTMLRE = Regexp.new('([0-9]{4,4})\.xhtml')
     TCPATHRE = Regexp.compile('\$TCPATH')
     
@@ -34,7 +29,7 @@ module RdfaHelper
         #next unless statement.subject.uri.to_s.match(/0001/)
         unless self.about
           self.about = Addressable::URI.parse(statement.subject.uri.to_s)
-          self.name = statement.subject.short_name
+          self.name = statement.subject.short_name || self.about
         end
         
         if statement.predicate.short_name == "expectedResults"
@@ -74,7 +69,7 @@ module RdfaHelper
     end
     
     def tcpath
-      BASE_TEST_CASE_URL + (suite == "xhtml" ? "xhtml1" : suite)
+      RDFA_TEST_CASE_URL + (suite == "xhtml" ? "xhtml1" : suite)
     end
     
     # Read in file, and apply modifications to create a properly formatted HTML
@@ -82,7 +77,7 @@ module RdfaHelper
       f = self.inputDocument
       found_head = false
       namespaces = ""
-      body = File.readlines(File.join(TEST_DIR, "tests", f)).map do |line|
+      body = File.readlines(File.join(RDFA_DIR, "tests", f)).map do |line|
         found_head ||= line.match(/<head/)
         if found_head
           line.chop
@@ -118,14 +113,14 @@ module RdfaHelper
     # Read in file, and apply modifications reference either .html or .xhtml
     def results
       f = self.name + ".sparql"
-      body = File.read(File.join(TEST_DIR, "tests", f)).gsub(TCPATHRE, tcpath)
+      body = File.read(File.join(RDFA_DIR, "tests", f)).gsub(TCPATHRE, tcpath)
       
       suite == "xhtml" ? body : body.gsub(HTMLRE, '\1.html')
     end
     
     def triples
       f = self.name + ".nt"
-      body = File.read(File.join(NT_DIR, f)).gsub(TCPATHRE, tcpath)
+      body = File.read(File.join(RDFA_NT_DIR, f)).gsub(TCPATHRE, tcpath)
       suite == "xhtml" ? body : body.gsub(HTMLRE, '\1.html')
     end
     
@@ -151,7 +146,7 @@ module RdfaHelper
         # Run SPARQL query
         @parser.graph.should pass_query(query_string, self)
       else
-        #pending("Query skipped, Redland not installed")
+        raise SparqlException, "Query skipped, Redland not installed"
       end
 
       @parser.graph.to_rdfxml.should be_valid_xml
@@ -166,9 +161,9 @@ module RdfaHelper
       return @test_cases unless @test_cases.empty?
       
       @suite = suite # Process the given test suite
-      @manifest_url = "#{BASE_MANIFEST_URL}#{suite}-manifest.rdf"
+      @manifest_url = "#{RDFA_MANIFEST_URL}#{suite}-manifest.rdf"
       
-      manifest_str = File.read(File.join(TEST_DIR, "#{suite}-manifest.rdf"))
+      manifest_str = File.read(File.join(RDFA_DIR, "#{suite}-manifest.rdf"))
       parser = RdfXmlParser.new
       
       begin

data/spec/rdfa_parser_spec.rb

@@ -1,13 +1,47 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 require 'rdfa_helper'
+require 'patron'
 
 # Time to add your specs!
 # http://rspec.info/
 describe "RDFa parser" do
-  before(:each) { @parser = RdfaParser.new }
+  before(:each) do
+     @parser = RdfaParser.new
+
+     # Don't load external profiles when testing
+     basic_resp = mock("basic_resp")
+     basic_resp.stub(:status).and_return(200)
+     basic_resp.stub(:body).and_return(File.read(File.join(RDFA_DIR, "profiles", "basic.html")))
+
+     foaf_resp = mock("foaf_resp")
+     foaf_resp.stub(:status).and_return(200)
+     foaf_resp.stub(:body).and_return(File.read(File.join(RDFA_DIR, "profiles", "foaf.html")))
+
+     hcard_resp = mock("hcard_resp")
+     hcard_resp.stub(:status).and_return(200)
+     hcard_resp.stub(:body).and_return("HCARD")
+
+     profile_resp = mock("profile_resp")
+     profile_resp.stub(:status).and_return(200)
+     profile_resp.stub(:body).and_return("PROFILE")
+
+     xhv_resp = mock("xhv_resp")
+     xhv_resp.stub(:status).and_return(200)
+     xhv_resp.stub(:body).and_return(File.read(File.join(RDFA_DIR, "profiles", "xhv.html")))
+
+     sess = mock("session")
+     sess.stub(:base_url=)
+     sess.stub(:timeout=)
+     sess.stub(:get).with("http://www.w3.org/2007/08/pyRdfa/profiles/foaf").and_return(foaf_resp)
+     sess.stub(:get).with("http://www.w3.org/2007/08/pyRdfa/profiles/basic").and_return(basic_resp)
+     sess.stub(:get).with("http://www.w3.org/1999/xhtml/vocab").and_return(xhv_resp)
+     sess.stub(:get).with("http://microformats.org/profiles/hcard").and_return(hcard_resp)
+     sess.stub(:get).with("http://www.w3.org/2005/10/profile").and_return(profile_resp)
+     Patron::Session.stub!(:new).and_return(sess)
+   end
   
-  it "should parse simple doc" do
+   it "should parse simple doc" do
     sampledoc = <<-EOF;
     <?xml version="1.0" encoding="UTF-8"?>
     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">
@@ -119,8 +153,12 @@ describe "RDFa parser" do
           specify "test #{t.name}: #{t.title}#{",  (negative test)" unless t.expectedResults}" do
             #puts t.input
             #puts t.results
-            t.run_test do |rdfa_string, rdfa_parser|
-              rdfa_parser.parse(rdfa_string, t.informationResourceInput, :debug => [])
+            begin
+              t.run_test do |rdfa_string, rdfa_parser|
+                rdfa_parser.parse(rdfa_string, t.informationResourceInput, :debug => [])
+              end
+            rescue SparqlException => e
+              pending(e.message) { raise }
             end
           end
         end
@@ -128,15 +166,21 @@ describe "RDFa parser" do
       describe "that are unreviewed" do
         test_cases(suite).each do |t|
           next unless t.status == "unreviewed"
-          #next unless t.name =~ /017\d/
+          #next unless t.name =~ /0185/
           #puts t.inspect
           specify "test #{t.name}: #{t.title}#{",  (negative test)" unless t.expectedResults}" do
             begin
               t.run_test do |rdfa_string, rdfa_parser|
                 rdfa_parser.parse(rdfa_string, t.informationResourceInput, :debug => [])
               end
+            rescue SparqlException => e
+              pending(e.message) { raise }
             rescue Spec::Expectations::ExpectationNotMetError => e
-              pending() {  raise }
+              if t.name =~ /01[789]\d/
+                raise
+              else
+                pending() {  raise }
+              end
             end
           end
         end