rdf-rdfxml 0.3.4 → 0.3.5

data/example.rb

@@ -1,37 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
-
-require 'rubygems'
-require 'rdf/rdfxml'
-
-data = <<-EOF;
-  <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
-
-RDF::RDFXML::Reader.new(data, :base_uri => 'http://example.org/example.xml') do |reader|
-  reader.each_statement do |statement|
-    statement.inspect!
-  end
-end

data/rdf-rdfxml.gemspec

@@ -1,99 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{rdf-rdfxml}
-  s.version = "0.3.4"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = [%q{Gregg Kellogg}]
-  s.date = %q{2011-08-08}
-  s.description = %q{RDF::RDFXML is an RDF/XML reader and writer for the RDF.rb library suite.}
-  s.email = %q{gregg@kellogg-assoc.com}
-  s.extra_rdoc_files = [
-    "AUTHORS",
-    "CONTRIBUTORS",
-    "History.rdoc",
-    "README.md",
-    "UNLICENSE"
-  ]
-  s.files = [
-    ".yardopts",
-    "AUTHORS",
-    "CONTRIBUTORS",
-    "History.rdoc",
-    "README",
-    "README.md",
-    "Rakefile",
-    "UNLICENSE",
-    "VERSION",
-    "etc/doap.nt",
-    "etc/doap.xml",
-    "example.rb",
-    "lib/rdf/rdfxml.rb",
-    "lib/rdf/rdfxml/format.rb",
-    "lib/rdf/rdfxml/patches/array_hacks.rb",
-    "lib/rdf/rdfxml/patches/graph_properties.rb",
-    "lib/rdf/rdfxml/patches/literal_hacks.rb",
-    "lib/rdf/rdfxml/patches/nokogiri_hacks.rb",
-    "lib/rdf/rdfxml/reader.rb",
-    "lib/rdf/rdfxml/version.rb",
-    "lib/rdf/rdfxml/vocab.rb",
-    "lib/rdf/rdfxml/writer.rb",
-    "rdf-rdfxml.gemspec",
-    "script/console",
-    "script/parse",
-    "script/tc",
-    "script/yard-to-rubyforge",
-    "spec/.gitignore",
-    "spec/format_spec.rb",
-    "spec/graph_spec.rb",
-    "spec/literal_spec.rb",
-    "spec/matchers.rb",
-    "spec/rdf_test.rb",
-    "spec/reader_spec.rb",
-    "spec/spec.opts",
-    "spec/spec_helper.rb",
-    "spec/writer_spec.rb"
-  ]
-  s.homepage = %q{http://github.com/gkellogg/rdf-rdfxml}
-  s.require_paths = [%q{lib}]
-  s.rubygems_version = %q{1.8.6}
-  s.summary = %q{RDF/XML reader/writer for RDF.rb.}
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<rdf>, [">= 0.3.3"])
-      s.add_runtime_dependency(%q<nokogiri>, [">= 1.4.4"])
-      s.add_development_dependency(%q<open-uri-cached>, [">= 0"])
-      s.add_development_dependency(%q<spira>, [">= 0.0.12"])
-      s.add_development_dependency(%q<rspec>, [">= 2.5.0"])
-      s.add_development_dependency(%q<rdf-spec>, [">= 0.3.3"])
-      s.add_development_dependency(%q<rdf-isomorphic>, [">= 0.3.4"])
-      s.add_development_dependency(%q<yard>, [">= 0.6.4"])
-    else
-      s.add_dependency(%q<rdf>, [">= 0.3.3"])
-      s.add_dependency(%q<nokogiri>, [">= 1.4.4"])
-      s.add_dependency(%q<open-uri-cached>, [">= 0"])
-      s.add_dependency(%q<spira>, [">= 0.0.12"])
-      s.add_dependency(%q<rspec>, [">= 2.5.0"])
-      s.add_dependency(%q<rdf-spec>, [">= 0.3.3"])
-      s.add_dependency(%q<rdf-isomorphic>, [">= 0.3.4"])
-      s.add_dependency(%q<yard>, [">= 0.6.4"])
-    end
-  else
-    s.add_dependency(%q<rdf>, [">= 0.3.3"])
-    s.add_dependency(%q<nokogiri>, [">= 1.4.4"])
-    s.add_dependency(%q<open-uri-cached>, [">= 0"])
-    s.add_dependency(%q<spira>, [">= 0.0.12"])
-    s.add_dependency(%q<rspec>, [">= 2.5.0"])
-    s.add_dependency(%q<rdf-spec>, [">= 0.3.3"])
-    s.add_dependency(%q<rdf-isomorphic>, [">= 0.3.4"])
-    s.add_dependency(%q<yard>, [">= 0.6.4"])
-  end
-end
-

