rdf-n3 0.2.1 → 0.2.2

data/History.txt

@@ -1,3 +1,13 @@
+=== 0.2.2
+* Ruby 1.9.2 compatibility
+* Added script/tc to run test cases
+* Fixed RDF.to_s != RDF.to_uri.to_s in writer, it worke for every other vocabulary
+* Handle XMLLiteral when value is a Nokogiri node set.
+* Simplify process_uri by not having a special case for ^# type URIs.
+* Unescape values when creating URIs.
+* URI normalization isn't required for N3, so removed.
+* Added Reader#rewind and #close as stubs because document is parsed on initialize and input is closed.
+
 === 0.2.1
 * Compatible with RDF.rb 0.2.1
 

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.2.2

data/lib/rdf/n3.rb

@@ -6,7 +6,7 @@ module RDF
   # **`RDF::N3`** is an Notation-3 plugin for RDF.rb.
   #
   # @example Requiring the `RDF::N3` module
-  #   require 'rdf/rdfxml'
+  #   require 'rdf/n3'
   #
   # @example Parsing RDF statements from an N3 file
   #   RDF::N3::Reader.open("etc/foaf.n3") do |reader|

data/lib/rdf/n3/patches/literal_normalization.rb

@@ -20,8 +20,7 @@ module RDF; class Literal
     ##
     # @param  [Object] value
     # @option options [String] :lexical (nil)
-    # @option options [Hash] :namespaces (nil)
-    # @option options [Hash] :namespaces ({})
+    # @option options [Hash] :namespaces ({}) Use :__default__ or "" to declare default namespace
     # @option options [Symbol] :language (nil)
     # @option options [Symbol] :library (:nokogiri, :libxml, or :rexml)
     def initialize(value, options = {})
@@ -69,7 +68,8 @@ module RDF; class Literal
     def parse_value(value, options)
       ns_hash = {}
       options[:namespaces].each_pair do |prefix, uri|
-        attr = prefix.to_s.empty? ? "xmlns" : "xmlns:#{prefix}"
+        prefix = prefix == :__default__ ? "" : prefix.to_s
+        attr = prefix.empty? ? "xmlns" : "xmlns:#{prefix}"
         ns_hash[attr] = uri.to_s
       end
       ns_strs = []
@@ -94,10 +94,18 @@ module RDF; class Literal
     
     # Nokogiri implementations
     if defined?(::Nokogiri)
+      # A somewhat half-hearted attempt at C14N.
+      # Main problem is that it promotes all namespaces to top element, instead of demoting them
+      # to the required element, and does not properly order either namespaces or attributes.
+      #
+      # An open-issue in Nokogiri is to add support for C14N from the underlying libxml2 libraries.
       def parse_value_nokogiri(value, ns_strs, language)
-        return value if value.is_a?(Nokogiri::XML::NodeSet)
-        # Add inherited namespaces to created root element so that they're inherited to sub-elements
-        elements = Nokogiri::XML::Document.parse("<foo #{ns_strs.join(" ")}>#{value.to_s}</foo>").root.children
+        elements = if value.is_a?(Nokogiri::XML::NodeSet)
+          value
+        else
+          # Add inherited namespaces to created root element so that they're inherited to sub-elements
+          Nokogiri::XML::Document.parse("<foo #{ns_strs.join(" ")}>#{value.to_s}</foo>").root.children
+        end
 
         elements.map do |c|
           if c.is_a?(Nokogiri::XML::Element)
@@ -110,9 +118,9 @@ module RDF; class Literal
               c[prefix] = ns.href.to_s unless c.namespaces[prefix]
             end
 
-            # Add lanuage
+            # Add language
             if language && c["lang"].to_s.empty?
-              c["xml:lang"] = language
+              c["xml:lang"] = language.to_s
             end
           end
           c
@@ -125,6 +133,7 @@ module RDF; class Literal
     end   # Nokogiri
     
     if defined?(::LibXML)
+      # This should use Document#canonicalize if as and when it is available in libxml-ruby
       def parse_value_libxml(value, ns_strs, language)
         # Fixme
       end
@@ -135,6 +144,8 @@ module RDF; class Literal
     end   # LibXML
     
     # REXML
+    # This could make use of the XMLCanonicalizer gem (http://rubygems.org/gems/XMLCanonicalizer)
+    # But, it hasn't been touched since 2007 and relies on log4r.
     def parse_value_rexml(value, ns_strs, language)
       # Fixme
     end

data/lib/rdf/n3/patches/qname_hacks.rb

@@ -21,7 +21,7 @@ module RDF
           raise "Vocab #{vocab.inspect} is not a Vocabulary!" if vocab.is_a?(Array)
           vocab_name = vocab.__name__.to_s.split('::').last.downcase
           local_name = to_s[vocab.to_uri.to_s.size..-1]
