the-experimenters-rdf-rdfxml 0.3.3

data/spec/matchers.rb

@@ -0,0 +1,79 @@
+require 'rspec/matchers'
+
+RSpec::Matchers.define :have_xpath do |xpath, value, namespaces = {}|
+  match do |actual|
+    @doc = Nokogiri::XML.parse(actual)
+    @doc.should be_a(Nokogiri::XML::Document)
+    @doc.root.should be_a(Nokogiri::XML::Element)
+    @namespaces = @doc.namespaces.
+      merge(namespaces).
+      merge("xhtml" => "http://www.w3.org/1999/xhtml", "xml" => "http://www.w3.org/XML/1998/namespace")
+    @result = @doc.root.at_xpath(xpath, @namespaces) rescue false
+    case value
+    when false
+      @result.should be_nil
+    when Array
+      @result.to_s.split(" ").should include(*value)
+    when Regexp
+      @result.to_s.should =~ value
+    else
+      @result.to_s.should == value
+    end
+  end
+  
+  failure_message_for_should do |actual|
+    msg = "expected to that #{xpath.inspect} would be #{value.inspect} in:\n" + actual.to_s
+    msg += "was: #{@result}"
+  end
+end
+
+def normalize(graph)
+  case graph
+  when RDF::Graph then graph
+  when IO, StringIO
+    RDF::Graph.new.load(graph, :base_uri => @info.about)
+  else
+    # Figure out which parser to use
+    g = RDF::Graph.new
+    reader_class = RDF::Reader.for(detect_format(graph))
+    reader_class.new(graph, :base_uri => @info.about).each {|s| g << s}
+    g
+  end
+end
+
+Info = Struct.new(:about, :information, :trace, :compare, :inputDocument, :outputDocument)
+
+RSpec::Matchers.define :be_equivalent_graph do |expected, info|
+  match do |actual|
+    @info = if info.respond_to?(:about)
+      info
+    elsif info.is_a?(Hash)
+      identifier = info[:identifier] || expected.is_a?(RDF::Graph) ? expected.context : info[:about]
+      trace = info[:trace]
+      trace = trace.join("\n") if trace.is_a?(Array)
+      Info.new(identifier, info[:information] || "", trace, info[:compare])
+    else
+      Info.new(expected.is_a?(RDF::Graph) ? expected.context : info, info.to_s)
+    end
+    @expected = normalize(expected)
+    @actual = normalize(actual)
+    @actual.isomorphic_with?(@expected)
+  end
+  
+  failure_message_for_should do |actual|
+    info = @info.respond_to?(:information) ? @info.information : @info.inspect
+    if @expected.is_a?(RDF::Graph) && @actual.size != @expected.size
+      "Graph entry count differs:\nexpected: #{@expected.size}\nactual:   #{@actual.size}"
+    elsif @expected.is_a?(Array) && @actual.size != @expected.length
+      "Graph entry count differs:\nexpected: #{@expected.length}\nactual:   #{@actual.size}"
+    else
+      "Graph differs"
+    end +
+    "\n#{info + "\n" unless info.empty?}" +
+    (@info.inputDocument ? "Input file: #{@info.inputDocument}\n" : "") +
+    (@info.outputDocument ? "Output file: #{@info.outputDocument}\n" : "") +
+    "Unsorted Expected:\n#{@expected.dump(:ntriples)}" +
+    "Unsorted Results:\n#{@actual.dump(:ntriples)}" +
+    (@info.trace ? "\nDebug:\n#{@info.trace}" : "")
+  end  
+end

data/spec/rdf_test.rb

@@ -0,0 +1,69 @@
+# Spira class for manipulating test-manifest style test suites.
+# Used for SWAP tests
+require 'spira'
+require 'rdf/n3'
+require 'open-uri'
+
+module Fixtures
+  module TestCase
+    class Test < RDF::Vocabulary("http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#"); end
+
+    class Entry
+      attr_accessor :debug
+      attr_accessor :compare
+      include Spira::Resource
+
+      property :description,    :predicate => Test.description,   :type => XSD.string
+      property :status,         :predicate => Test.status,        :type => XSD.string
+      property :warning,        :predicate => Test.warning,       :type => XSD.string
+      property :approval,       :predicate => Test.approval
+      property :issue,          :predicate => Test.issue
+      property :document,       :predicate => Test.document
+      property :discussion,     :predicate => Test.discussion
+      property :inputDocument,  :predicate => Test.inputDocument
+      property :outputDocument, :predicate => Test.outputDocument
+
+      def name
+        subject.to_s.split("#").last
+      end
+
+      def input
+        Kernel.open(self.inputDocument)
+      end
+      
+      def output
+        self.outputDocument ? Kernel.open(self.outputDocument) : ""
+      end
+
+      def information; self.description; end
+      
+      def inspect
+        "[#{self.class.to_s} " + %w(
+          subject
+          description
+          inputDocument
+          outputDocument
+        ).map {|a| v = self.send(a); "#{a}='#{v}'" if v}.compact.join(", ") +
+        "]"
+      end
+    end
+
+    class PositiveParserTest < Entry
+      default_source :entries
+      type Test.PositiveParserTest
+    end
+
+    class NegativeParserTest < Entry
+      default_source :entries
+      type Test.NegativeParserTest
+    end
+    
+    class MiscellaneousTest < Entry
+      default_source :entries
+      type Test.MiscellaneousTest
+    end
+
+    repo = RDF::Repository.load("http://www.w3.org/2000/10/rdf-tests/rdfcore/Manifest.rdf")
+    Spira.add_repository! :entries, repo
+  end
+end