data/script/console

@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-# File: script/console
-irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
-
-libs =  " -r irb/completion"
-RDF = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "rdf", "lib"))
-libs << " -I #{RDF}" if File.directory?(RDF)
-libs <<  " -r #{File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib", "rdf", "rdfxml.rb")}"
-puts "Loading rdf-rdfxml gem"
-exec "#{irb} #{libs} --simple-prompt"

data/script/parse

@@ -1,55 +0,0 @@
-#!/usr/bin/env ruby
-require 'rubygems'
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
-require 'rdf/rdfxml'
-require 'rdf/n3' rescue nil
-require 'getoptlong'
-require 'open-uri'
-
-def parse(input, base)
-  reader_class = RDF::Reader.for($input_format.to_sym)
-  writer_class = RDF::Writer.for($output_format.to_sym)
-  raise "Reader not found for #{$input_format}" unless reader_class
-  raise "Writer not found for #{$output_format}" unless writer_class
-  puts writer_class.buffer(:standard_prefixes => true) { |writer|
-    reader_class.new(input, :base_uri => base, :validate => true).each do |statement|
-      writer << statement
-    end
-  }
-end
-
-$verbose = false
-$output_format = :ntriples
-$input_format = :rdfxml
-base_uri  = "http://example.com"
-input = nil
-
-opts = GetoptLong.new(
-  ["--debug", GetoptLong::NO_ARGUMENT],
-  ["--verbose", GetoptLong::NO_ARGUMENT],
-  ["--quiet", GetoptLong::NO_ARGUMENT],
-  ["--format", GetoptLong::REQUIRED_ARGUMENT],
-  ["--input-format", GetoptLong::REQUIRED_ARGUMENT],
-  ["--execute", "-e", GetoptLong::REQUIRED_ARGUMENT],
-  ["--uri", GetoptLong::REQUIRED_ARGUMENT]
-)
-opts.each do |opt, arg|
-  case opt
-  when '--verbose' then $verbose = true
-  when '--quiet' then $quiet = true
-  when '--debug' then ::RDF::RDFXML::debug = true
-  when '--execute' then input = arg
-  when '--format' then $output_format = arg
-  when '--input-format' then $input_format = arg
-  when '--uri' then base_uri = arg
-  end
-end
-
-if ARGV.empty?
-  s = input ? input : $stdin.read
-  parse(StringIO.new(s), base_uri)
-else
-  ARGV.each do |test_file|
-    parse(Kernel.open(test_file), base_uri)
-  end
-end

data/script/tc

