rdf-rdfa 0.3.4.2 → 0.3.5.1

data/script/tc

@@ -1,115 +0,0 @@
-#!/usr/bin/env ruby
-require 'rubygems'
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
-require 'rdf/rdfa'
-require 'sparql/grammar'
-require File.expand_path(File.join(File.dirname(__FILE__), "..", 'spec', 'spec_helper'))
-require File.expand_path(File.join(File.dirname(__FILE__), "..", 'spec', 'test_helper'))
-require 'getoptlong'
-
-def run_tc(tc, options)
-  input_uri = tc.input(options[:host_language], options[:version])
-  results_uri = tc.results(options[:host_language], options[:version])
-
-  STDOUT.write "run #{tc.name}"
-
-  if options[:verbose]
-    puts("\nTestCase: #{tc.inspect}") 
-    puts("\nInput:\n" + Kernel.open(input_uri) {|f| f.read}) 
-    puts("\nQuery:\n" + Kernel.open(results_uri) {|f| f.read})
-  end
-
-  pg = RDF::Graph.new if options[:processor_graph]
-
-  begin
-    reader = RDF::RDFa::Reader.new(Kernel.open(input_uri),
-      :base_uri => input_uri,
-      :validate => options[:validate],
-      :processor_graph => pg,
-      :version => options[:version])
-
-    graph = RDF::Graph.new << reader
-  rescue Exception => e
-    puts "#{"exception:" unless options[:quiet]}: #{e}"
-    if options[:quiet]
-      return
-    else
-      raise
-    end
-  end
-  
-  puts("\nResult:\n" + graph.dump(options[:format])) unless options[:quiet]
-  
-  begin
-    result = SPARQL::Grammar.parse(Kernel.open(results_uri)).execute(graph)
-  rescue Exception => e
-    puts "#{"exception:" unless options[:quiet]}: #{e}"
-    return
-  end
-  puts "#{"test result:" unless options[:quiet]} #{(result == (tc.expectedResults || true)) ? 'ok' : 'fail'}"
-  
-  if pg && !options[:quiet]
-    puts "\nProcessor Graph:\n"
-    puts pg.inspect
-    RDF::Writer.for(options[:format]).new do |writer|
-      writer << pg
-    end
-  end
-end
-
-options = {
-  :verbose         => false,
-  :quite           => false,
-  :validate        => false,
-  :format          => :ntriples,
-  :processor_graph => nil,
-  :host_language   => "xhtml1",
-  :version         => "rdfa1.1"
-}
-
-opts = GetoptLong.new(
-  ["--help", "-?", GetoptLong::NO_ARGUMENT],
-  ["--dbg", GetoptLong::NO_ARGUMENT],
-  ["--format", GetoptLong::REQUIRED_ARGUMENT],
-  ["--host-language", "-h", GetoptLong::OPTIONAL_ARGUMENT],
-  ["--processor-graph", GetoptLong::NO_ARGUMENT],
-  ["--quiet", GetoptLong::NO_ARGUMENT],
-  ["--validate", GetoptLong::NO_ARGUMENT],
-  ["--verbose", GetoptLong::NO_ARGUMENT],
-  ["--version", "-v", GetoptLong::OPTIONAL_ARGUMENT]
-)
-
-def help(options)
-  puts "Usage: #{$0} [options] [test-number ...]"
-  puts "Options:"
-  puts "      --dump:               Dump raw output, otherwise serialize to Ruby"
-  puts "      --debug:              Display detailed debug output"
-  puts "      --format:             Format for output, defaults to #{options[:format].inspect}"
-  puts "      --host-language:      Run for specified host language, defaults to #{options[:host_language]}"
-  puts "      --processor-graph:    Output processor graph"
-  puts "      --quiet:              Minimal output"
-  puts "      --validate:           Validate input"
-  puts "      --verbose:            Verbose processing"
-  puts "      --version:            Version of processor to use (rdf1.0, rdf1.1). Defaults to #{options[:version]}"
-  puts "      --help,-?:            This message"
-  exit(0)
-end
-
-opts.each do |opt, arg|
-  case opt
-  when '--help'             then help(options)
-  when '--verbose'          then options[:verbose] = true
-  when '--quiet'            then options[:quiet] = true
-  when '--dbg'              then ::RDF::RDFa::debug = true
-  when '--format'           then options[:format] = arg.to_sym
-  when '--processor-graph'  then options[:processor_graph] = true
-  when '--host-language'    then options[:host_language] = arg
-  when '--version'          then options[:version] = arg
-  when '--validate'         then options[:validate] = true
-  end
-end
-
-Fixtures::TestCase.for_specific(options[:host_language], options[:version]) do |tc|
-  next unless ARGV.empty? || ARGV.any? {|n| tc.name.match(/#{n}/)}
-  run_tc(tc, options)
-end

data/script/yard-to-rubyforge

@@ -1,2 +0,0 @@
-#!/usr/bin/env sh
-rsync -azv doc/yard/ gkellogg@rubyforge.org:/var/www/gforge-projects/rdf/rdfa/

data/spec/.gitignore

@@ -1 +0,0 @@
-/uri-cache/

data/spec/literal_spec.rb

@@ -1,244 +0,0 @@
-# coding: utf-8
-$:.unshift "."
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe RDF::Literal do
-  require 'nokogiri' rescue nil
-
-  before :each do 
-    @new = Proc.new { |*args| RDF::Literal.new(*args) }
-  end
-
-  describe "XML Literal" do
-    describe "with no namespace" do
-      subject { @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral) }
-      it "should return input" do subject.to_s.should == "foo <sup>bar</sup> baz!" end
-
-      it "should be equal if they have the same contents" do
-        should == @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral)
-      end
-    end
-
-    describe "with a namespace" do
-      subject {
-        @new.call("foo <dc:sup>bar</dc:sup> baz!", :datatype => RDF.XMLLiteral,
-                      :namespaces => {:dc => RDF::DC.to_s})
-      }
-
-      it "should add namespaces" do subject.to_s.should == "foo <dc:sup xmlns:dc=\"http://purl.org/dc/terms/\">bar</dc:sup> baz!" end
-
-        describe "as string prefix" do
-          subject {
-            @new.call("foo <dc:sup>bar</dc:sup> baz!", :datatype => RDF.XMLLiteral,
-                          :namespaces => {"dc" => RDF::DC.to_s})
-          }
-
-          it "should add namespaces" do subject.to_s.should == "foo <dc:sup xmlns:dc=\"http://purl.org/dc/terms/\">bar</dc:sup> baz!" end
-        end
-
-      describe "and language" do
-        subject {
-          @new.call("foo <dc:sup>bar</dc:sup> baz!", :datatype => RDF.XMLLiteral,
-                        :namespaces => {:dc => RDF::DC.to_s},
-                        :language => :fr)
-        }
-
-        it "should add namespaces and language" do subject.to_s.should == "foo <dc:sup xmlns:dc=\"http://purl.org/dc/terms/\" xml:lang=\"fr\">bar</dc:sup> baz!" end
-      end
-
-      describe "and node set" do
-        subject {
-          root = Nokogiri::XML.parse(%(<?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/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">
-            <head profile="http://www.w3.org/1999/xhtml/vocab http://www.w3.org/2005/10/profile">
-              <title>Test 0100</title>
-            </head>
-            <body>
-              <div about="http://www.example.org">
-                <h2 property="ex:example" datatype="rdf:XMLLiteral"><svg:svg/></h2>
-              </div>
-            </body>
-          </html>
-          ), nil, nil, Nokogiri::XML::ParseOptions::DEFAULT_XML).root
-          content = root.css("h2").children
-          @new.call(content, :datatype => RDF.XMLLiteral,
-                    :namespaces => {
-                      :svg => "http://www.w3.org/2000/svg",
-                      :dc => "http://purl.org/dc/terms/",
-                    })
-        }
-        it "should add namespace" do subject.to_s.should == "<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\" xmlns:dc=\"http://purl.org/dc/terms/\"></svg:svg>" end
-      end
-
-      describe "and language with an existing language embedded" do
-        subject {
-          @new.call("foo <dc:sup>bar</dc:sup><dc:sub xml:lang=\"en\">baz</dc:sub>",
-                        :datatype => RDF.XMLLiteral,
-                        :namespaces => {:dc => RDF::DC.to_s},
-                        :language => :fr)
-        }
-
-        it "should add namespaces and language" do subject.to_s.should == "foo <dc:sup xmlns:dc=\"http://purl.org/dc/terms/\" xml:lang=\"fr\">bar</dc:sup><dc:sub xmlns:dc=\"http://purl.org/dc/terms/\" xml:lang=\"en\">baz</dc:sub>" end
-      end
-    end
-
-    describe "with a default namespace" do
-      subject {
-        @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral,
-                      :namespaces => {"" => RDF::DC.to_s})
-      }
-
-      it "should add namespace" do subject.to_s.should == "foo <sup xmlns=\"http://purl.org/dc/terms/\">bar</sup> baz!" end
-    end
-
-    describe "with a default namespace (as empty string)" do
-      subject {
-        @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral,
-                      :namespaces => {"" => RDF::DC.to_s})
-      }
-
-      it "should add namespace" do subject.to_s.should == "foo <sup xmlns=\"http://purl.org/dc/terms/\">bar</sup> baz!" end
-    end
-
-    context "rdfcore tests" do
-      context "rdfms-xml-literal-namespaces" do
-        it "should reproduce test001" do
-          l = @new.call("
-      <html:h1>
-        <b>John</b>
-      </html:h1>
-   ",
-                      :datatype => RDF.XMLLiteral,
-                      :namespaces => {
-                        "" => "http://www.w3.org/1999/xhtml",
-                        "rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
-                        "html" => "http://NoHTML.example.org",
-                        "my" => "http://my.example.org/",
-                      })
-
-          pending do
-            l.to_s.should == "\n      <html:h1 xmlns:html=\"http://NoHTML.example.org\">\n        <b xmlns=\"http://www.w3.org/1999/xhtml\">John</b>\n      </html:h1>\n   "
-          end
-        end
-
-        it "should reproduce test002" do
-          l = @new.call("
-    Ramifications of
-       <apply>
-      <power/>
-      <apply>
-	<plus/>
-	<ci>a</ci>
-	<ci>b</ci>
-      </apply>
-      <cn>2</cn>
-    </apply>
-    to World Peace
-  ",
-                      :datatype => RDF.XMLLiteral,
-                      :namespaces => {
-                        "" => "http://www.w3.org/TR/REC-mathml",
-                      })
-
-          l.to_s.should == "\n    Ramifications of\n       <apply xmlns=\"http://www.w3.org/TR/REC-mathml\">\n      <power></power>\n      <apply>\n\t<plus></plus>\n\t<ci>a</ci>\n\t<ci>b</ci>\n      </apply>\n      <cn>2</cn>\n    </apply>\n    to World Peace\n  "
-        end
-      end
-
-      context "rdfms-xmllang" do
-        it "should reproduce test001" do
-          l = @new.call("chat", :datatype => RDF.XMLLiteral, :language => nil)
-
-          l.to_s.should == "chat"
-        end
-        it "should reproduce test002" do
-          l = @new.call("chat", :datatype => RDF.XMLLiteral, :language => :fr)
-
-          l.to_s.should == "chat"
-        end
-      end
-
-      context "xml-canon" do
-        it "should reproduce test001" do
-          l = @new.call("<br />", :datatype => RDF.XMLLiteral)
-
-          l.to_s.should == "<br></br>"
-        end
-      end
-    end
-
-    context "rdfa tests" do
-      it "should reproduce test 0011: XMLLiteral" do
-        l = @new.call("E = mc<sup>2</sup>: The Most Urgent Problem of Our Time",
-                    :datatype => RDF.XMLLiteral,
-                    :namespaces => {"" => "http://www.w3.org/1999/xhtml"})
-
-        l.to_s.should == "E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\">2</sup>: The Most Urgent Problem of Our Time"
-      end
-
-      it "should reproduce test 0092: Tests XMLLiteral content with explicit @datatype" do
-        l = @new.call(%(E = mc<sup>2</sup>: The Most Urgent Problem of Our Time<),
-                    :datatype => RDF.XMLLiteral,
-                    :namespaces => {"" => "http://www.w3.org/1999/xhtml"})
-
-        l.to_s.should == "E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\">2</sup>: The Most Urgent Problem of Our Time"
-      end
-
-      it "should reproduce test 0100: XMLLiteral with explicit namespace" do
-        l = @new.call(%(Some text here in <strong>bold</strong> and an svg rectangle: <svg:svg><svg:rect svg:width="200" svg:height="100"/></svg:svg>),
-                    :datatype => RDF.XMLLiteral,
-                    :namespaces => {
-                      "" => "http://www.w3.org/1999/xhtml",
-                      "svg" => "http://www.w3.org/2000/svg",
-                    })
-
-        pending do
-          l.to_s.should == "Some text here in <strong xmlns=\"http://www.w3.org/1999/xhtml\">bold</strong> and an svg rectangle: <svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"><svg:rect svg:height=\"100\" svg:width=\"200\"></svg:rect></svg:svg>"
-        end
-      end
-
-      it "should reproduce 0101: XMLLiteral with explicit namespace and xml:lang" do
-        l = @new.call(%(Du texte ici en <strong>gras</strong> et un rectangle en svg: <svg:svg><svg:rect svg:width="200" svg:height="100"/></svg:svg>),
-                    :datatype => RDF.XMLLiteral, :language => :fr,
-                    :namespaces => {
-                      "" => "http://www.w3.org/1999/xhtml",
-                      "svg" => "http://www.w3.org/2000/svg",
-                    })
-
-        pending do
-          l.to_s.should == "Du texte ici en <strong xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"fr\">gras</strong> et un rectangle en svg: <svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\" xml:lang=\"fr\"><svg:rect svg:height=\"100\" svg:width=\"200\"></svg:rect></svg:svg>"
-        end
-      end
-
-      it "should reproduce test 0102: XMLLiteral with explicit namespace and xml:lang; not overwriting existing langs" do
-        l = @new.call(%(Du texte ici en <strong>gras</strong> et un rectangle en svg: <svg:svg xml:lang="hu"><svg:rect svg:width="200" svg:height="100"/></svg:svg>),
-                    :datatype => RDF.XMLLiteral, :language => :fr,
-                    :namespaces => {
-                      "" => "http://www.w3.org/1999/xhtml",
-                      "svg" => "http://www.w3.org/2000/svg",
-                    })
-
-        pending do
-          l.to_s.should == "Du texte ici en <strong xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"fr\">gras</strong> et un rectangle en svg: <svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\" xml:lang=\"hu\"><svg:rect svg:height=\"100\" svg:width=\"200\"></svg:rect></svg:svg>"
-        end
-      end
-
-      it "should reproduce test 0103: XMLLiteral with explicit namespace; not overwriting local namespaces" do
-        l = @new.call(%(Some text here in <strong>bold</strong> and an svg rectangle: <svg xmlns="http://www.w3.org/2000/svg"><rect width="200" height="100"/></svg>),
-                    :datatype => RDF.XMLLiteral,
-                    :namespaces => {
-                      "" => "http://www.w3.org/1999/xhtml",
-                      "svg" => "http://www.w3.org/2000/svg",
-                    })
-
-        pending do
-          l.to_s.should == "Some text here in <strong xmlns=\"http://www.w3.org/1999/xhtml\">bold</strong> and an svg rectangle: <svg xmlns=\"http://www.w3.org/2000/svg\"><rect height=\"100\" width=\"200\"></rect></svg>"
-        end
-      end
-    end
-  end if defined?(::Nokogiri)
-end