-          vocab_name && local_name && [vocab_name.to_sym, local_name.to_sym]
+          vocab_name && local_name && [vocab_name.to_sym, local_name.empty? ? nil : local_name.to_sym]
         end
       end
     #end

data/lib/rdf/n3/patches/seq.rb

@@ -8,7 +8,7 @@ module RDF
 
       #puts "seq; #{rdf_type} #{rdf_type - [RDF.Seq, RDF.Bag, RDF.Alt]}"
       if !(rdf_type - [RDF.Seq, RDF.Bag, RDF.Alt]).empty?
-        props.keys.select {|k| k.match(/#{RDF.to_s}_(\d)$/)}.
+        props.keys.select {|k| k.match(/#{RDF._}(\d)$/)}.
           sort_by {|i| i.sub(RDF._.to_s, "").to_i}.
           map {|key| props[key]}.
           flatten
@@ -31,4 +31,4 @@ module RDF
       end
     end
   end
-end
+end

data/lib/rdf/n3/patches/uri_hacks.rb

@@ -15,5 +15,15 @@ module RDF
       end
       self.class.new(result)
     end
+    
+    # From http://www.w3.org/TR/2004/REC-rdf-concepts-20040210/#section-Graph-URIref
+    #
+    # A URI Reference within an RDF graph is a Unicode string that:
+    # * does not contain any control characters ( #x00 - #x1F, #x7F-#x9F)
+    # * and would produce a valid URI character sequence (per RFC2396 [URI], sections 2.1) representing an absolute URI with optional fragment identifier when subjected to the encoding described below.
+    #
+    # The encoding consists of:
+    # 1. encoding the Unicode string as UTF-8 [RFC-2279], giving a sequence of octet values.
+    # 2. %-escaping octets that do not correspond to permitted US-ASCII characters.
   end
 end

data/lib/rdf/n3/reader.rb

@@ -41,7 +41,7 @@ module RDF::N3
         @debug = options[:debug]
         @strict = options[:strict]
         @uri_mappings = {}
-        @uri = uri(options[:base_uri], nil, true)
+        @uri = uri(options[:base_uri], nil, false)
 
         @doc = input.respond_to?(:read) ? (input.rewind; input.read) : input
         @default_ns = uri("#{options[:base_uri]}#", nil, false) if @uri
@@ -51,6 +51,12 @@ module RDF::N3
       end
     end
 
+    # No need to rewind, as parsing is done in initialize
+    def rewind; end
+    
+    # Document closed when read in initialize
+    def close; end
+    
     ##
     # Iterates the given block for each RDF statement in the input.
     #
@@ -120,8 +126,6 @@ module RDF::N3
       uri = uri.to_s
       if uri == "#"
         uri = @default_ns
-      elsif !uri.match(/[\/\#]$/)
-        uri += "#"
       end
       add_debug("namesspace", "'#{prefix}' <#{uri}>")
       @uri_mappings[prefix] = RDF::URI.intern(uri)
@@ -157,16 +161,23 @@ module RDF::N3
           if s.respond_to?(:nprefix)
             add_debug(*s.info("process_statements(namespace)"))
             keyword_check("prefix") if s.text_value.index("prefix") == 0
-            uri = process_uri(s.explicituri.uri, false)
+            uri = process_uri(s.explicituri.uri)
             namespace(uri, s.nprefix.text_value)
           elsif s.respond_to?(:base)
             add_debug(*s.info("process_statements(base)"))
             keyword_check("base") if s.text_value.index("base") == 0
             # Base, set or update document URI
             uri = s.explicituri.uri.text_value
-            @default_ns = process_uri(uri, false)  # Don't normalize
-            add_debug("@default_ns", "#{@default_ns.inspect}")
             @uri = process_uri(uri)
+            
+            # The empty prefix "" is by default , bound to "#" -- the local namespace of the file.
+            # The parser behaves as though there were a
+            #   @prefix : <#>.
+            # just before the file.
+            # This means that <#foo> can be written :foo and using @keywords one can reduce that to foo.
+            
+            @default_ns =  uri.match(/[\/\#]$/) ? @uri : process_uri("#{uri}#")
+            add_debug("@default_ns", "#{@default_ns.inspect}")
             add_debug("@base", "#{@uri}")
             @uri
           elsif s.respond_to?(:keywords)
@@ -276,7 +287,7 @@ module RDF::N3
         if @keywords && !@keywords.include?(barename)
           build_uri(barename)
         else
-          RDF::Literal.new(barename.delete("@"), :datatype => RDF::XSD.boolean)
+          RDF::Literal.new(barename.delete("@"), :datatype => RDF::XSD.boolean, :validate => @strict, :canonicalize => true)
         end
       elsif expression.respond_to?(:barename)
         add_debug(*expression.info("process_expression(barename)"))
@@ -341,14 +352,9 @@ module RDF::N3
       end
     end
     
-    def process_uri(uri, normalize = true)
+    def process_uri(uri)
       uri = uri.text_value if uri.respond_to?(:text_value)
-      if uri.match(/^\#/)
-        uri(@uri, RDF::NTriples::Writer.escape(uri), false) # This is probably bogus, but allows tests to pass
-      else
-        uri = RDF::NTriples::Writer.escape(uri) unless normalize # Addressable does it's own escaping when normalizing
-        uri(@uri, uri, normalize)
-      end
+      uri(@uri, RDF::NTriples.unescape(uri))
     end
     
     def process_properties(properties)
@@ -392,15 +398,13 @@ module RDF::N3
 
       # Evaluate text_value to remove redundant escapes
       #puts string.elements[1].text_value.dump
-      lit = RDF::Literal.new(RDF::NTriples::Reader.unescape(string.elements[1].text_value), :language => language, :datatype => encoding)
-      raise RDF::ReaderError, %(Typed literal has an invalid lexical value: #{encoding.to_s} "#{lit.value}") if @strict && !lit.valid?
-      lit
+      RDF::Literal.new(RDF::NTriples.unescape(string.elements[1].text_value), :language => language, :validate => @strict, :datatype => encoding, :canonicalize => true)
     end
     
     def process_numeric_literal(object)
       add_debug(*object.info("process_numeric_literal"))
 
-      RDF::Literal.new(RDF::NTriples::Reader.unescape(object.text_value), :datatype => RDF::XSD[object.numericliteral])
+      RDF::Literal.new(RDF::NTriples.unescape(object.text_value), :datatype => RDF::XSD[object.numericliteral], :validate => @strict, :canonicalize => true)
     end
     
     def build_uri(expression)
@@ -408,7 +412,7 @@ module RDF::N3
       localname = expression.localname.text_value if expression.respond_to?(:localname)
       localname ||= (expression.respond_to?(:text_value) ? expression.text_value : expression).to_s.sub(/^:/, "")
       localname = nil if localname.empty? # In N3/Turtle "_:" is not named
-      escaped_localname = RDF::NTriples::Writer.escape(localname.to_s)
+      escaped_localname = RDF::NTriples.escape(localname.to_s)
 
       if expression.respond_to?(:info)
         add_debug(*expression.info("build_uri(#{prefix.inspect}, #{localname.inspect})"))
@@ -418,7 +422,7 @@ module RDF::N3
 
       uri = if @uri_mappings[prefix]
         add_debug(*expression.info("build_uri: (ns): #{@uri_mappings[prefix]}, #{escaped_localname}")) if expression.respond_to?(:info)
-        ns(prefix, RDF::NTriples::Writer.escape(localname.to_s))
+        ns(prefix, RDF::NTriples.escape(localname.to_s))
       elsif prefix == '_'
         add_debug(*expression.info("build_uri: (bnode)")) if expression.respond_to?(:info)
         bnode(localname)
@@ -446,22 +450,17 @@ module RDF::N3
       end
     end
     
-    # Create normalized or unnormalized URIs
-    def uri(value, append, normalize = true)
-      value = value.to_s.sub(/\#$/, "") if normalize
-      value = case value
-      when Addressable::URI then value
-      else Addressable::URI.parse(value.to_s)
-      end
-      
+    # Create URIs
+    def uri(value, append, normalize = false)
+      value = RDF::URI.intern(value)
       value = value.join(append) if append
-      value.normalize! if normalize
-      RDF::URI.intern(value)
+      value
     end
     
     def ns(prefix, suffix)
       prefix = prefix.nil? ? @default_ns.to_s : @uri_mappings[prefix].to_s
       suffix = suffix.to_s.sub(/^\#/, "") if prefix.index("#")
+      add_debug("ns", "prefix: '#{prefix}', suffix: '#{suffix}'")
       RDF::URI.intern(prefix + suffix)
     end
   end

data/lib/rdf/n3/version.rb

@@ -1,7 +1,7 @@
 module RDF::N3::VERSION
   MAJOR = 0
   MINOR = 2
-  TINY  = 1
+  TINY  = 2
   EXTRA = nil
 
   STRING = [MAJOR, MINOR, TINY].join('.')

data/lib/rdf/n3/writer.rb

@@ -379,8 +379,9 @@ module RDF::N3
 
     def add_namespace(prefix, ns)
       return if @namespaces.has_key?(prefix.to_s)
-      add_debug "add_namespace: '#{prefix}', <#{ns}>"
-      @namespaces[prefix.to_s] = ns.to_s
+      uri = (ns.respond_to?(:to_uri) ? ns.to_uri : ns).to_s
+      add_debug "add_namespace: '#{prefix}', <#{uri}>"
+      @namespaces[prefix.to_s] = uri
     end
 
     def reset
@@ -428,6 +429,7 @@ module RDF::N3
     #
     # @param [String] message::
     def add_debug(message)
+      STDERR.puts message if $DEBUG
       @debug << message if @debug.is_a?(Array)
     end
 

data/rdf-n3.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rdf-n3}
-  s.version = "0.2.1"
+  s.version = "0.2.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gregg Kellogg"]
-  s.date = %q{2010-06-28}
+  s.date = %q{2010-08-11}
   s.description = %q{    RDF::N3 is an Notation-3 (n3-rdf) parser for Ruby using the RDF.rb library suite.
 }
   s.email = %q{gregg@kellogg-assoc.com}
@@ -44,6 +44,7 @@ Gem::Specification.new do |s|
      "rdf-n3.gemspec",
      "script/console",
      "script/parse",
+     "script/tc",
      "spec/cwm_spec.rb",
      "spec/format_spec.rb",
      "spec/literal_spec.rb",
@@ -608,7 +609,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/gkellogg/rdf-rdfa}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{Notation-3 (n3-rdf) and Turtle reader/writer for RDF.rb.}
   s.test_files = [
     "spec/cwm_spec.rb",
@@ -627,7 +628,7 @@ Gem::Specification.new do |s|
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<rdf>, [">= 0.2.1"])
       s.add_runtime_dependency(%q<treetop>, [">= 1.4.0"])
       s.add_development_dependency(%q<rspec>, [">= 0"])

data/script/console

@@ -3,6 +3,8 @@
 irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
 
 libs =  " -r irb/completion"
-libs <<  " -r #{File.dirname(__FILE__) + '/../lib/rdf/n3.rb'}"
+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", "n3.rb")}"
 puts "Loading rdf-n3 gem"
 exec "#{irb} #{libs} --simple-prompt"

data/script/parse

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby -s
 require 'rubygems'
-$:.unshift(File.join(File.dirname(__FILE__), "..", 'lib'))
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
 require 'rdf/n3'
 require 'getoptlong'
 

data/script/tc

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby -s
+require 'rubygems'
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
+require 'rdf/n3'
+require 'spec/rdf_helper'
+require 'getoptlong'
+
+def run_tc(tc)
+  puts "run #{tc.name}"
+  puts RDF::Writer.for($format.to_sym).buffer { |writer|
+    RDF::N3::Reader.new(tc.input, :base_uri => tc.about, :strict => $strict).each do |statement|
+      writer << statement
+    end
+  }
+end
+
+$verbose = false
+$format = :ntriples
+$strict = false
+suite = "turtle"
+opts = GetoptLong.new(
+  ["--debug", GetoptLong::NO_ARGUMENT],
+  ["--verbose", GetoptLong::NO_ARGUMENT],
+  ["--quiet", GetoptLong::NO_ARGUMENT],
+  ["--suite", GetoptLong::OPTIONAL_ARGUMENT],
+  ["--strict", 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 $DEBUG = true
+  when '--format' then $format = arg
+  when '--suite' then suite = arg
+  when '--strict' then $strict = true
+  end
+end
+
+# Test URI and directory for different suites
+TEST_PARAMS = {
+  "rdfxml"  => [RDFCORE_TEST, RDFCORE_DIR],
+  "cwm"  => [CWM_TEST, SWAP_DIR],
+  "swap"  => [SWAP_TEST, SWAP_DIR],
+  "turtle"  => [TURTLE_TEST, TURTLE_DIR],
+  "turtlebad"  => [TURTLE_BAD_TEST, TURTLE_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/spec/cwm_spec.rb

@@ -1,3 +1,4 @@
+$:.unshift "."
 require File.join(File.dirname(__FILE__), 'spec_helper')
 require 'rdf/rdfxml'
 

data/spec/format_spec.rb

@@ -1,3 +1,4 @@
+$:.unshift "."
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe RDF::N3::Format do

data/spec/literal_spec.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+$:.unshift "."
 require File.join(File.dirname(__FILE__), 'spec_helper')
 require 'nokogiri'
 
@@ -22,26 +23,64 @@ describe RDF::Literal do
     describe "with a namespace" do
       subject {
         @new.call("foo <dc:sup>bar</dc:sup> baz!", :datatype => RDF.XMLLiteral,
-                      :namespaces => {"dc" => RDF::DC.to_s})
+                      :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},
+                        :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\"></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},
+                        :namespaces => {:dc => RDF::DC.to_s},
                         :language => :fr)
         }
 
@@ -50,6 +89,15 @@ describe RDF::Literal do
     end
 
     describe "with a default namespace" do
+      subject {
+        @new.call("foo <sup>bar</sup> baz!", :datatype => RDF.XMLLiteral,
+                      :namespaces => {:__default__ => 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})
@@ -57,5 +105,141 @@ describe RDF::Literal do
 
       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