@@ -1,50 +0,0 @@
-#!/usr/bin/env ruby -s
-require 'rubygems'
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
-require 'rdf/rdfxml'
-require File.expand_path(File.join(File.dirname(__FILE__), "..", 'spec', 'rdf_helper'))
-require 'getoptlong'
-
-def run_tc(tc)
-  puts "run #{tc.name}"
-  puts tc.input if $verbose
-  puts RDF::Writer.for($output_format.to_sym).buffer { |writer|
-    RDF::RDFXML::Reader.new(tc.input, :base_uri => tc.about, :validate => $validate).each do |statement|
-      writer << statement
-    end
-  }
-end
-
-$verbose = false
-$output_format = :ntriples
-$validate = false
-suite = "rdfxml"
-opts = GetoptLong.new(
-  ["--debug", GetoptLong::NO_ARGUMENT],
-  ["--verbose", GetoptLong::NO_ARGUMENT],
-  ["--quiet", GetoptLong::NO_ARGUMENT],
-  ["--suite", GetoptLong::OPTIONAL_ARGUMENT],
-  ["--validate", GetoptLong::NO_ARGUMENT],
-  ["--format", GetoptLong::REQUIRED_ARGUMENT]
-)
-opts.each do |opt, arg|
-  case opt
-  when '--verbose' then $verbose = true
-  when '--quiet' then $quiet = true
-  when '--debug' then ::RDF::RDFXML::debug = true
-  when '--format' then $output_format = arg
-  when '--suite' then suite = arg
-  when '--validate' then $validate = true
-  end
-end
-
-# Test URI and directory for different suites
-TEST_PARAMS = {
-  "rdfxml"  => [RDFCORE_TEST, RDFCORE_DIR],
-}
-test_cases = RdfHelper::TestCase.test_cases(*TEST_PARAMS[suite])
-
-test_cases = test_cases.detect do |tc|
-  next unless ARGV.empty? || ARGV.any? {|n| tc.name.match(/#{n}/)}
-  run_tc(tc)
-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/rdfxml/

data/spec/.gitignore

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

data/spec/format_spec.rb

@@ -1,28 +0,0 @@
-$:.unshift "."
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe RDF::RDFXML::Format do
-  context "discovery" do
-    {
-      "rdf"                 => RDF::Format.for(:rdf),
-      "rdfxml"              => RDF::Format.for(:rdfxml),
-      "etc/foaf.xml"        => RDF::Format.for("etc/foaf.xml"),
-      "etc/foaf.rdf"        => RDF::Format.for("etc/foaf.rdf"),
-      "foaf.xml"            => RDF::Format.for(:file_name      => "foaf.xml"),
-      "foaf.rdf"            => RDF::Format.for(:file_name      => "foaf.xml"),
-      ".xml"                => RDF::Format.for(:file_extension => "xml"),
-      ".rdf"                => RDF::Format.for(:file_extension => "rdf"),
-      "application/xml"     => RDF::Format.for(:content_type   => "application/xml"),
-      "application/rdf+xml" => RDF::Format.for(:content_type   => "application/rdf+xml"),
-    }.each_pair do |label, format|
-      it "should discover '#{label}'" do
-        format.should == RDF::RDFXML::Format
-      end
-    end
-    
-    it "should discover 'xml'" do
-      RDF::Format.for(:xml).reader.should == RDF::RDFXML::Reader
-      RDF::Format.for(:xml).writer.should == RDF::RDFXML::Writer
-    end
-  end
-end

data/spec/graph_spec.rb

@@ -1,59 +0,0 @@
-$:.unshift "."
-require File.join(File.dirname(__FILE__), 'spec_helper')
-require 'rdf/rdfxml/patches/graph_properties'
-
-class EX < RDF::Vocabulary("http://example.com/"); end
-
-describe RDF::Graph do
-  describe "properties" do
-    subject { RDF::Graph.new }
-    
-    it "should get asserted properties" do
-      subject << [EX.a, EX.b, EX.c]
-      subject.properties(EX.a).should be_a(Hash)
-      subject.properties(EX.a).size.should == 1
-      subject.properties(EX.a).has_key?(EX.b.to_s).should be_true
-      subject.properties(EX.a)[EX.b.to_s].should == [EX.c]
-    end
-    
-    it "should get asserted properties with 2 properties" do
-      subject << [EX.a, EX.b, EX.c]
-      subject << [EX.a, EX.b, EX.d]
-      subject.properties(EX.a).should be_a(Hash)
-      subject.properties(EX.a).size.should == 1
-      subject.properties(EX.a).has_key?(EX.b.to_s).should be_true
-      subject.properties(EX.a)[EX.b.to_s].should include(EX.c, EX.d)
-    end
-
-    it "should get asserted properties with 3 properties" do
-      subject << [EX.a, EX.b, EX.c]
-      subject << [EX.a, EX.b, EX.d]
-      subject << [EX.a, EX.b, EX.e]
-      subject.properties(EX.a).should be_a(Hash)
-      subject.properties(EX.a).size.should == 1
-      subject.properties(EX.a).has_key?(EX.b.to_s).should be_true
-      subject.properties(EX.a)[EX.b.to_s].should include(EX.c, EX.d, EX.e)
-    end
-    
-    it "should get asserted properties for a RDF::Node" do
-      bn = RDF::Node.new
-      subject << [bn, EX.b, EX.c]
-      subject.properties(bn).should be_a(Hash)
-      subject.properties(bn).size.should == 1
-      subject.properties(bn).has_key?(EX.b.to_s).should be_true
-      subject.properties(bn)[EX.b.to_s].should == [EX.c]
-    end
-
-    it "should get asserted type with single type" do
-      subject << [EX.a, RDF.type, EX.Audio]
-      subject.properties(EX.a)[RDF.type.to_s].should == [EX.Audio]
-      subject.type_of(EX.a).should == [EX.Audio]
-    end
-  
-    it "should get nil with no type" do
-      subject << [EX.a, EX.b, EX.c]
-      subject.properties(EX.a)[RDF.type.to_s].should == nil
-      subject.type_of(EX.a).should == []
-    end
-  end
-end

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