gkellogg-reddy 0.2.1

data/lib/reddy/conjunctive_graph.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), "graph.rb")
+
+module Reddy
+  # ConjunctiveGraph - The top level container for all named Graphs sharing a _Store_
+  #
+  # A ConjuctiveGraph is a graph that can contain other graphs. Graphs are kept distinct
+  # by a _context_, which is the identifier of the sub-graph. It is the union of all graphs in a _Store_.
+  #
+  # For the sake of persistence, Conjunctive Graphs must be distinguished by identifiers (that may not
+  # necessarily be RDF identifiers or may be an RDF identifier normalized - SHA1/MD5 perhaps - for database
+  # naming purposes ) which could be referenced to indicate conjunctive queries (queries made across the
+  # entire conjunctive graph) or appear as nodes in asserted statements. In this latter case, such
+  # statements could be interpreted as being made about the entire 'known' universe.
+  class ConjunctiveGraph < Graph
+    # Store for ConjunctiveGraph must support contexts.
+    def initialize(options = {})
+      unless options[:store] && options[:store].context_aware?
+        raise GraphException.new("Conjuective Graph requires store supporting contexts")
+      end
+    
+      super(:identifier => options[:store].identifier, :store => options[:store])
+      @context_aware = true
+    end
+
+    # The  default_context is a Graph having an _identifier_ the same as the
+    # _identifier_ of the _store_.
+    def default_context
+      @@default_context = Graph.new(:identifier => @store.identifier, :store => @store)
+    end
+    
+    # Parse source into a new context.
+    #
+    # Create a new context (Graph) and parse into that.
+    #
+    # @param  [IO, String] stream:: the RDF IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
+    # @param [String] uri:: the URI of the document
+    # @param [Hash] options:: Options from
+    # <em>options[:debug]</em>:: Array to place debug messages
+    # <em>options[:type]</em>:: One of _rdfxml_, _html_, or _n3_
+    # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
+    # @return [Graph]:: Returns the graph containing parsed triples
+    def parse(stream, uri, options = {}, &block) # :yields: triple
+      graph = Graph.new(:identifier => uri, :store => self.store)
+      Parser.parse(stream, uri, options.merge(:graph => graph), &block)
+    end
+  end
+end

data/lib/reddy/exceptions.rb

@@ -0,0 +1,11 @@
+module Reddy
+  class RdfException < RuntimeError; end
+  class ParserException < RdfException; end
+  class GraphException < RdfException; end
+  class StoreException < RdfException; end
+  class BNodeException < RdfException; end
+  class TypeError < RdfException; end
+  class InvalidPredicate < RdfException; end
+  class InvalidSubject < RdfException; end
+  class InvalidObject < RdfException; end
+end

data/lib/reddy/graph.rb

