rdfa_parser 0.1.0

data/spec/matchers.rb

@@ -0,0 +1,134 @@
+module Matchers
+  class BeEquivalentGraph
+    def initialize(expected, info)
+      @expected = expected
+      @info = info
+    end
+    def matches?(actual)
+      @actual = actual
+      @last_line = 0
+      @sorted_actual = @actual.triples.sort_by{|t| t.to_ntriples}
+      @sorted_expected = @expected.triples.sort_by{|t| t.to_ntriples}
+      0.upto(@sorted_actual.length) do |i|
+        @last_line = i
+        a = @sorted_actual[i]
+        b = @sorted_expected[i]
+        return false unless a == b
+      end
+      @sorted_actual.length == @sorted_expected.length
+    end
+    def failure_message_for_should
+      if @last_line < @sorted_actual.length && @sorted_expected[@last_line]
+        "Graph differs at entry #{@last_line}:\nexpected: #{@sorted_expected[@last_line].to_ntriples}\nactual:   #{@sorted_actual[@last_line].to_ntriples}"
+      elsif @last_line < @actual.triples.length
+        "Graph differs at entry #{@last_line}:\nunexpected: #{@sorted_actual[@last_line].to_ntriples}"
+      else
+        "Graph entry count differs:\nexpected: #{@sorted_expected.length}\nactual:   #{@sorted_actual.length}"
+      end +
+      "\n\n#{@info + "\n" unless @info.empty?}" +
+      "Unsorted Expected:\n#{@expected.to_ntriples}" +
+      "Unsorted Results:\n#{@actual.to_ntriples}"
+    end
+  end
+  
+  def be_equivalent_graph(expected, info = "")
+    BeEquivalentGraph.new(expected, info)
+  end
+
+  # Run expected SPARQL query against actual
+  class PassQuery
+    def initialize(expected, info)
+      @expected = expected
+      @query = Redland::Query.new(expected)
+      @info = info
+    end
+    def matches?(actual)
+      @actual = actual
+      model = Redland::Model.new
+      ntriples_parser = Redland::Parser.ntriples
+      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)
+      if @expected.match(/(This test should result in a 'NO'|negative test case)/)
+        @results.nil? || (@results.is_boolean? && !@results.get_boolean?)
+      else
+        @results.is_boolean? && @results.get_boolean?
+      end
+    end
+    def failure_message_for_should
+      "#{@info + "\n" unless @info.empty?}" +
+      if @results.nil?
+        "Query failed to return results"
+      elsif !@results.is_boolean?
+        "Query returned non-boolean results"
+      else
+        "Query returned false"
+      end +
+      "\n#{@expected}" +
+      "\nResults:\n#{@actual.to_ntriples}"
+    end
+  end
+
+  def pass_query(expected, info = "")
+    PassQuery.new(expected, info)
+  end
+
+  class BeValidXML
+    def initialize(info)
+      @info = info
+    end
+    def matches?(actual)
+      @actual = actual
+      @doc = Nokogiri::XML.parse(actual)
+      @results = @doc.validate
+      @results.nil?
+    rescue
+      false
+    end
+    def failure_message_for_should
+      "#{@info + "\n" unless @info.empty?}" +
+      if @doc.nil?
+        "did not parse"
+      else
+        "\n#{@results}" +
+        "\nParsed:\n#{@doc}"
+      end   +
+        "\nActual:\n#{@actual}"
+    end
+  end
+  
+  def be_valid_xml(info = "")
+    BeValidXML.new(info)
+  end
+
+  class BeEquivalentXML
+    def initialize(expected, info)
+      @expected = expected
+      @info = info
+    end
+    
+    def matches?(actual)
+      @actual = actual
+
+      a = "<foo>#{@actual}</foo>" unless @actual.index("<") == 0
+      e = "<foo>#{@expected}</foo>" unless @actual.index("<") == 0
+      a_hash = ActiveSupport::XmlMini.parse(a)
+      e_hash = ActiveSupport::XmlMini.parse(e)
+      a_hash == e_hash
+    rescue
+      @fault = $!.message
+      false
+    end
+
+    def failure_message_for_should
+      "#{@info + "\n" unless @info.empty?}" +
+      "#{@fault + "\n" unless @fault.nil?}" +
+      "Expected:\n#{@expected}\n" +
+      "Actual:#{@actual}"
+    end
+  end
+  
+  def be_equivalent_xml(expected, info = "")
+    BeEquivalentXML.new(expected, info)
+  end
+end

