rdfa_parser 0.1.0

data/lib/rdfa_parser/uriref.rb

@@ -0,0 +1,94 @@
+require 'net/http'
+
+module RdfaParser
+  class URIRef
+    attr_accessor :uri
+    
+    # Create a URIRef from a URI  or a fragment and a URI
+    #
+    # ==== Example
+    #   u = URIRef.new("http://example.com")
+    #   u = URIRef.new("foo", u) => "http://example.com/foo"
+    # 
+    def initialize (*args)
+      args.each {|s| test_string(s)}
+      if args.size == 1
+        @uri = Addressable::URI.parse(args[0].to_s)
+      else
+        @uri = Addressable::URI.join(*args.map{|s| s.to_s}.reverse)
+      end
+      if @uri.relative?
+        raise UriRelativeException, "<" + @uri.to_s + "> is a relative URI"
+      end
+      if !@uri.to_s.match(/^javascript/).nil?
+        raise ParserException, "Javascript pseudo-URIs are not acceptable"
+      end
+      
+      # Unique URI through class hash to ensure that URIRefs can be easily compared
+      @@uri_hash ||= {}
+      @@uri_hash[@uri.to_s] ||= @uri
+      @uri = @@uri_hash[@uri.to_s]
+    end
+    
+    def + (input)
+      input_uri = Addressable::URI.parse(input.to_s)
+      return URIRef.new(input_uri, self.to_s)
+    end
+    
+    def short_name
+      if @uri.fragment()
+        return @uri.fragment()
+      elsif @uri.path.split("/").last.class == String and @uri.path.split("/").last.length > 0
+        return @uri.path.split("/").last
+      else
+        return false
+      end
+    end
+  
+    def eql?(other)
+      @uri.to_s == other.to_s
+    end
+    alias_method :==, :eql?
+  
+    # Needed for uniq
+    def hash; to_s.hash; end
+  
+    def to_s
+      @uri.to_s
+    end
+  
+    def to_ntriples
+      "<" + @uri.to_s + ">"
+    end
+  
+    # Output URI as QName using URI binding
+    def to_qname(uri_binding = {})
+      uri_base = @uri.to_s
+      sn = short_name.to_s
+      uri_base = uri_base[0, uri_base.length - sn.length]
+      if uri_binding.has_key?(uri_base)
+        "#{uri_binding[uri_base]}:#{sn}"
+      else
+        raise ParserException, "Couldn't find QName for #{@uri}"
+      end
+    end
+    
+    # Output URI as resource reference for RDF/XML
+    def xml_args
+      [{"rdf:resource" => @uri.to_s}]
+    end
+    
+    def test_string (string)
+      string.to_s.each_byte do |b|
+        if b >= 0 and b <= 31
+          raise ParserException, "URI must not contain control characters"
+        end
+      end
+    end
+
+#    def load_graph
+#      get = Net::HTTP.start(@uri.host, @uri.port) {|http| [:xml, http.get(@uri.path)] }
+#      return Reddy::RdfXmlParser.new(get[1].body, @uri.to_s).graph if get[0] == :xml
+#    end
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/rdfa_parser.rb'}"
+puts "Loading rdfa_parser gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/bnode_spec.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+describe "Blank nodes" do
+  describe "which have custom identifiers" do
+    subject { BNode.new("foo") }
+    
+    it "should return identifier" do
+      subject.identifier.should == "foo"
+      subject.to_s.should == "foo"
+    end
+
+    it "should be rejected if they are not acceptable" do
+      b = BNode.new("4cake")
+      b.identifier.should_not == "4cake"
+    end
+
+    it "should be expressible in NT syntax" do
+      subject.to_ntriples.should == "_:foo"
+    end
+
+    it "should be able to determine equality" do
+      other = BNode.new(subject.to_s)
+      should == other
+    end
+
+    it "should be able to determine inequality" do
+      other = URIRef.new('http://somehost.com/wherever.xml')
+      should_not == other
+    end
+
+    it "should resource hash for RDF/XML named bnode" do
+      subject.xml_args.should == [{"rdf:nodeID" => subject.to_s}]
+    end
+  end
+  
+  describe "which has a blank identifier" do
+    subject { BNode.new("") }
+    it "should not be the same as an anonymous identifier" do should_not == BNode.new end
+    it "should be the same as nother blank identifier" do should == BNode.new("") end
+  end
+  
+  it "should create a single BNode for a blank identifier" do
+    BNode.new("").should_not == BNode
+  end
+  
+  describe "which are anonymous" do
+    it "should resource hash for RDF/XML anonymous bnode" do
+      b = BNode.new
+      b.xml_args.should == [{"rdf:nodeID" => b.identifier}]
+    end
+  end
+end

