rdf-rdfa 0.3.1.2 → 0.3.3

data/spec/test_helper.rb

@@ -0,0 +1,97 @@
+# Spira class for manipulating test-manifest style test suites.
+# Used for SWAP tests
+require 'spira'
+require 'rdf/n3'
+require 'open-uri'
+
+module Fixtures
+  SUITE = RDF::URI("http://rdfa.digitalbazaar.com/test-suite/")
+
+  class TestCase
+    HTMLRE = Regexp.new('([0-9]{4,4})\.xhtml')
+    TCPATHRE = Regexp.compile('\$TCPATH')
+
+    HOST_LANGUAGE_VERSION_SETS = [
+      ["xhtml1",      "rdfa1.1"],
+      ["xml1",        "rdfa1.1"],
+      ["html4",       "rdfa1.1"],
+      ["html5",       "rdfa1.1"],
+      ["xhtml5",      "rdfa1.1"],
+      ["xhtml1",      "rdfa1.0"],
+      ["svgtiny1.2",  "rdfa1.0"],
+      ["svg",         "rdfa1.1"],
+    ]
+
+    class Test < RDF::Vocabulary("http://www.w3.org/2006/03/test-description#"); end
+    class RdfaTest < RDF::Vocabulary("http://rdfa.digitalbazaar.com/vocabs/rdfa-test#"); end
+
+    attr_accessor :debug
+    include Spira::Resource
+
+    type Test.TestCase
+    property :title,          :predicate => DC11.title,                   :type => XSD.string
+    property :purpose,        :predicate => Test.purpose,                 :type => XSD.string
+    has_many :hostLanguage,   :predicate => RdfaTest.hostLanguage,        :type => XSD.string
+    has_many :version,        :predicate => RdfaTest.rdfaVersion,         :type => XSD.string
+    property :expected,       :predicate => Test.expectedResults
+    property :contributor,    :predicate => DC11.contributor,             :type => XSD.string
+    property :reference,      :predicate => Test.specificationRefference, :type => XSD.string
+    property :classification, :predicate => Test.classification
+    property :inputDocument,  :predicate => Test.informationResourceInput
+    property :resultDocument, :predicate => Test.informationResourceResults
+
+    def self.for_specific(host_language, version, classification = nil)
+      each do |tc|
+        yield(tc) if tc.hostLanguage.include?(host_language) &&
+                     tc.version.include?(version) &&
+                     (classification.nil? || tc.classification == classification)
+      end
+    end
+    
+    def expectedResults
+      RDF::Literal::Boolean.new(expected.nil? ? "true" : expected)
+    end
+    
+    def name
+      subject.to_s.split("/").last
+    end
+
+    def input(host_language, version)
+      base = self.inputDocument.to_s.sub('test-cases/', "test-cases/#{host_language}/#{version}/")
+      case host_language
+      when /^xml/   then RDF::URI(base.sub(".html", ".xml"))
+      when /^xhtml/ then RDF::URI(base.sub(".html", ".xhtml"))
+      when /^svg/   then RDF::URI(base.sub(".html", ".svg"))
+      else               RDF::URI(base)
+      end
+    end
+    
+    def results(host_language, version)
+      RDF::URI(self.resultDocument.to_s.sub('test-cases/', "test-cases/#{host_language}/#{version}/"))
+    end
+
+    def trace
+      @debug.to_a.join("\n")
+    end
+    
+    def inspect
+      "[#{self.class.to_s} " + %w(
+        title
+        classification
+        hostLanguage
+        version
+        inputDocument
+        resultDocument
+      ).map {|a| v = self.send(a); "#{a}='#{v}'" if v}.compact.join(", ") +
+      "]"
+    end
+  end
+
+  local_manifest = File.join(File.expand_path(File.dirname(__FILE__)), 'rdfa-test-suite', 'manifest.ttl')
+  repo = if File.exist?(local_manifest)
+    RDF::Repository.load(local_manifest, :base_uri => SUITE.join("manifest.ttl"), :format => :n3)
+  else
+    RDF::Repository.load(SUITE.join("manifest.ttl"), :format => :n3)
+  end
+  Spira.add_repository! :default, repo
+end

data/spec/writer_spec.rb