@@ -0,0 +1,327 @@
+module Reddy
+  # A simple graph to hold triples.
+  #
+  # Graphs store triples, and the namespaces associated with those triples, where defined
+  class Graph
+    attr_reader :triples
+    attr_reader :nsbinding
+    attr_reader :identifier
+    attr_reader :store
+
+    # Create a Graph with the given store and identifier.
+    #
+    # The constructor accepts a _store_ option,
+    # that will be used to store the graph data.
+    #
+    # Stores can be context-aware or unaware.  Unaware stores take up
+    # (some) less space but cannot support features that require
+    # context, such as true merging/demerging of sub-graphs and
+    # provenance.
+    #
+    # The Graph constructor can take an identifier which identifies the Graph
+    # by name.  If none is given, the graph is assigned a BNode for it's identifier.
+    # For more on named graphs, see: http://en.wikipedia.org/wiki/RDFLib
+    #
+    # @param [Hash] options:: Options
+    # <em>options[:store]</em>:: storage, defaults to a new ListStore instance
+    # <em>options[:identifier]</em>:: Identifier for this graph, Literal, BNode or URIRef
+    #
+    # @author Gregg Kellogg
+    def initialize(options = {})
+      @nsbinding = {}
+
+      # Instantiate triple store
+      @store = case options[:store]
+      when AbstractStore  then options[:store]
+      when :list_store    then ListStore.new
+      when :memory_store  then MemoryStore.new
+      else                     MemoryStore.new
+      end
+      
+      @identifier = options[:identifier] || BNode.new
+    end
+
+    def inspect
+      "Graph[id=#{identifier},store=#{store.inspect}]"
+    end
+    
+    def context_aware?; @context_aware; end
+    
+    # Data Store interface
+    def nsbinding; @store.nsbinding; end
+
+    # Destroy the store identified by _configuration_ if supported
+    def destroy(configuration = nil)
+      @store.destroy(configuration)
+      self.freeze
+    end
+
+    # Commit changes to graph
+    def commit; @store.commit; end
+
+    # Rollback active transactions
+    def rollback; @store.rollback; end
+
+    # Open the graph store
+    #
+    # Might be necessary for stores that require opening a connection to a
+    # database or acquiring some resource.
+    def open(configuration, create=false)
+      @store.open(configuration, create)
+    end
+
+    # Close the graph store
+    #
+    # Might be necessary for stores that require closing a connection to a
+    # database or releasing some resource.
+    def close(commit_pending_transaction=false)
+      @store.open(commit_pending_transaction)
+    end
+
+    ## 
+    # Exports the graph to RDF in N-Triples form.
+    #
+    # ==== Example
+    #   g = Graph.new; g.add_triple(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new); g.to_ntriples  # => returns a string of the graph in N-Triples form
+    #
+    # @return [String]:: The graph in N-Triples.
+    #
+    # @author Tom Morris
+    def to_ntriples
+      triples.collect do |t|
+        t.to_ntriples
+      end * "\n" + "\n"
+    end
+    
+    # Output graph using to_ntriples
+    def to_s; self.to_ntriples; end
+
+    ## 
+    # Exports the graph to RDF in RDF/XML form.
+    #
+    # @return [String]:: The RDF/XML graph
+    #
+    # @author Gregg Kellogg
+    def to_rdfxml
+      replace_text = {}
+      rdfxml = ""
+      xml = builder = Builder::XmlMarkup.new(:target => rdfxml, :indent => 2)
+
+      extended_bindings = nsbinding.merge(
+        "rdf"   => RDF_NS,
+        "rdfs"  => RDFS_NS,
+        "xhv"   => XHV_NS,
+        "xml"   => XML_NS
+      )
+      rdf_attrs = extended_bindings.values.inject({}) { |hash, ns| hash.merge(ns.xmlns_attr => ns.uri.to_s)}
+      uri_bindings = extended_bindings.values.inject({}) { |hash, ns| hash.merge(ns.uri.to_s => ns.prefix)}
+      xml.instruct!
+      xml.rdf(:RDF, rdf_attrs) do
+        # Add statements for each subject
+        subjects.each do |s|
+          xml.rdf(:Description, (s.is_a?(BNode) ? "rdf:nodeID" : "rdf:about") => s) do
+            triples(Triple.new(s, nil, nil)) do |triple, context|
+              xml_args = triple.object.xml_args
+              if triple.object.is_a?(Literal) && triple.object.xmlliteral?
+                replace_text["__replace_with_#{triple.object.object_id}__"] = xml_args[0]
+                xml_args[0] = "__replace_with_#{triple.object.object_id}__"
+              end
+              xml.tag!(triple.predicate.to_qname(uri_bindings), *xml_args)
+            end
+          end
+        end
+      end
+
+      # Perform literal substitutions
+      replace_text.each_pair do |match, value|
+        rdfxml.sub!(match, value)
+      end
+      
+      rdfxml
+    end
+    
+    ## 
+    # Bind a namespace to the graph.
+    #
+    # ==== Example
+    #   g = Graph.new; g.bind(Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")) # => binds the Foaf namespace to g
+    #
+    # @param [String] namespace:: the namespace to bind
+    # @return [Namespace]:: The newly bound or pre-existing namespace.
+    def bind(namespace)
+      raise GraphException, "Can't bind #{namespace.inspect} as namespace" unless namespace.is_a?(Namespace)
+      @store.bind(namespace)
+    end
+
+    # Namespace for prefix
+    def namespace(prefix); @store.namespace(prefix); end
+
+    # Prefix for namespace
+    def prefix(namespace); @store.prefix(namespace); end
+    
+    # Number of Triples in the graph
+    def size; @store.size(self); end
+
+    # List of distinct subjects in graph
+    def subjects; @store.subjects(self); end
+    
+    # List of distinct predicates in graph
+    def predicates; @store.predicates(self); end
+    
+    # List of distinct objects in graph
+    def objects; @store.objects(self); end
+    
+    # Indexed statement in serialized graph triples. Equivalent to graph.triples[item] 
+    def [] (item); @store.item(item, self); end
+
+    # Adds a triple to a graph directly from the intended subject, predicate, and object.
+    #
+    # ==== Example
+    #   g = Graph.new; g.add_triple(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new) # => results in the triple being added to g; returns an array of g's triples
+    #
+    # @param [URIRef, BNode] subject:: the subject of the triple
+    # @param [URIRef] predicate:: the predicate of the triple
+    # @param [URIRef, BNode, Literal] object:: the object of the triple
+    # @return [Graph]:: Returns the graph
+    # @raise [Error]:: Checks parameter types and raises if they are incorrect.
+    def add_triple(subject, predicate, object)
+      self.add(Triple.new(subject, predicate, object))
+      self
+    end
+
+    ## 
+    # Adds an more extant triples to a graph. Delegates to Store.
+    #
+    # ==== Example
+    #   g = Graph.new;
+    #   t = Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new);
+    #   g << t
+    #
+    # @param [Triple] t:: the triple to be added to the graph
+    # @return [Graph]:: Returns the graph
+    def << (triple)
+      @store.add(triple, self)
+      self
+    end
+    
+    ## 
+    # Adds one or more extant triples to a graph. Delegates to Store.
+    #
+    # ==== Example
+    #   g = Graph.new;
+    #   t1 = Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new);
+    #   t2 = Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new);
+    #   g.add(t1, t2, ...)
+    #
+    # @param [Triple] triples:: one or more triples. Last element may be a hash for options
+    # <em>options[:context]</em>:: Graph context in which to deposit triples, defaults to default_context or self
+    # @return [Graph]:: Returns the graph
+    def add(*triples)
+      options = triples.last.is_a?(Hash) ? triples.pop : {}
+      ctx = options[:context] || @default_context || self
+      triples.each {|t| @store.add(t, ctx)}
+      self
+    end
+    
+    # Remove a triple from the graph. Delegates to store.
+    # Nil matches all triples and thus empties the graph
+    def remove(triple); @store.remove(triple, self); end
+    
+    # Triples from graph, optionally matching subject, predicate, or object.
+    # Delegates to Store#triples.
+    #
+    # @param [Triple, nil] triple:: Triple to match, may be a patern triple or nil
+    # @return [Array]:: List of matched triples
+    def triples(triple = Triple.new(nil, nil, nil), &block) # :yields: triple, context
+      @store.triples(triple, self, &block) || []
+    end
+    alias_method :find, :triples
+
+    # Detect the presence of a BNode in the graph, either as a subject or an object
+    #
+    # @param [BNode] bn:: BNode to find
+    #
+    def has_bnode_identifier?(bn)
+      triples do |triple, context|
+        return true if triple.subject.eql?(bn) || triple.object.eql?(bn)
+      end
+      false
+    end
+
+    # Check to see if this graph contains the specified triple
+    def contains?(triple)
+      @store.contains?(triple, self)
+    end
+    
+    # Get all BNodes with usage count used within graph
+    def bnodes
+      @store.bnodes(self)
+    end
+    
+    # Get list of subjects having rdf:type == object
+    #
+    # @param [Resource, Regexp, String] object:: Type resource
+    def get_by_type(object)
+      triples(Triple.new(nil, RDF_TYPE, object)).map {|t, ctx| t.subject}
+    end
+    
+    # Merge a graph into this graph
+    def merge!(graph)
+      raise GraphException.new("merge without a graph") unless graph.is_a?(Graph)
+      
+      # Map BNodes from source Graph to new BNodes
+      bn = graph.bnodes
+      bn.keys.each {|k| bn[k] = BNode.new}
+      
+      graph.triples do |triple, context|
+        # If triple contains bnodes, remap to new values
+        if triple.subject.is_a?(BNode) || triple.object.is_a?(BNode)
+          triple = triple.clone
+          triple.subject = bn[triple.subject] if triple.subject.is_a?(BNode)
+          triple.object = bn[triple.object] if triple.object.is_a?(BNode)
+        end
+        self << triple
+      end
+    end
+    
+    # Two graphs are equal if each is an instance of the other, considering BNode equivalence.
+    # This may be done by creating a new graph an substituting each permutation of BNode identifiers
+    # from self to other until every permutation is exhausted, or a textual equivalence is found
+    # after sorting each graph.
+    #
+    # We just follow Python RDFlib's lead and do a simple comparison
+    def eql? (other)
+      #puts "eql? size #{self.size} vs #{other.size}"
+      return false if !other.is_a?(Graph) || self.size != other.size
+      bn_self = bnodes.values.sort
+      bn_other = other.bnodes.values.sort
+      #puts "eql? bnodes '#{bn_self.to_sentence}' vs '#{bn_other.to_sentence}'"
+      return false unless bn_self == bn_other
+      
+      # Check each triple to see if it's contained in the other graph
+      triples do |t, ctx|
+        next if t.subject.is_a?(BNode) || t.object.is_a?(BNode)
+        #puts "eql? contains '#{t.to_ntriples}'"
+        return false unless other.contains?(t)
+      end
+      true
+    end
+
+    alias_method :==, :eql?
+  end
+  
+  # Parse source into Graph.
+  #
+  # Merges results into a common Graph
+  #
+  # @param  [IO, String] stream:: the RDF IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
+  # @param [String] uri:: the URI of the document
+  # @param [Hash] options:: Options from
+  # <em>options[:debug]</em>:: Array to place debug messages
+  # <em>options[:type]</em>:: One of _rdfxml_, _html_, or _n3_
+  # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
+  # @return [Graph]:: Returns the graph containing parsed triples
+  def parse(stream, uri, options = {}, &block) # :yields: triple
+    Parser.parse(stream, uri, options.merge(:graph => self), &block)
+  end
+end