data/spec/namespace_spec.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Namespace" do
+  subject { Namespace.new("http://xmlns.com/foaf/0.1/", "foaf") }
+
+  describe "method_missing" do
+    it "should create URIRef" do
+      subject.knows.to_s.should == "http://xmlns.com/foaf/0.1/knows"
+    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"
+    end
+  end
+  
+  it "should have a URI" do
+    lambda do
+      test = Namespace.new(short='foaf')
+    end.should raise_error
+  end
+  
+  it "should have equality with URIRefs" do
+      foaf_name = URIRef.new("http://xmlns.com/foaf/0.1/name")
+      subject.name.should == foaf_name
+  end
+  
+  it "should have an XML and N3-friendly prefix" do
+    lambda do
+      test = Namespace.new('http://xmlns.com/foaf/0.1/', '*~{')
+    end.should raise_error
+  end
+  
+  it "should be able to attach to the graph for substitution" do
+    # rdflib does this using graph.bind('prefix', namespace)
+    g = Graph.new
+    subject.bind(g)
+    should == g.nsbinding["foaf"]
+  end
+  
+  it "should not allow you to attach to non-graphs" do
+    lambda do
+      subject.bind("cheese")
+    end.should raise_error
+  end
+  
+  it "should construct URI" do
+    subject.foo.class.should == URIRef
+    subject.foo.should == "http://xmlns.com/foaf/0.1/foo"
+  end
+  
+  it "should construct URI with +" do
+    (subject + "foo").class.should == URIRef
+    (subject + "foo").should == "http://xmlns.com/foaf/0.1/foo"
+  end
+  
+  it "will cause method conflict" do
+    (subject + "class").should == "http://xmlns.com/foaf/0.1/class"
+    subject.class.should ==  Namespace
+  end
+end

data/spec/rdfa_helper.rb