data/spec/matchers.rb

@@ -1,108 +0,0 @@
-require 'rspec/matchers'
-require 'sparql/grammar'
-
-RSpec::Matchers.define :have_xpath do |xpath, value|
-  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("xhtml" => "http://www.w3.org/1999/xhtml", "xml" => "http://www.w3.org/XML/1998/namespace")
-    case value
-    when false
-      @doc.root.at_xpath(xpath, @namespaces).should be_nil
-    when true
-      @doc.root.at_xpath(xpath, @namespaces).should_not be_nil
-    when Array
-      @doc.root.at_xpath(xpath, @namespaces).to_s.split(" ").should include(*value)
-    when Regexp
-      @doc.root.at_xpath(xpath, @namespaces).to_s.should =~ value
-    else
-      @doc.root.at_xpath(xpath, @namespaces).to_s.should == value
-    end
-  end
-  
-  failure_message_for_should do |actual|
-    msg = "expected that #{xpath.inspect} would be #{value.inspect} in:\n" + actual.to_s
-    msg += "was: #{@doc.root.at_xpath(xpath, @namespaces)}"
-  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 = 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
-
-RSpec::Matchers.define :pass_query do |expected, info|
-  match do |actual|
-    @expected = expected.read
-    @expected = @expected.force_encoding("utf-8") if @expected.respond_to?(:force_encoding)
-    query = SPARQL::Grammar.parse(@expected)
-    actual = actual.force_encoding("utf-8") if actual.respond_to?(:force_encoding)
-    @results = query.execute(actual)
-
-    @results.should == info.expectedResults
-  end
-  
-  failure_message_for_should do |actual|
-    information = info.respond_to?(:information) ? info.information : ""
-    "#{information + "\n" unless information.empty?}" +
-    if @results.nil?
-      "Query failed to return results"
-    elsif !@results.is_a?(RDF::Literal::Boolean)
-      "Query returned non-boolean results"
-    elsif info.expectedResults
-      "Query returned false"
-    else
-      "Query returned true (expected false)"
-    end +
-    "\n#{@expected}" +
-    "\nResults:\n#{@actual.dump(:ntriples)}" +
-    "\nDebug:\n#{info.trace}"
-  end  
-end