rdf-rdfa 0.3.4.2 → 0.3.5.1

data/spec/spec.opts

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

data/spec/spec_helper.rb

@@ -1,46 +0,0 @@
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$:.unshift File.dirname(__FILE__)
-
-require "bundler/setup"
-require 'rubygems'
-require 'rspec'
-require 'bigdecimal'  # XXX Remove Me
-require 'rdf/rdfa'
-require 'rdf/spec'
-require 'rdf/spec/matchers'
-require 'rdf/isomorphic'
-require 'open-uri/cached'
-require 'matchers'
-
-# Create and maintain a cache of downloaded URIs
-URI_CACHE = File.expand_path(File.join(File.dirname(__FILE__), "uri-cache"))
-Dir.mkdir(URI_CACHE) unless File.directory?(URI_CACHE)
-OpenURI::Cache.class_eval { @cache_path = URI_CACHE }
-
-::RSpec.configure do |c|
-  c.filter_run :focus => true
-  c.run_all_when_everything_filtered = true
-  c.exclusion_filter = {
-    :ruby => lambda { |version| !(RUBY_VERSION.to_s =~ /^#{version.to_s}/) },
-  }
-  c.include(RDF::Spec::Matchers)
-end
-
-TMP_DIR = File.join(File.expand_path(File.dirname(__FILE__)), "tmp")
-
-# Heuristically detect the input stream
-def detect_format(stream)
-  # Got to look into the file to see
-  if stream.is_a?(IO) || stream.is_a?(StringIO)
-    stream.rewind
-    string = stream.read(1000)
-    stream.rewind
-  else
-    string = stream.to_s
-  end
-  case string
-  when /<html/i   then RDF::RDFa::Reader
-  when /@prefix/i then RDF::N3::Reader
-  else                 RDF::NTriples::Reader
-  end
-end

data/spec/test_helper.rb

@@ -1,97 +0,0 @@
-# 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

@@ -1,410 +0,0 @@
-$:.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   # This seems to have broken sometime before 2011-07-07
-  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
-      
-      context "type template" do
-        subject do
-          @graph << [EX.a, RDF.type, EX.Type]
-          serialize(:haml => RDF::RDFa::Writer::MIN_HAML.merge({
-            EX.Type => {
-              :subject => %q(
-                %span
-                  type-specific subject
-              )
-            }
-          }))
-        end
-
-        {
-          "/xhtml:html/xhtml:body/xhtml:span/text()" => /type-specific subject/,
-        }.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)
-                # Need to put this in to avoid problems with added markup
-                statements = graph2.query(:object => RDF::URI("http://rdf.kellogg-assoc.com/css/distiller.css")).to_a
-                statements.each {|st| graph2.delete(st)}
-                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