@@ -0,0 +1,127 @@
+require 'rdf/redland'
+
+module RdfaHelper
+  # Class representing test cases in format http://www.w3.org/2006/03/test-description#
+  class TestCase
+    TEST_DIR = File.join(File.dirname(__FILE__), 'xhtml1-testcases')
+    
+    attr_accessor :about
+    attr_accessor :name
+    attr_accessor :contributor
+    attr_accessor :title
+    attr_accessor :informationResourceInput
+    attr_accessor :originalInformationResourceInput
+    attr_accessor :informationResourceResults
+    attr_accessor :originalInformationResourceResults
+    attr_accessor :purpose
+    attr_accessor :reviewStatus
+    attr_accessor :specificationReference
+    attr_accessor :expected_results
+    
+    @@test_cases = []
+    
+    def initialize(statements)
+      expected_results = true
+      statements.each do |statement|
+        next if statement.subject.is_a?(Redland::BNode)
+        unless self.about
+          self.about = URI.parse(statement.subject.uri.to_s)
+          self.name = statement.subject.uri.short_name
+        end
+        
+        if statement.predicate.uri.short_name == "informationResourceInput"
+          self.informationResourceInput = statement.object.uri.to_s.sub!(/^.*xhtml1-testcases/, TEST_DIR)
+          self.originalInformationResourceInput = statement.object.uri.to_s
+        elsif statement.predicate.uri.short_name == "informationResourceResults"
+          self.informationResourceResults = statement.object.uri.to_s.sub!(/^.*xhtml1-testcases/, TEST_DIR)
+          self.originalInformationResourceResults = statement.object.uri.to_s
+        elsif self.respond_to?("#{statement.predicate.uri.short_name}=")
+          s = case
+          when statement.object.literal?  then statement.object.literal
+          when statement.object.resource? then statement.object.uri
+          when statement.object.blank?    then statement.object.blank_identifier
+          else false
+          end
+          self.send("#{statement.predicate.uri.short_name}=", s.to_s)
+        end
+      end
+    end
+    
+    def information
+      %w(purpose specificationReference).map {|a| v = self.send(a); "#{a}: #{v}" if v}.compact.join("\n")
+    end
+    
+    def self.parse_test_cases
+      return unless @@test_cases.empty?
+      
+      manifest = File.read(File.join(TEST_DIR, "rdfa-xhtml1-test-manifest.rdf"))
+      rdfxml_parser = Redland::Parser.new
+      test_hash = {}
+      rdfxml_parser.parse_string_as_stream(manifest, "http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/rdfa-xhtml1-test-manifest.rdf") do |st|
+        a = test_hash[st.subject.uri.to_s] ||= []
+        a << st
+      end
+      
+      @@test_cases = test_hash.values.map {|statements| TestCase.new(statements)}.
+        compact.
+        select{|t| t.reviewStatus == "http://www.w3.org/2006/03/test-description#approved"}.
+        sort_by{|t| t.about.is_a?(URI) ? t.about.to_s : "zzz"}
+    end
+    
+    def self.test_cases; parse_test_cases; @@test_cases; end
+  end
+end
+
+
+class Redland::Uri
+  def short_name
+    u = URI.parse(self.to_s)
+    if u.fragment
+      return u.fragment
+    elsif u.path.split("/").last.class == String and u.path.split("/").last.length > 0
+      return u.path.split("/").last
+    else
+      return false
+    end
+  end
+end
+
+# Simple parser for NTriples
+class NTriplesParser
+  attr_reader :graph
+
+  def initialize(string)
+    @graph = RdfaParser::Graph.new
+    RdfaParser::BNode.reset
+    
+    ntriples_parser = Redland::Parser.ntriples
+    ntriples_parser.parse_string_as_stream(string, "http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/") do |st|
+      s = redland_to_native(st.subject)
+      p = redland_to_native(st.predicate)
+      o = redland_to_native(st.object)
+      @graph.add_triple(s, p, o)
+    end
+  end
+  
+  def redland_to_native(resource)
+#    puts resource.inspect
+    case
+    when resource.literal?
+      node_type = Redland.librdf_node_get_literal_value_datatype_uri(resource.literal.node)
+      node_type = Redland.librdf_uri_to_string(node_type) if node_type
+      RdfaParser::Literal.typed(resource.literal.value, node_type, :language => resource.literal.language)
+    when resource.blank?
+      # Cache anonymous blank identifiers
+      @bn_hash ||= {}
+      id = resource.blank_identifier.to_s
+      id = nil if id.match(/^r[r\d]+$/)
+      bn = @bn_hash[resource.blank_identifier.to_s] ||= RdfaParser::BNode.new(id)
+      bn.identifier
+      bn
+    when resource.resource?
+      RdfaParser::URIRef.new(resource.uri.to_s)
+    else
+      nil
+    end
+  end
+end

data/spec/rdfa_parser_spec.rb

