Class: RdfContext::XmlSerializer

Inherits:

RecursiveSerializer

Object
AbstractSerializer
RecursiveSerializer
RdfContext::XmlSerializer

show all

Defined in:: lib/rdf_context/serializer/xml_serializer.rb

Overview

Serialize RDF graphs in NTriples format

Constant Summary collapse

VALID_ATTRIBUTES =

[:none, :untyped, :typed]

Constants inherited from RecursiveSerializer

RecursiveSerializer::INDENT_STRING, RecursiveSerializer::MAX_DEPTH

Instance Attribute Summary

Attributes inherited from AbstractSerializer

#base, #graph

Instance Method Summary collapse

#initialize(graph) ⇒ XmlSerializer constructor

New XmlSerializer.
#predicate(prop, object, node, is_unique) ⇒ Object protected

Output a predicate into the specified node.
#preprocess_triple(triple) ⇒ Object protected
#serialize(stream, options = {})

Serialize the graph.
#subject(subject, parent_node) ⇒ Object protected

Methods inherited from RecursiveSerializer

#add_namespace, #get_qname, #indent, #is_done?, #order_subjects, #predicate_order, #preprocess, #ref_count, #reset, #sort_properties, #subject_done, #top_classes, #uri_binding, #write

Methods inherited from AbstractSerializer

#relativize

Constructor Details

#initialize(graph) ⇒ `XmlSerializer`

New XmlSerializer

Parameters:

graph (Graph)

# File 'lib/rdf_context/serializer/xml_serializer.rb', line 9

def initialize(graph)
  super
  @force_RDF_about = {}
end

Instance Method Details

#predicate(prop, object, node, is_unique) ⇒ `Object` (protected)

Output a predicate into the specified node.

If is_unique is true, this predicate may be able to be serialized as an attribute

Raises:

(RdfException)

# File 'lib/rdf_context/serializer/xml_serializer.rb', line 145

def predicate(prop, object, node, is_unique)
  qname = prop.to_qname(uri_binding)
  raise RdfException, "No qname generated for <#{prop}>" unless qname

  # See if we can serialize as attribute.
  # * untyped attributes that aren't duplicated where xml:lang == @lang
  # * typed attributes that aren't duplicated if @dt_as_attr is true
  # * rdf:type
  as_attr = false
  as_attr ||= true if [:untyped, :typed].include?(@attributes) && prop == RDF_TYPE

  # Untyped attribute with no lang, or whos lang is the same as the default and RDF_TYPE
  as_attr ||= true if [:untyped, :typed].include?(@attributes) &&
    (object.is_a?(Literal) && object.untyped? && (object.lang.nil? || object.lang == @lang))
  
  as_attr ||= true if [:typed].include?(@attributes) && object.is_a?(Literal) && object.typed?

  as_attr = false unless is_unique
  
  # Can't do as an attr if the qname has no prefix and there is no prefixed version
  if @default_ns && prop.namespace.uri == @default_ns.uri
    if as_attr
      if @prefixed_default_ns
        qname = "#{@prefixed_default_ns.prefix}:#{prop.short_name}"
      else
        as_attr = false
      end
    else
      qname = prop.short_name
    end
  end

  puts "predicate: #{qname}, as_attr: #{as_attr}, object: #{object.inspect}, done: #{is_done?(object)}, sub: #{@subjects.include?(object)}" if ::RdfContext::debug?
  qname = "rdf:li" if qname.match(/rdf:_\d+/)
  pred_node = Nokogiri::XML::Element.new(qname, node.document)
  
  if object.is_a?(Literal) || is_done?(object) || !@subjects.include?(object)
    # Literals or references to objects that aren't subjects, or that have already been serialized
    
    args = object.xml_args
    puts "predicate: args=#{args.inspect}" if ::RdfContext::debug?
    attrs = args.pop
    
    if as_attr
      # Serialize as attribute
      pred_node.unlink
      pred_node = nil
      node[qname] = object.is_a?(URIRef) ? relativize(object) : object.to_s
    else
      # Serialize as element
      attrs.each_pair do |a, av|
        next if a == "xml:lang" && av == @lang # Lang already specified, don't repeat
        av = relativize(object) if a == "#{RDF_NS.prefix}:resource"
        puts "  elt attr #{a}=#{av}" if ::RdfContext::debug?
        pred_node[a] = av.to_s
      end
      puts "  elt #{'xmllit ' if object.is_a?(Literal) && object.xmlliteral?}content=#{args.first}" if ::RdfContext::debug? && !args.empty?
      if object.is_a?(Literal) && object.xmlliteral?
        pred_node.add_child(Nokogiri::XML::CharacterData.new(args.first, node.document))
      elsif args.first
        pred_node.content = args.first unless args.empty?
      end
    end
  else
    # Check to see if it can be serialized as a collection
    col = @graph.seq(object)
    conformant_list = col.all? {|item| !item.is_a?(Literal)}
    o_props = @graph.properties(object)
    if conformant_list && o_props[RDF_NS.first.to_s]
      # Serialize list as parseType="Collection"
      pred_node["rdf:parseType"] = "Collection"
      col.each do |item|
        # Mark the BNode subject of each item as being complete, so that it is not serialized
        @graph.triples(Triple.new(nil, RDF_NS.first, item)) do |triple, ctx|
          subject_done(triple.subject)
        end
        @force_RDF_about[item] = true
        subject(item, pred_node)
      end
    else
      if @depth < @max_depth
        @depth += 1
        subject(object, pred_node)
        @depth -= 1
      elsif object.is_a?(BNode)
        pred_node["rdf:nodeID"] = object.identifier
      else
        pred_node["rdf:resource"] = relativize(object)
      end
    end
  end
  node.add_child(pred_node) if pred_node
end

#preprocess_triple(triple) ⇒ `Object` (protected)

# File 'lib/rdf_context/serializer/xml_serializer.rb', line 239

def preprocess_triple(triple)
  super
  
  # Pre-fetch qnames, to fill namespaces
  get_qname(triple.predicate)
  get_qname(triple.object) if triple.predicate == RDF_TYPE

  @references[triple.predicate] = ref_count(triple.predicate) + 1
end

#serialize(stream, options = {})

This method returns an undefined value.

Serialize the graph

Examples:

attributes == :none
serialize(io, :attributes => none)