data/spec/graph_spec.rb

@@ -0,0 +1,230 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Graphs" do
+  before(:all) do
+    @ex = Namespace.new("http://example.org/", "ex")
+    @foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+  end
+  
+  subject { Graph.new }
+  it "should allow you to add one or more triples" do
+    lambda do
+      subject.add_triple(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new)
+    end.should_not raise_error
+  end
+  
+  it "should give you a list of resources of a particular type" do
+    subject.add_triple(URIRef.new("http://example.org/joe"), URIRef.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), URIRef.new("http://xmlns.com/foaf/0.1/Person"))
+    subject.add_triple(URIRef.new("http://example.org/jane"), URIRef.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), URIRef.new("http://xmlns.com/foaf/0.1/Person"))
+
+    subject.get_by_type("http://xmlns.com/foaf/0.1/Person").size.should == 2
+    subject.get_by_type("http://xmlns.com/foaf/0.1/Person")[0].to_s.should == "http://example.org/joe"
+    subject.get_by_type("http://xmlns.com/foaf/0.1/Person")[1].to_s.should == "http://example.org/jane"
+  end
+
+  it "should support << as an alias for add_triple" do
+    lambda do
+      subject << Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new)
+    end.should_not raise_error
+    subject.size.should == 1
+  end
+  
+  it "should return bnode subjects" do
+    bn = BNode.new
+    subject.add_triple bn, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new
+    subject.subjects.should == [bn]
+  end
+  
+  it "should be able to determine whether or not it has existing BNodes" do
+    foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    subject << Triple.new(BNode.new('john'), foaf.knows, BNode.new('jane'))
+    subject.has_bnode_identifier?('john').should be_true
+    subject.has_bnode_identifier?('jane').should be_true
+    subject.has_bnode_identifier?('jack').should_not be_true
+  end
+  
+  it "should be able to return BNodes on demand" do
+    john = BNode.new('john')
+    jane = BNode.new('jane')
+    foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    subject << Triple.new(john, foaf.knows, jane)
+    subject.get_bnode_by_identifier('john').should == john
+    subject.get_bnode_by_identifier('jane').should == jane
+    subject.get_bnode_by_identifier('barny').should == false
+  end
+  
+  it "should allow you to create and bind Namespace objects on-the-fly" do
+    subject.namespace("http://xmlns.com/foaf/0.1/", "foaf")
+    subject.nsbinding["foaf"].uri.should == "http://xmlns.com/foaf/0.1/"
+  end
+  
+  it "should not allow you to bind things other than namespaces" do
+    lambda do
+      subject.bind(false)
+    end.should raise_error
+  end
+    
+  it "should follow the specification as to output identical triples" do
+    pending
+  end
+  
+  describe "with XML Literal objects" do
+    subject {
+      dc = Namespace.new("http://purl.org/dc/elements/1.1/", "dc")
+      xhtml = Namespace.new("http://www.w3.org/1999/xhtml", "")
+      g = Graph.new
+      g << Triple.new(
+        URIRef.new("http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml"),
+        URIRef.new("http://purl.org/dc/elements/1.1/title"),
+        Literal.typed("E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">2</sup>: The Most Urgent Problem of Our Time",
+                      "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                      g.nsbinding)
+      )
+      g.bind(dc)
+      g.bind(xhtml)
+      g
+    }
+    
+    it "should output NTriple" do
+      nt = '<http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml> <http://purl.org/dc/elements/1.1/title> "E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">2</sup>: The Most Urgent Problem of Our Time"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral> .' + "\n"
+      subject.to_ntriples.should == nt
+    end
+
+    it "should output RDF/XML" do
+      rdfxml = <<-HERE
+<?xml version="1.0" encoding="UTF-8"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:xml=\"http://www.w3.org/XML/1998/namespace\" xmlns:rdfs=\"http://www.w3.org/2000/01/rdf-schema#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:xhv=\"http://www.w3.org/1999/xhtml/vocab#\">
+  <rdf:Description rdf:about="http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml">
+    <dc:title rdf:parseType="Literal">E = mc<sup xmlns="http://www.w3.org/1999/xhtml" xmlns:dc="http://purl.org/dc/elements/1.1/">2>/sup>: The Most Urgent Problem of Our Time</dc:title>
+  </rdf:Description>
+</rdf:RDF>
+HERE
+      subject.to_rdfxml.should include("E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">2</sup>: The Most Urgent Problem of Our Time")
+    end
+  end
+  
+  describe "with bnodes" do
+    subject {
+      a = BNode.new("a")
+      b = BNode.new("b")
+      
+      g = Graph.new
+      g << Triple.new(a, @foaf.name, Literal.untyped("Manu Sporny"))
+      g << Triple.new(a, @foaf.knows, b)
+      g << Triple.new(b, @foaf.name, Literal.untyped("Ralph Swick"))
+      g.bind(@foaf)
+      g
+    }
+    
+    it "should output RDF/XML" do
+      rdfxml = <<-HERE
+<?xml version="1.0" encoding="utf-8"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:xhv="http://www.w3.org/1999/xhtml/vocab#">
+  <rdf:Description rdf:nodeID="a">
+    <foaf:name>Manu Sporny</foaf:name>
+    <foaf:knows rdf:nodeID="b"/>
+  </rdf:Description>
+  <rdf:Description rdf:nodeID="b">
+    <foaf:name>Ralph Swick</foaf:name>
+  </rdf:Description>
+</rdf:RDF>
+HERE
+      xml = subject.to_rdfxml
+      xml.should include("Ralph Swick")
+      xml.should include("Manu Sporny")
+    end
+  end
+  
+  describe "with triples" do
+    subject {
+      g = Graph.new
+      g.add_triple(@ex.john, @foaf.knows, @ex.jane)
+      g.add_triple(@ex.john, @foaf.knows, @ex.rick)
+      g.add_triple(@ex.jane, @foaf.knows, @ex.rick)
+      g.bind(@foaf)
+      g
+    }
+
+    it "should tell you how large the graph is" do
+      subject.size.should == 3
+    end
+  
+    it "should return unique subjects" do
+      subject.subjects.should == [@ex.john.uri.to_s, @ex.jane.uri.to_s]
+    end
+    
+    it "should allow you to select one resource" do
+      subject.get_resource(@ex.john).size.should == 2
+    end
+
+    it "should allow iteration" do
+      count = 0
+      subject.each do |t|
+        count = count + 1
+        t.class.should == Triple
+      end
+      count.should == 3
+    end
+
+    it "should allow iteration over a particular subject" do
+      count = 0
+      subject.each_with_subject(@ex.john) do |t|
+        count = count + 1
+        t.class.should == Triple
+      end
+      count.should == 2
+    end
+
+    describe "encodings" do
+      it "should output NTriple" do
+        nt = "<http://example.org/john> <http://xmlns.com/foaf/0.1/knows> <http://example.org/jane> .\n<http://example.org/john> <http://xmlns.com/foaf/0.1/knows> <http://example.org/rick> .\n<http://example.org/jane> <http://xmlns.com/foaf/0.1/knows> <http://example.org/rick> .\n"
+        subject.to_ntriples.should == nt
+      end
+    
+      it "should output RDF/XML" do
+        rdfxml = <<HERE
+<?xml version="1.0" encoding="UTF-8"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:xhv="http://www.w3.org/1999/xhtml/vocab#">
+  <rdf:Description rdf:about="http://example.org/john">
+    <foaf:knows rdf:resource="http://example.org/jane"/>
+  </rdf:Description>
+  <rdf:Description rdf:about="http://example.org/john">
+    <foaf:knows rdf:resource="http://example.org/rick"/>
+  </rdf:Description>
+  <rdf:Description rdf:about="http://example.org/jane">
+    <foaf:knows rdf:resource="http://example.org/rick"/>
+  </rdf:Description>
+</rdf:RDF>
+HERE
+        subject.to_rdfxml.should be_equivalent_xml(rdfxml)
+      end
+    end
+  end
+
+  describe "which are joined" do
+    it "should be able to integrate another graph" do
+      subject.add_triple(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new)
+      g = Graph.new
+      g.join(subject)
+      g.size.should == 1
+    end
+    
+    it "should not join with non graph" do
+      lambda do
+        h.join("")
+      end.should raise_error
+    end
+  end
+  
+  describe "that can be compared" do
+    it "should be true for empty graphs" do
+      should be_equivalent_graph(Graph.new)
+    end
+
+    it "should be false for different graphs" do
+      f = Graph.new
+      f.add_triple(URIRef.new("http://example.org/joe"), URIRef.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), URIRef.new("http://xmlns.com/foaf/0.1/Person"))
+      should_not be_equivalent_graph(f)
+    end
+  end
+end

data/spec/literal_spec.rb

@@ -0,0 +1,282 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Literals: " do
+  describe "an untyped string" do
+    subject {Literal.untyped("tom")}
+    it "should be equal if they have the same contents" do should == Literal.untyped("tom") end
+    it "should not be equal if they do not have the same contents" do should_not == Literal.untyped("tim") end
+    it "should match a string" do should == "tom" end
+    it "should return a string using to_s" do subject.to_s.should == "tom" end
+    
+    it "should infer type" do
+      other = Literal.build_from("foo")
+      other.encoding.should == "http://www.w3.org/2001/XMLSchema#string"
+    end
+
+    describe "encodings" do
+      it "should return n3" do subject.to_n3.should == "\"tom\"" end
+      it "should return ntriples" do subject.to_ntriples.should == "\"tom\"" end
+      it "should return xml_args" do subject.xml_args.should == ["tom", {}] end
+      it "should return TriX" do subject.to_trix.should == "<plainLiteral>tom</plainLiteral>" end
+    end
+
+    describe "with extended characters" do
+      subject { Literal.untyped("松本 后子") }
+      
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == "\"\\\u677E\\\u672C \\\u540E\\\u5B50\"" end
+        it "should return ntriples" do subject.to_ntriples.should == "\"\\\u677E\\\u672C \\\u540E\\\u5B50\"" end
+        it "should return xml_args" do subject.xml_args.should == ["松本 后子", {}] end
+        it "should return TriX" do subject.to_trix.should == "<plainLiteral>" + "松本 后子" + "</plainLiteral>" end
+      end
+    end
+    
+    describe "with a language" do
+      subject { Literal.untyped("tom", "en") }
+
+      it "should accept a language tag" do
+        subject.lang.should == "en"
+      end
+  
+      it "should be equal if they have the same contents and language" do
+        should == Literal.untyped("tom", "en")
+      end
+  
+      it "should not be equal if they do not have the same contents" do
+        should_not == Literal.untyped("tim", "en")
+      end
+    
+      it "should not be equal if they do not have the same language" do
+        should_not == Literal.untyped("tom", "fr")
+      end
+
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == "\"tom\"@en" end
+        it "should return ntriples" do subject.to_ntriples.should == "\"tom\"@en" end
+        it "should return xml_args" do subject.xml_args.should == ["tom", {"xml:lang" => "en"}] end
+        it "should return TriX" do subject.to_trix.should == "<plainLiteral xml:lang=\"en\">tom</plainLiteral>" end
+      end
+
+      it "should normalize language tags to lower case" do
+        f = Literal.untyped("tom", "EN")
+        f.lang.should == "en"
+      end
+    end
+  end
+  
+  describe "a typed string" do
+    subject { Literal.typed("tom", "http://www.w3.org/2001/XMLSchema#string") }
+    
+    it "accepts an encoding" do
+      subject.encoding.to_s.should == "http://www.w3.org/2001/XMLSchema#string"
+    end
+
+    it "should be equal if they have the same contents and datatype" do
+      should == Literal.typed("tom", "http://www.w3.org/2001/XMLSchema#string")
+    end
+
+    it "should not be equal if they do not have the same contents" do
+      should_not == Literal.typed("tim", "http://www.w3.org/2001/XMLSchema#string")
+    end
+
+    it "should not be equal if they do not have the same datatype" do
+      should_not == Literal.typed("tom", "http://www.w3.org/2001/XMLSchema#token")
+    end
+
+    describe "encodings" do
+      it "should return n3" do subject.to_n3.should == "\"tom\"^^<http://www.w3.org/2001/XMLSchema#string>" end
+      it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+      it "should return xml_args" do subject.xml_args.should == ["tom", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#string"}] end
+      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#string\">tom</typedLiteral>" end
+    end
+  end
+  
+  describe "an integer" do
+    describe "encodings" do
+      subject { Literal.typed(5, "http://www.w3.org/2001/XMLSchema#int") }
+      it "should return n3" do subject.to_n3.should == "\"5\"^^<http://www.w3.org/2001/XMLSchema#int>" end
+      it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+      it "should return xml_args" do subject.xml_args.should == ["5", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#int"}] end
+      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#int\">5</typedLiteral>" end
+    end
+
+    it "should infer type" do
+      int = Literal.build_from(15)
+      int.encoding.should == "http://www.w3.org/2001/XMLSchema#int"
+    end
+  end
+    
+  describe "a float" do
+    describe "encodings" do
+      subject { Literal.typed(15.4, "http://www.w3.org/2001/XMLSchema#float") }
+      it "should return n3" do subject.to_n3.should == "\"15.4\"^^<http://www.w3.org/2001/XMLSchema#float>" end
+      it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+      it "should return xml_args" do subject.xml_args.should == ["15.4", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#float"}] end
+      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#float\">15.4</typedLiteral>" end
+    end
+
+    it "should infer type" do
+      float = Literal.build_from(15.4)
+      float.encoding.should == "http://www.w3.org/2001/XMLSchema#float"
+    end
+  end
+    
+  describe "XML Literal" do
+    describe "with no namespace" do
+      subject { Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral") }
+      it "should indicate xmlliteral?" do
+        subject.xmlliteral?.should == true
+      end
+      
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == "\"foo <sup>bar</sup> baz!\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+        it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+        it "should return xml_args" do subject.xml_args.should == ["foo <sup>bar</sup> baz!", {"rdf:parseType" => "Literal"}] end
+        it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup>bar</sup> baz!</typedLiteral>" end
+      end
+      
+      it "should be equal if they have the same contents" do
+        should == Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+      end
+
+      it "should be a XMLLiteral encoding" do
+        subject.encoding.should == "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral"
+      end
+    end
+      
+    describe "with a namespace" do
+      subject {
+        Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                      :namespaces => {"dc" => Namespace.new("http://purl.org/dc/elements/1.1/", "dc")})
+      }
+    
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == "\"foo <sup xmlns:dc=\\\"http://purl.org/dc/elements/1.1/\\\">bar</sup> baz!\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+        it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+        it "should return xml_args" do subject.xml_args.should == ["foo <sup xmlns:dc=\"http://purl.org/dc/elements/1.1/\">bar</sup> baz!", {"rdf:parseType" => "Literal"}] end
+        it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup xmlns:dc=\"http://purl.org/dc/elements/1.1/\">bar</sup> baz!</typedLiteral>" end
+      end
+      
+      describe "and language" do
+        subject {
+          Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                        :namespaces => {"dc" => Namespace.new("http://purl.org/dc/elements/1.1/", "dc")},
+                        :language => "fr")
+        }
+
+        describe "encodings" do
+          it "should return n3" do subject.to_n3.should == "\"foo <sup xmlns:dc=\\\"http://purl.org/dc/elements/1.1/\\\" xml:lang=\\\"fr\\\">bar</sup> baz!\"\^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+          it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+          it "should return xml_args" do subject.xml_args.should == ["foo <sup xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xml:lang=\"fr\">bar</sup> baz!", {"rdf:parseType" => "Literal"}] end
+          it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xml:lang=\"fr\">bar</sup> baz!</typedLiteral>" end
+        end
+      end
+      
+      describe "and language with an existing language embedded" do
+        subject {
+          Literal.typed("foo <sup>bar</sup><sub xml:lang=\"en\">baz</sub>",
+                        "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                        :language => "fr")
+        }
+
+        describe "encodings" do
+          it "should return n3" do subject.to_n3.should == "\"foo <sup xml:lang=\\\"fr\\\">bar</sup><sub xml:lang=\\\"en\\\">baz</sub>\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+          it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+          it "should return xml_args" do subject.xml_args.should == ["foo <sup xml:lang=\"fr\">bar</sup><sub xml:lang=\"en\">baz</sub>", {"rdf:parseType" => "Literal"}] end
+          it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup xml:lang=\"fr\">bar</sup><sub xml:lang=\"en\">baz</sub></typedLiteral>" end
+        end
+      end
+      
+      describe "and namespaced element" 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/elements/1.1/"
+          	  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
+          Literal.typed(content,
+                        "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                        :namespaces => {"svg" => Namespace.new("http://www.w3.org/2000/svg", "svg")})
+        }
+        it "should return xml_args" do subject.xml_args.should == ["<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"></svg:svg>", {"rdf:parseType" => "Literal"}] end
+      end
+      
+      describe "and existing namespace definition" do
+        subject {
+          Literal.typed("<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"/>",
+                        "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                        :namespaces => {"svg" => Namespace.new("http://www.w3.org/2000/svg", "svg")})
+        }
+        it "should return xml_args" do subject.xml_args.should == ["<svg:svg xmlns:svg=\"http://www.w3.org/2000/svg\"></svg:svg>", {"rdf:parseType" => "Literal"}] end
+      end
+    end
+      
+    describe "with a default namespace" do
+      subject {
+        Literal.typed("foo <sup>bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                      :namespaces => {"" => Namespace.new("http://purl.org/dc/elements/1.1/", "")})
+      }
+    
+      describe "encodings" do
+        it "should return n3" do subject.to_n3.should == "\"foo <sup xmlns=\\\"http://purl.org/dc/elements/1.1/\\\">bar</sup> baz!\"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>" end
+        it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+        it "should return xml_args" do subject.xml_args.should == ["foo <sup xmlns=\"http://purl.org/dc/elements/1.1/\">bar</sup> baz!", {"rdf:parseType" => "Literal"}] end
+        it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral\">foo <sup xmlns=\"http://purl.org/dc/elements/1.1/\">bar</sup> baz!</typedLiteral>" end
+      end
+    end
+    
+    describe "with multiple namespaces" do
+      subject {
+        Literal.typed("foo <sup <sup xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+      }
+      it "should ignore namespace order" do
+        g = Literal.typed("foo <sup <sup xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+        should == g
+      end
+    end
+    
+    describe "with multiple attributes" do
+      it "should ignore attribute order" do
+        f = Literal.typed("foo <sup a=\"a\" b=\"b\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+        g = Literal.typed("foo <sup b=\"b\" a=\"a\">bar</sup> baz!", "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+        f.should == g
+      end
+    end
+  end
+  
+#  it "build_from_language" do
+#    english = Literal.build_from_language("Have a nice day")
+#    english.encoding.should == "en"
+#    
+#    french = Literal.build_from_language("Bonjour, madame. Parlez vous francais?")
+#    french.encoding.should == "fr"
+#    
+#    german = Literal.build_from_language("Achtung")
+#    german.encoding.should == "de"
+#  end
+
+  # TODO: refactor based on new interface
+  # describe "Languages" do
+  #   it "should be inspectable" do
+  #     literal = Reddy::Literal.new("foo", "en")
+  #     lang = literal.lang
+  #     lang.to_s == "en"
+  #     lang.hash.class.should == Fixnum
+  #   end    
+  # end
+  
+end