@@ -0,0 +1,119 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+require 'rdfa_helper'
+
+# Time to add your specs!
+# http://rspec.info/
+describe "RDFa parser" 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">
+    <html xmlns="http://www.w3.org/1999/xhtml"
+          xmlns:dc="http://purl.org/dc/elements/1.1/">
+    <head>
+    	<title>Test 0001</title>
+    </head>
+    <body>
+    	<p>This photo was taken by <span class="author" about="photo1.jpg" property="dc:creator">Mark Birbeck</span>.</p>
+    </body>
+    </html>
+    EOF
+
+    parser = RdfaParser::RdfaParser.new
+    parser.parse(sampledoc, "http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0001.xhtml")
+    parser.graph.size.should == 1
+    
+    parser.graph.to_rdfxml.should be_valid_xml
+  end
+
+  it "should parse XML Literal and generate valid XML" 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">
+    <html xmlns="http://www.w3.org/1999/xhtml"
+          xmlns:dc="http://purl.org/dc/elements/1.1/">
+    	<head>
+    		<title>Test 0011</title>
+    	</head>
+      <body>
+      	<div about="">
+          Author: <span property="dc:creator">Albert Einstein</span>
+          <h2 property="dc:title">E = mc<sup>2</sup>: The Most Urgent Problem of Our Time</h2>
+    	</div>
+      </body>
+    </html>
+    EOF
+
+    parser = RdfaParser::RdfaParser.new
+    parser.parse(sampledoc, "http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml")
+    parser.graph.size.should == 2
+    
+    xml = parser.graph.to_rdfxml
+    xml.should be_valid_xml
+    
+    # Ensure that enclosed literal is also valid
+    xml.should include("E = mc<sup xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns=\"http://www.w3.org/1999/xhtml\">2</sup>: The Most Urgent Problem of Our Time")
+  end
+
+
+  it "should parse BNodes" 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">
+    <html xmlns="http://www.w3.org/1999/xhtml"
+          xmlns:foaf="http://xmlns.com/foaf/0.1/">
+      <head>
+    	<title>Test 0017</title>   
+      </head>
+      <body>
+      	 <p>
+              <span about="[_:a]" property="foaf:name">Manu Sporny</span>
+               <span about="[_:a]" rel="foaf:knows"
+    resource="[_:b]">knows</span>
+               <span about="[_:b]" property="foaf:name">Ralph Swick</span>.
+            </p>
+      </body>
+    </html>
+    EOF
+
+    parser = RdfaParser::RdfaParser.new
+    parser.parse(sampledoc, "http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml")
+    parser.graph.size.should == 3
+    
+    xml = parser.graph.to_rdfxml
+    xml.should be_valid_xml
+    
+    xml.should include("Ralph Swick")
+    xml.should include("Manu Sporny")
+  end
+  
+  # W3C Test suite from http://www.w3.org/2006/07/SWD/RDFa/testsuite/
+  describe "w3c xhtml1 testcases" do
+    def self.test_cases
+      RdfaHelper::TestCase.test_cases
+    end
+
+    test_cases.each do |t|
+      #next unless t.name == "Test0100"
+      specify "test #{t.name}: #{t.title}" do
+        rdfa_string = File.read(t.informationResourceInput)
+        rdfa_parser = RdfaParser::RdfaParser.new
+        rdfa_parser.parse(rdfa_string, t.originalInformationResourceInput)
+
+        query_string = t.informationResourceResults ? File.read(t.informationResourceResults) : ""
+
+        if query_string.match(/UNION|OPTIONAL/)
+          # Check triples, as Rasql doesn't implement UNION
+          ntriples = File.read(t.informationResourceResults.sub("sparql", "nt"))
+          parser = NTriplesParser.new(ntriples)
+          rdfa_parser.graph.should be_equivalent_graph(parser.graph, t.information)
+        else
+          rdfa_parser.graph.should pass_query(query_string, t.information)
+        end
+
+        rdfa_parser.graph.to_rdfxml.should be_valid_xml
+      end
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+begin
+  require 'spec'
+  require 'activesupport'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+  gem 'activesupport'
+  require 'activesupport'
+end
+
+ActiveSupport::XmlMini.backend = 'Nokogiri'
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift File.dirname(__FILE__)
+require 'rdfa_parser'
+require 'matchers'
+
+include RdfaParser
+
+Spec::Runner.configure do |config|
+  config.include(Matchers)
+end