@@ -0,0 +1,385 @@
+$:.unshift "."
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'rdf/spec/writer'
+require 'rspec/matchers'
+
+class EX < RDF::Vocabulary("http://example/"); end
+
+describe RDF::RDFa::Writer do
+  before(:each) do
+    @graph = RDF::Graph.new
+  end
+  
+  context "generic" do
+    before(:each) do
+      @writer = RDF::RDFa::Writer.new(StringIO.new)
+    end
+    it_should_behave_like RDF_Writer
+  end
+  
+  describe "#buffer" do
+    context "prefix definitions" do
+      subject do
+        @graph << [EX.a, RDF::DC.title, "foo"]
+        serialize(:prefixes => {:dc => "http://purl.org/dc/terms/"})
+      end
+
+      specify { subject.should have_xpath("/xhtml:html/@prefix", %r(dc: http://purl.org/dc/terms/))}
+      specify { subject.should have_xpath("/xhtml:html/@prefix", %r(ex: http://example/))}
+      specify { subject.should_not have_xpath("/xhtml:html/@prefix", %r(bibo:))}
+    end
+
+    context "plain literal" do
+      subject do
+        @graph << [EX.a, EX.b, "foo"]
+        serialize(:haml_options => {:ugly => false})
+      end
+
+      {
+        "/xhtml:html/xhtml:body/xhtml:div/@about" => "ex:a",
+        "//xhtml:div[@class='property']/xhtml:span[@property]/@property" => "ex:b",
+        "//xhtml:div[@class='property']/xhtml:span[@property]/text()" => "foo",
+      }.each do |path, value|
+        it "returns #{value.inspect} for xpath #{path}" do
+          subject.should have_xpath(path, value)
+        end
+      end
+    end
+
+    context "dc:title" do
+      subject do
+        @graph << [EX.a, RDF::DC.title, "foo"]
+        serialize(:prefixes => {:dc => RDF::DC.to_s})
+      end
+
+      {
+        "/xhtml:html/xhtml:head/xhtml:title/text()" => "foo",
+        "/xhtml:html/xhtml:body/xhtml:div/@about" => "ex:a",
+        "/xhtml:html/xhtml:body/xhtml:div/xhtml:h1/@property" => "dc:title",
+        "/xhtml:html/xhtml:body/xhtml:div/xhtml:h1/text()" => "foo",
+      }.each do |path, value|
+        it "returns #{value.inspect} for xpath #{path}" do
+          subject.should have_xpath(path, value)
+        end
+      end
+    end
+
+    context "typed resources" do
+      context "typed resource" do
+        subject do
+          @graph << [EX.a, RDF.type, EX.Type]
+          serialize(:haml_options => {:ugly => false})
+        end
+
+        {
+          "/xhtml:html/xhtml:body/xhtml:div/@about" => "ex:a",
+          "/xhtml:html/xhtml:body/xhtml:div/@typeof" => "ex:Type",
+        }.each do |path, value|
+          it "returns #{value.inspect} for xpath #{path}" do
+            subject.should have_xpath(path, value)
+          end
+        end
+      end
+
+      context "resource with two types" do
+        subject do
+          @graph << [EX.a, RDF.type, EX.t1]
+          @graph << [EX.a, RDF.type, EX.t2]
+          serialize(:haml_options => {:ugly => false})
+        end
+
+        {
+          "/xhtml:html/xhtml:body/xhtml:div/@about" => "ex:a",
+          "/xhtml:html/xhtml:body/xhtml:div/@typeof" => "ex:t1 ex:t2",
+        }.each do |path, value|
+          it "returns #{value.inspect} for xpath #{path}" do
+            subject.should have_xpath(path, value)
+          end
+        end
+      end
+    end
+
+    context "languaged tagged literals" do
+      context "literal with language and no default language" do
+        subject do
+          @graph << [EX.a, RDF::DC.title, RDF::Literal("foo", :language => :en)]
+          serialize(:prefixes => {:dc => "http://purl.org/dc/terms/"})
+        end
+
+        {
+          "/xhtml:html/xhtml:body/xhtml:div/xhtml:h1/@property" => "dc:title",
+          "/xhtml:html/xhtml:body/xhtml:div/xhtml:h1/@lang" => "en",
+        }.each do |path, value|
+          it "returns #{value.inspect} for xpath #{path}" do
+            subject.should have_xpath(path, value)
+          end
+        end
+      end
+
+      context "literal with language and same default language" do
+        subject do
+          @graph << [EX.a, RDF::DC.title, RDF::Literal("foo", :language => :en)]
+          serialize(:lang => :en)
+        end
+
+        {
+          "/xhtml:html/@lang" => "en",
+          "/xhtml:html/xhtml:body/xhtml:div/xhtml:h1/@lang" => false,
+        }.each do |path, value|
+          it "returns #{value.inspect} for xpath #{path}" do
+            subject.should have_xpath(path, value)
+          end
+        end
+      end
+
+      context "literal with language and different default language" do
+        subject do
+          @graph << [EX.a, RDF::DC.title, RDF::Literal("foo", :language => :en)]
+          serialize(:lang => :de)
+        end
+
+        {
+          "/xhtml:html/@lang" => "de",
+          "/xhtml:html/xhtml:body/xhtml:div/xhtml:h1/@lang" => "en",
+        }.each do |path, value|
+          it "returns #{value.inspect} for xpath #{path}" do
+            subject.should have_xpath(path, value)
+          end
+        end
+      end
+    end
+
+    context "typed literals" do
+      describe "xsd:date" do
+        subject do
+          @graph << [EX.a, EX.b, RDF::Literal::Date.new("2011-03-18")]
+          serialize(:haml_options => {:ugly => false})
+        end
+
+        {
+          "//xhtml:span[@property]/@property" => "ex:b",
+          "//xhtml:span[@property]/@datatype" => "xsd:date",
+          "//xhtml:span[@property]/@content" => "2011-03-18",
+          "//xhtml:span[@property]/text()" => "Friday, 18 March 2011",
+        }.each do |path, value|
+          it "returns #{value.inspect} for xpath #{path}" do
+            subject.should have_xpath(path, value)
+          end
+        end
+      end
+
+      context "xsd:time" do
+        subject do
+          @graph << [EX.a, EX.b, RDF::Literal::Time.new("12:34:56")]
+          serialize(:haml_options => {:ugly => false})
+        end
+
+        {
+          "//xhtml:span[@property]/@property" => "ex:b",
+          "//xhtml:span[@property]/@datatype" => "xsd:time",
+          "//xhtml:span[@property]/@content" => "12:34:56",
+          "//xhtml:span[@property]/text()" => /12:34:56/,
+        }.each do |path, value|
+          it "returns #{value.inspect} for xpath #{path}" do
+            subject.should have_xpath(path, value)
+          end
+        end
+      end
+
+      context "xsd:dateTime" do
+        subject do
+          @graph << [EX.a, EX.b, RDF::Literal::DateTime.new("2011-03-18T12:34:56")]
+          serialize(:haml_options => {:ugly => false})
+        end
+
+        {
+          "//xhtml:span[@property]/@property" => "ex:b",
+          "//xhtml:span[@property]/@datatype" => "xsd:dateTime",
+          "//xhtml:span[@property]/@content" => "2011-03-18T12:34:56",
+          "//xhtml:span[@property]/text()" => /12:34:56 \w+ on Friday, 18 March 2011/,
+        }.each do |path, value|
+          it "returns #{value.inspect} for xpath #{path}" do
+            subject.should have_xpath(path, value)
+          end
+        end
+      end
+
+      context "rdf:XMLLiteral" do
+        subject do
+          @graph << [EX.a, EX.b, RDF::Literal::XML.new("E = mc<sup>2</sup>: The Most Urgent Problem of Our Time")]
+          serialize(:haml_options => {:ugly => false})
+        end
+
+        {
+          "//xhtml:span[@property]/@property" => "ex:b",
+          "//xhtml:span[@property]/@datatype" => "rdf:XMLLiteral",
+          "//xhtml:span[@property]" => %r(<span [^>]+>E = mc<sup>2</sup>: The Most Urgent Problem of Our Time<\/span>),
+        }.each do |path, value|
+          it "returns #{value.inspect} for xpath #{path}" do
+            subject.should have_xpath(path, value)
+          end
+        end
+      end
+      
+      context "xsd:string" do
+        subject do
+          @graph << [EX.a, EX.b, RDF::Literal.new("Albert Einstein", :datatype => RDF::XSD.string)]
+          serialize(:haml_options => {:ugly => false})
+        end
+
+        {
+          "//xhtml:span[@property]/@property" => "ex:b",
+          "//xhtml:span[@property]/@datatype" => "xsd:string",
+          "//xhtml:span[@property]/text()" => "Albert Einstein",
+        }.each do |path, value|
+          it "returns #{value.inspect} for xpath #{path}" do
+            subject.should have_xpath(path, value)
+          end
+        end
+      end
+      
+      context "unknown" do
+        subject do
+          @graph << [EX.a, EX.b, RDF::Literal.new("Albert Einstein", :datatype => EX.unknown)]
+          serialize(:haml_options => {:ugly => false})
+        end
+
+        {
+          "//xhtml:span[@property]/@property" => "ex:b",
+          "//xhtml:span[@property]/@datatype" => "ex:unknown",
+          "//xhtml:span[@property]/text()" => "Albert Einstein",
+        }.each do |path, value|
+          it "returns #{value.inspect} for xpath #{path}" do
+            subject.should have_xpath(path, value)
+          end
+        end
+      end
+    end
+    
+    context "multi-valued literals" do
+      subject do
+        @graph << [EX.a, EX.b, "c"]
+        @graph << [EX.a, EX.b, "d"]
+        serialize(:haml_options => {:ugly => false})
+      end
+
+      {
+        "//xhtml:ul/@property" => "ex:b",
+        "//xhtml:ul/xhtml:li[1]/text()" => "c",
+        "//xhtml:ul/xhtml:li[2]/text()" => "d",
+      }.each do |path, value|
+        it "returns #{value.inspect} for xpath #{path}" do
+          subject.should have_xpath(path, value)
+        end
+      end
+    end
+    
+    context "resource objects" do
+      subject do
+        @graph << [EX.a, EX.b, EX.c]
+        serialize(:haml_options => {:ugly => false})
+      end
+
+      {
+        "//xhtml:div/@about" => "ex:a",
+        "//xhtml:a/@rel" => "ex:b",
+        "//xhtml:a/@href" => EX.c.to_s,
+      }.each do |path, value|
+        it "returns #{value.inspect} for xpath #{path}" do
+          subject.should have_xpath(path, value)
+        end
+      end
+    end
+    
+    context "multi-valued resource objects" do
+      subject do
+        @graph << [EX.a, EX.b, EX.c]
+        @graph << [EX.a, EX.b, EX.d]
+        serialize(:haml_options => {:ugly => false})
+      end
+
+      {
+        "//xhtml:div/@about" => "ex:a",
+        "//xhtml:ul/@rel" => "ex:b",
+        "//xhtml:ul/xhtml:li[1]/xhtml:a/@href" => EX.c.to_s,
+        "//xhtml:ul/xhtml:li[2]/xhtml:a/@href" => EX.d.to_s,
+      }.each do |path, value|
+        it "returns #{value.inspect} for xpath #{path}" do
+          subject.should have_xpath(path, value)
+        end
+      end
+    end
+    
+    context "included resource definitions" do
+      subject do
+        @graph << [EX.a, EX.b, EX.c]
+        @graph << [EX.c, EX.d, EX.e]
+        serialize(:haml_options => {:ugly => false})
+      end
+
+      {
+        "/xhtml:html/xhtml:body/xhtml:div/@about" => "ex:a",
+        "//xhtml:div[@about='ex:a']/xhtml:div[@class='property']/xhtml:div[@rel]/@rel" => "ex:b",
+        "//xhtml:div[@rel]/@resource" => "ex:c",
+        "//xhtml:div[@rel]/xhtml:div[@class='property']/xhtml:a/@href" => EX.e.to_s,
+        "//xhtml:div[@rel]/xhtml:div[@class='property']/xhtml:a/@rel" => "ex:d",
+      }.each do |path, value|
+        it "returns #{value.inspect} for xpath #{path}" do
+          subject.should have_xpath(path, value)
+        end
+      end
+    end
+
+    # W3C Test suite from http://www.w3.org/2006/07/SWD/RDFa/testsuite/
+    describe "w3c xhtml testcases" do
+      require 'test_helper'
+
+      # Generate with each template set
+      RDF::RDFa::Writer::HAML_TEMPLATES.each do |name, template|
+        context "Using #{name} template" do
+          Fixtures::TestCase.for_specific("xhtml1", "rdfa1.1", Fixtures::TestCase::Test.required) do |t|
+            next if t.name == "0212"  # XMLLiteral equivalence
+            specify "test #{t.name}: #{t.title}" do
+              begin
+                input = t.input("xhtml1", "rdfa1.1")
+                @graph = RDF::Graph.load(t.input("xhtml1", "rdfa1.1"))
+                result = serialize(:haml => template, :haml_options => {:ugly => false})
+                graph2 = parse(result, :format => :rdfa)
+                graph2.should be_equivalent_graph(@graph, :trace => @debug.unshift(result).join("\n"))
+              rescue RSpec::Expectations::ExpectationNotMetError => e
+                if %w(0198).include?(t.name) || result =~ /XMLLiteral/m
+                  pending("XMLLiteral canonicalization not implemented yet")
+                else
+                  raise
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  require 'rdf/n3'
+  def parse(input, options = {})
+    reader_class = RDF::Reader.for(options[:format]) if options[:format]
+    reader_class ||= options.fetch(:reader, RDF::Reader.for(detect_format(input)))
+  
+    graph = RDF::Graph.new
+    reader_class.new(input, options).each do |statement|
+      graph << statement
+    end
+    graph
+  end
+
+  # Serialize  @graph to a string and compare against regexps
+  def serialize(options = {})
+    @debug = []
+    result = RDF::RDFa::Writer.buffer({:debug => @debug, :standard_prefixes => true}.merge(options)) do |writer|
+      writer << @graph
+    end
+    require 'cgi'
+    puts CGI.escapeHTML(result) if $verbose
+    result
+  end
+end