data/lib/reddy/literal.rb

@@ -0,0 +1,340 @@
+module Reddy
+  # An RDF Literal, with value, encoding and language elements.
+  class Literal
+    class Encoding
+      attr_reader :value
+
+      # New Encoding for a literal, typed, untyped or XMLLiteral
+      def initialize(value)
+        @value = URIRef.new(value.to_s) if value
+      end
+
+      # Shortcut for <tt>Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#int")</tt>
+      def self.integer
+        @integer ||= coerce "http://www.w3.org/2001/XMLSchema#int"
+      end
+
+      # Shortcut for <tt>Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#float")</tt>
+      def self.float
+        @float ||= coerce "http://www.w3.org/2001/XMLSchema#float"
+      end
+
+      # Shortcut for <tt>Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#string")</tt>
+      def self.string
+        @string ||= coerce "http://www.w3.org/2001/XMLSchema#string"
+      end
+
+      # Create from URI, empty or nil string
+      def self.coerce(string_or_nil)
+        if string_or_nil.nil? || string_or_nil == ''
+          the_null_encoding
+        elsif xmlliteral == string_or_nil.to_s
+          xmlliteral
+        else
+          new string_or_nil
+        end
+      end
+      
+      def inspect
+        to_s()
+      end
+      
+      def self.the_null_encoding
+        @the_null_encoding ||= Null.new(nil)
+      end
+
+      def self.xmlliteral
+        @xmlliteral ||= XMLLiteral.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
+      end
+
+      # Compare against another encoding, or a URI of a literal type
+      def ==(other)
+        case other
+        when String
+          other == @value.to_s
+        when self.class
+          other.value.to_s == @value.to_s
+        else
+          false
+        end
+      end
+
+      # Generate hash of type to determine uniqueness
+      def hash
+        @value.hash
+      end
+
+      def to_s
+        @value.to_s
+      end
+
+      # Serialize literal, adding datatype and language elements, if present.
+      # XMLLiteral and String values are RDF-escaped.
+      def format_as_n3(content, lang)
+        quoted_content = "\"#{content.to_s.rdf_escape}\"^^<#{value}>"
+      end
+
+      # Serialize literal to TriX
+      def format_as_trix(content, lang)
+        lang = " xml:lang=\"#{lang}\"" if lang
+        "<typedLiteral datatype=\"#{@value}\"#{lang}>#{content}</typedLiteral>"
+      end
+      
+      # Return content and hash appropriate for encoding in XML
+      #
+      # ==== Example
+      #  Encoding.string.xml_args("foo", "en-US") => ["foo", {"rdf:datatype" => "xs:string"}]
+      def xml_args(content, lang)
+        hash = {"rdf:datatype" => @value.to_s}
+        [content.to_s, hash]
+      end
+      
+      # Compare literal contents, ignore language
+      def compare_contents(a, b, same_lang)
+        a == b
+      end
+      
+      # Encode literal contents
+      def encode_contents(contents, options)
+        contents
+      end
+    end
+    
+    # The null encoding
+    class Null < Encoding
+      def to_s
+        ''
+      end
+
+      # Format content for n3/N-Triples. Quote an RDF-escape and include language
+      def format_as_n3(content, lang)
+        "\"#{content.to_s.rdf_escape}\"" + (lang ? "@#{lang}" : "")
+      end
+
+      # Format content for TriX
+      def format_as_trix(content, lang)
+        if lang
+          "<plainLiteral xml:lang=\"#{lang}\"\>#{content}</plainLiteral>"
+        else
+          "<plainLiteral>#{content}</plainLiteral>"
+        end
+      end
+
+      # Return content and hash appropriate for encoding in XML
+      #
+      # ==== Example
+      #  Encoding.the_null_encoding.xml_args("foo", "en-US") => ["foo", {"xml:lang" => "en-US"}]
+      def xml_args(content, lang)
+        hash = {}
+        hash["xml:lang"] = lang if lang
+        [content, hash]
+      end
+      
+      # Compare literal contents, requiring languages to match
+      def compare_contents(a, b, same_lang)
+        a == b && same_lang
+      end
+      
+      def inspect
+        "<Literal::Encoding::Null>"
+      end
+    end
+
+    class XMLLiteral < Encoding
+      # Compare XMLLiterals
+      #
+      # Nokogiri doesn't do a deep compare of elements
+      #
+      # Convert node-sets to hash using ActiveSupport::XmlMini and compare hashes.
+      def compare_contents(a, b, same_lang)
+        begin
+          a_hash = ActiveSupport::XmlMini.parse("<foo>#{a}</foo>")
+          b_hash = ActiveSupport::XmlMini.parse("<foo>#{b}</foo>")
+          a_hash == b_hash
+        rescue
+          super
+        end
+      end
+      
+      def format_as_n3(content, lang)
+        "\"#{content.to_s.rdf_escape}\"^^<#{value}>"
+      end
+
+      def format_as_trix(content, lang)
+        "<typedLiteral datatype=\"#{@value}\">#{content}</typedLiteral>"
+      end
+
+      def xml_args(content, lang)
+        hash = {"rdf:parseType" => "Literal"}
+        [content, hash]
+      end
+
+      # Map namespaces from context to each top-level element found within node-set
+      def encode_contents(contents, options)
+        #puts "encode_contents: '#{contents}'"
+        if contents.is_a?(String)
+          ns_hash = options[:namespaces].values.inject({}) {|h, ns| h.merge(ns.xmlns_hash)}
+          ns_strs = []
+          ns_hash.each_pair {|a, u| ns_strs << "#{a}=\"#{u}\""}
+
+          # Add inherited namespaces to created root element so that they're inherited to sub-elements
+          contents = Nokogiri::XML::Document.parse("<foo #{ns_strs.join(" ")}>#{contents}</foo>").root.children
+        end
+
+        # Add already mapped namespaces and language
+        @contents = contents.map do |c|
+          c = Nokogiri::XML.parse(c.copy(true).to_s) if c.is_a?(LibXML::XML::Node)
+          if c.is_a?(Nokogiri::XML::Element)
+            # Gather namespaces from self and decendant nodes
+            c.traverse do |n|
+              ns = n.namespace
+              next unless ns
+              prefix = ns.prefix ? "xmlns:#{ns.prefix}" : "xmlns"
+              c[prefix] = ns.href unless c.namespaces[prefix]
+            end
+            
+            # Add lanuage
+            if options[:language] && c["lang"].to_s.empty?
+              c["xml:lang"] = options[:language]
+            end
+          end
+          c.to_html
+        end.join("")
+      end
+    end
+
+    class Language
+      attr_accessor :value
+      def initialize(string)
+        @value = string.to_s.downcase
+      end
+
+      def clean(string)
+        case string
+        when "eng"; "en"
+        else string
+        end
+      end
+
+      def == (other)
+        case other
+        when String
+          other == @value
+        when self.class
+          other.value == @value
+        end
+      end
+      
+      def to_s; @value; end
+    end
+
+    attr_accessor :contents, :encoding, :lang
+    
+    # Create a new Literal. Optinally pass a namespaces hash
+    # for use in applying to rdf::XMLLiteral values.
+    def initialize(contents, encoding, options = {})
+      unless encoding.is_a?(Encoding)
+        raise TypeError, "#{encoding.inspect} should be an instance of Encoding"
+      end
+      @encoding = encoding
+      lang = options[:language]
+      @lang = Language.new(lang) if lang
+      options = {:namespaces => {}}.merge(options)
+
+      @contents = @encoding.encode_contents(contents, options)
+    end
+    
+    # Create literal from a string that is already N3 encoded.
+    def self.n3_encoded(contents, language, encoding = nil)
+      encoding = encoding.nil? ? Encoding.the_null_encoding : Encoding.coerce(encoding)
+      options = {}
+      options[:language] = language if language
+      #puts "encoded: #{contents.dump}"
+      contents = contents.rdf_unescape
+      #puts "unencoded: #{contents.dump}"
+      new(contents, encoding, options)
+    end
+    
+    # Create an un-typed literal with a language
+    def self.untyped(contents, language = nil)
+      options = {}
+      options[:language] = language if language
+      new(contents, Encoding.the_null_encoding, options)
+    end
+    
+    # Create a typed literal
+    # Options include:
+    # _namespaces_:: A hash of namespace entries (for XMLLiteral)
+    def self.typed(contents, encoding, options = {})
+      encoding = Encoding.coerce(encoding)
+      new(contents, encoding, options)
+    end
+    
+    # Create a literal appropriate for type of object by datatype introspection
+    def self.build_from(object)
+      new(object.to_s, infer_encoding_for(object))
+    end
+
+    # Infer the proper XML datatype for the given object
+    def self.infer_encoding_for(object)
+      case object
+      when Integer  then Encoding.new("http://www.w3.org/2001/XMLSchema#int")
+      when Float    then Encoding.new("http://www.w3.org/2001/XMLSchema#float")
+      when Time     then Encoding.new("http://www.w3.org/2001/XMLSchema#time")
+      when DateTime then Encoding.new("http://www.w3.org/2001/XMLSchema#dateTime")
+      when Date     then Encoding.new("http://www.w3.org/2001/XMLSchema#date")
+      else               Encoding.new("http://www.w3.org/2001/XMLSchema#string")
+      end
+    end
+
+   class << self
+      protected :new
+    end
+
+    # Compare literal with another literal or a string.
+    # If a string is passed, only contents must match.
+    # Otherwise, compare encoding types, contents and languages.
+    def ==(other)
+      case other
+      when String     then other == self.contents
+      when self.class
+        other.encoding == @encoding &&
+        @encoding.compare_contents(self.contents, other.contents, other.lang == @lang)
+      else false
+      end
+    end
+    
+    def hash
+      [@contents, @encoding, @lang].hash
+    end
+
+    # Output literal in N3 format
+    def to_n3
+      encoding.format_as_n3(self.contents, @lang)
+    end
+    alias_method :to_ntriples, :to_n3
+
+    # Output literal in TriX format
+    def to_trix
+      encoding.format_as_trix(@contents, @lang)
+    end
+    
+    # Return content and hash appropriate for encoding in XML
+    #
+    # ==== Example
+    #  Encoding.the_null_encoding.xml_args("foo", "en-US") => ["foo", {"xml:lang" => "en-US"}]
+    def xml_args
+      encoding.xml_args( @contents, @lang)
+    end
+
+    # Is this an XMLLiteral?
+    def xmlliteral?
+      encoding.is_a?(XMLLiteral)
+    end
+    
+    # Output literal contents as a string
+    def to_s
+      self.contents.to_s
+    end
+  end
+end