data/spec/reader_spec.rb

@@ -0,0 +1,361 @@
+# coding: utf-8
+$:.unshift "."
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'rdf/spec/reader'
+
+# w3c test suite: http://www.w3.org/TR/rdf-testcases/
+
+describe "RDF::RDFXML::Reader" do
+  before :each do
+    @reader = RDF::RDFXML::Reader
+  end
+
+  it_should_behave_like RDF_Reader
+
+  context "discovery" do
+    {
+      "rdf" => RDF::Reader.for(:rdf),
+      "rdfxml" => RDF::Reader.for(:rdfxml),
+      "etc/foaf.xml" => RDF::Reader.for("etc/foaf.xml"),
+      "etc/foaf.rdf" => RDF::Reader.for("etc/foaf.rdf"),
+      "foaf.xml" => RDF::Reader.for(:file_name      => "foaf.xml"),
+      "foaf.rdf" => RDF::Reader.for(:file_name      => "foaf.rdf"),
+      ".xml" => RDF::Reader.for(:file_extension => "xml"),
+      ".rdf" => RDF::Reader.for(:file_extension => "rdf"),
+      "application/xml" => RDF::Reader.for(:content_type   => "application/xml"),
+      "application/rdf+xml" => RDF::Reader.for(:content_type   => "application/rdf+xml"),
+    }.each_pair do |label, format|
+      it "should discover '#{label}'" do
+        format.should == @reader
+      end
+    end
+  end
+
+  context :interface do
+    before(:each) do
+      @sampledoc = <<-EOF;
+<?xml version="1.0" ?>
+<GenericXML xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ex="http://example.org/">
+  <rdf:RDF>
+    <rdf:Description rdf:about="http://example.org/one">
+      <ex:name>Foo</ex:name>
+    </rdf:Description>
+  </rdf:RDF>
+  <blablabla />
+  <rdf:RDF>
+    <rdf:Description rdf:about="http://example.org/two">
+      <ex:name>Bar</ex:name>
+    </rdf:Description>
+  </rdf:RDF>
+</GenericXML>
+EOF
+    end
+    
+    it "should yield reader" do
+      inner = mock("inner")
+      inner.should_receive(:called).with(@reader)
+      @reader.new(@sampledoc) do |reader|
+        inner.called(reader.class)
+      end
+    end
+    
+    it "should return reader" do
+      @reader.new(@sampledoc).should be_a(@reader)
+    end
+    
+    it "should yield statements" do
+      inner = mock("inner")
+      inner.should_receive(:called).with(RDF::Statement).twice
+      @reader.new(@sampledoc).each_statement do |statement|
+        inner.called(statement.class)
+      end
+    end
+    
+    it "should yield triples" do
+      inner = mock("inner")
+      inner.should_receive(:called).with(RDF::URI, RDF::URI, RDF::Literal).twice
+      @reader.new(@sampledoc).each_triple do |subject, predicate, object|
+        inner.called(subject.class, predicate.class, object.class)
+      end
+    end
+  end
+  
+  context "simple parsing" do
+    it "should recognise and create single triple for empty non-RDF root" do
+      sampledoc = %(<?xml version="1.0" ?>
+        <NotRDF />)
+      graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
+      graph.size.should == 1
+      statement = graph.statements.first
+      statement.subject.class.should == RDF::Node
+      statement.predicate.should == RDF.type
+      statement.object.should == RDF::XML.NotRDF
+    end
+  
+    it "should parse on XML documents with multiple RDF nodes" do
+      sampledoc = <<-EOF;
+<?xml version="1.0" ?>
+<GenericXML xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ex="http://example.org/">
+  <rdf:RDF>
+    <rdf:Description rdf:about="http://example.org/one">
+      <ex:name>Foo</ex:name>
+    </rdf:Description>
+  </rdf:RDF>
+  <blablabla />
+  <rdf:RDF>
+    <rdf:Description rdf:about="http://example.org/two">
+      <ex:name>Bar</ex:name>
+    </rdf:Description>
+  </rdf:RDF>
+</GenericXML>
+EOF
+      graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
+      objects = graph.statements.map {|s| s.object.value}.sort
+      objects.should == ["Bar", "Foo"]
+    end
+  
+    it "should be able to parse a simple single-triple document" do
+      sampledoc = <<-EOF;
+<?xml version="1.0" ?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+xmlns:ex="http://www.example.org/" xml:lang="en" xml:base="http://www.example.org/foo">
+  <ex:Thing rdf:about="http://example.org/joe" ex:name="bar">
+    <ex:belongsTo rdf:resource="http://tommorris.org/" />
+    <ex:sampleText rdf:datatype="http://www.w3.org/2001/XMLSchema#string">foo</ex:sampleText>
+    <ex:hadADodgyRelationshipWith>
+      <rdf:Description>
+        <ex:name>Tom</ex:name>
+        <ex:hadADodgyRelationshipWith>
+          <rdf:Description>
+            <ex:name>Rob</ex:name>
+            <ex:hadADodgyRelationshipWith>
+              <rdf:Description>
+                <ex:name>Mary</ex:name>
+              </rdf:Description>
+            </ex:hadADodgyRelationshipWith>
+          </rdf:Description>
+        </ex:hadADodgyRelationshipWith>
+      </rdf:Description>
+    </ex:hadADodgyRelationshipWith>
+  </ex:Thing>
+</rdf:RDF>
+EOF
+
+      graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
+      #puts @debug
+      graph.size.should == 10
+      # print graph.dump(:ntriples
+      # TODO: add datatype parsing
+      # TODO: make sure the BNode forging is done correctly - an internal element->nodeID mapping
+      # TODO: proper test
+    end
+
+    it "should be able to handle Bags/Alts etc." do
+      sampledoc = <<-EOF;
+<?xml version="1.0" ?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:eg="http://example.org/">
+  <rdf:Bag>
+    <rdf:li rdf:resource="http://tommorris.org/" />
+    <rdf:li rdf:resource="http://twitter.com/tommorris" />
+  </rdf:Bag>
+</rdf:RDF>
+EOF
+      graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
+      graph.predicates.map(&:to_s).should include("http://www.w3.org/1999/02/22-rdf-syntax-ns#_1", "http://www.w3.org/1999/02/22-rdf-syntax-ns#_2")
+    end
+  end
+  
+  context :exceptions do
+    it "should raise an error if rdf:aboutEach is used, as per the negative parser test rdfms-abouteach-error001 (rdf:aboutEach attribute)" do
+      sampledoc = <<-EOF;
+<?xml version="1.0" ?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+         xmlns:eg="http://example.org/">
+
+  <rdf:Bag rdf:ID="node">
+    <rdf:li rdf:resource="http://example.org/node2"/>
+  </rdf:Bag>
+
+  <rdf:Description rdf:aboutEach="#node">
+    <dc:rights xmlns:dc="http://purl.org/dc/elements/1.1/">me</dc:rights>
+
+  </rdf:Description>
+
+</rdf:RDF>
+EOF
+  
+      lambda do
+        graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
+      end.should raise_error(RDF::ReaderError, /Obsolete attribute .*aboutEach/)
+    end
+
+    it "should raise an error if rdf:aboutEachPrefix is used, as per the negative parser test rdfms-abouteach-error002 (rdf:aboutEachPrefix attribute)" do
+      sampledoc = <<-EOF;
+<?xml version="1.0" ?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+         xmlns:eg="http://example.org/">
+
+  <rdf:Description rdf:about="http://example.org/node">
+    <eg:property>foo</eg:property>
+  </rdf:Description>
+
+  <rdf:Description rdf:aboutEachPrefix="http://example.org/">
+    <dc:creator xmlns:dc="http://purl.org/dc/elements/1.1/">me</dc:creator>
+
+  </rdf:Description>
+
+</rdf:RDF>
+EOF
+  
+      lambda do
+        graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
+      end.should raise_error(RDF::ReaderError, /Obsolete attribute .*aboutEachPrefix/)
+    end
+
+    it "should fail if given a non-ID as an ID (as per rdfcore-rdfms-rdf-id-error001)" do
+      sampledoc = <<-EOF;
+<?xml version="1.0"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+ <rdf:Description rdf:ID='333-555-666' />
+</rdf:RDF>
+EOF
+  
+      lambda do
+        graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
+      end.should raise_error(RDF::ReaderError, /ID addtribute '.*' must be a NCName/)
+    end
+
+    it "should make sure that the value of rdf:ID attributes match the XML Name production (child-element version)" do
+      sampledoc = <<-EOF;
+<?xml version="1.0" ?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+         xmlns:eg="http://example.org/">
+ <rdf:Description>
+   <eg:prop rdf:ID="q:name" />
+ </rdf:Description>
+</rdf:RDF>
+EOF
+  
+      lambda do
+        graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
+      end.should raise_error(RDF::ReaderError, /ID addtribute '.*' must be a NCName/)
+    end
+
+    it "should make sure that the value of rdf:ID attributes match the XML Name production (data attribute version)" do
+      sampledoc = <<-EOF;
+<?xml version="1.0" ?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+         xmlns:eg="http://example.org/">
+ <rdf:Description rdf:ID="a/b" eg:prop="val" />
+</rdf:RDF>
+EOF
+  
+      lambda do
+        graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
+      end.should raise_error(RDF::ReaderError, "ID addtribute 'a/b' must be a NCName")
+    end
+  
+    it "should detect bad bagIDs" do
+      sampledoc = <<-EOF;
+<?xml version="1.0" ?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+ <rdf:Description rdf:bagID='333-555-666' />
+</rdf:RDF>
+EOF
+    
+      lambda do
+        graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
+        puts @debug
+      end.should raise_error(RDF::ReaderError, /Obsolete attribute .*bagID/)
+    end
+  end
+  
+  context :reification do
+    it "should be able to reify according to §2.17 of RDF/XML Syntax Specification" do
+      sampledoc = <<-EOF;
+<?xml version="1.0"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+         xmlns:ex="http://example.org/stuff/1.0/"
+         xml:base="http://example.org/triples/">
+  <rdf:Description rdf:about="http://example.org/">
+    <ex:prop rdf:ID="triple1">blah</ex:prop>
+  </rdf:Description>
+</rdf:RDF>
+EOF
+
+      triples = <<-EOF
+<http://example.org/> <http://example.org/stuff/1.0/prop> \"blah\" .
+<http://example.org/triples/#triple1> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement> .
+<http://example.org/triples/#triple1> <http://www.w3.org/1999/02/22-rdf-syntax-ns#subject> <http://example.org/> .
+<http://example.org/triples/#triple1> <http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate> <http://example.org/stuff/1.0/prop> .
+<http://example.org/triples/#triple1> <http://www.w3.org/1999/02/22-rdf-syntax-ns#object> \"blah\" .
+EOF
+
+      graph = parse(sampledoc, :base_uri => "http://example.com", :validate => true)
+      graph.should be_equivalent_graph(triples, :about => "http://example.com/", :trace => @debug)
+    end
+  end
+
+  # W3C Test suite from http://www.w3.org/2000/10/rdf-tests/rdfcore/
+  describe "w3c rdfcore tests" do
+    require 'rdf_test'
+    
+    # Positive parser tests should raise errors.
+    describe "positive parser tests" do
+      Fixtures::TestCase::PositiveParserTest.each do |t|
+        next unless t.status == "APPROVED"
+        #next unless t.about =~ /rdfms-rdf-names-use/
+        #next unless t.name =~ /11/
+        #puts t.inspect
+        specify "#{t.name}: " + (t.description || "#{t.inputDocument} against #{t.outputDocument}") do
+          begin
+            graph = RDF::Graph.new << @reader.new(t.input,
+              :base_uri => t.inputDocument,
+              :validate => false,
+              :debug => t.debug)
+
+            # Parse result graph
+            #puts "parse #{self.outputDocument} as #{RDF::Reader.for(self.outputDocument)}"
+            format = detect_format(t.output)
+            output_graph = RDF::Graph.load(t.outputDocument, :format => format, :base_uri => t.inputDocument)
+            puts "result: #{CGI.escapeHTML(graph.dump(:ntriples))}" if ::RDF::N3::debug?
+            graph.should be_equivalent_graph(output_graph, t)
+          rescue RSpec::Expectations::ExpectationNotMetError => e
+            if t.inputDocument =~ %r(xml-literal|xml-canon)
+              pending("XMLLiteral canonicalization not implemented yet")
+            else
+              raise
+            end
+          end
+        end
+      end
+    end
+    
+    # Negative parser tests should raise errors.
+    describe "negative parser tests" do
+      Fixtures::TestCase::NegativeParserTest.each do |t|
+        next unless t.status == "APPROVED"
+        #next unless t.about =~ /rdfms-empty-property-elements/
+        #next unless t.name =~ /1/
+        #puts t.inspect
+        specify "test #{t.name}: " + (t.description || t.inputDocument) do
+          lambda do
+            RDF::Graph.new << @reader.new(t.input,
+              :base_uri => t.inputDocument,
+              :validate => true)
+          end.should raise_error(RDF::ReaderError)
+        end
+      end
+    end
+  end
+  
+  def parse(input, options)
+    @debug = []
+    graph = RDF::Graph.new
+    @reader.new(input, options.merge(:debug => @debug)).each do |statement|
+      graph << statement
+    end
+    graph
+  end
+end
+