Source File
	rdfxml.go

Belonging Package
	github.com/freeeve/libcodex/rdf

package rdf

import (
	"bytes"
	"encoding/xml"
	"errors"
	"io"
	"strconv"
	"strings"
)

const xmlNS = "http://www.w3.org/XML/1998/namespace"

// errTooDeep aborts an RDF/XML parse whose element nesting would otherwise
// recurse deep enough to overflow the goroutine stack.
var errTooDeep = errors.New("rdf: RDF/XML nesting too deep")

// maxLiteralBytes caps the character data accumulated into a single RDF/XML
// literal. Without it, a streamed dump carrying one multi-gigabyte literal would
// buffer wholly in memory, contradicting the streaming decoder's constant-memory
// guarantee. It matches the Turtle streaming statement cap; no real literal is
// anywhere near this large.
const maxLiteralBytes = 1 << 24 // 16 MiB

// errLiteralTooLarge aborts a parse whose single literal exceeds maxLiteralBytes.
var errLiteralTooLarge = errors.New("rdf: RDF/XML literal too large")

// ParseRDFXML parses an RDF/XML document into a Graph. It supports the striped
// syntax real bibliographic RDF uses: typed node elements and rdf:Description,
// rdf:about / rdf:nodeID / rdf:ID subjects, rdf:resource and rdf:nodeID object
// references, nested node elements, literal property values with rdf:datatype and
// xml:lang, property attributes, and rdf:parseType="Resource". It does not handle
// RDF containers, reification, or rdf:parseType="Literal"/"Collection".
func ParseRDFXML(data []byte) (*Graph, error) {
	g := &Graph{}
	p := &xmlParser{dec: xml.NewDecoder(bytes.NewReader(data)), emit: g.Add}
	if err := p.run(); err != nil {
		return g, err
	}
	return g, nil
}

// run drives the token loop, parsing each top-level node element. It is shared by
// the whole-document parser and the streaming decoder.
func (p *xmlParser) run() error {
	for {
		tok, err := p.dec.Token()
		if err == io.EOF {
			return nil
		}
		if err != nil {
			return err
		}
		se, ok := tok.(xml.StartElement)
		if !ok {
			continue
		}
		// The document root is rdf:RDF (its children are node elements) or, when a
		// single node is the root, the node element itself.
		if se.Name.Space == NS && se.Name.Local == "RDF" {
			if err := p.parseNodeChildren(se); err != nil {
				return err
			}
			continue
		}
		if _, err := p.parseNode(se); err != nil {
			return err
		}
	}
}

type xmlParser struct {
	dec    *xml.Decoder
	emit   func(s, pr, o Term) // sink: Graph.Add for ParseRDFXML, channel for streaming
	blanks int
	depth  int // current node-element nesting, bounded by maxParseDepth
}

func (p *xmlParser) fresh() Term {
	p.blanks++
	return NewBlank("b" + strconv.Itoa(p.blanks))
}

// docBlank wraps a document-supplied rdf:nodeID as a blank node, prefixing it so
// it can never collide with a generated ("b"+n) label -- a document nodeID of
// "b1" would otherwise merge with the first anonymous node.
func docBlank(nodeID string) Term {
	return NewBlank("u" + nodeID)
}

func iriOf(n xml.Name) string { return n.Space + n.Local }

func attr(se xml.StartElement, space, local string) (string, bool) {
	for _, a := range se.Attr {
		if a.Name.Space == space && a.Name.Local == local {
			return a.Value, true
		}
	}
	return "", false
}

// parseNode parses a node element (already read as a StartElement), emits its
// type and property-attribute triples, recurses into property children, and
// returns the node's subject term. It consumes the matching EndElement.
func (p *xmlParser) parseNode(se xml.StartElement) (Term, error) {
	if p.depth >= maxParseDepth {
		return Term{}, errTooDeep
	}
	p.depth++
	defer func() { p.depth-- }()
	subject := p.subjectOf(se)
	if !(se.Name.Space == NS && se.Name.Local == "Description") {
		p.emit(subject, NewIRI(TypeIRI), NewIRI(iriOf(se.Name)))
	}
	// Property attributes: rdf attributes other than the identity ones become
	// literal-valued statements (rdf:type becomes a type IRI).
	for _, a := range se.Attr {
		if isStructuralAttr(a) {
			continue
		}
		if a.Name.Space == NS && a.Name.Local == "type" {
			p.emit(subject, NewIRI(TypeIRI), NewIRI(a.Value))
			continue
		}
		p.emit(subject, NewIRI(iriOf(a.Name)), NewLiteral(a.Value, "", ""))
	}
	if err := p.parseProperties(se, subject); err != nil {
		return subject, err
	}
	return subject, nil
}

// parseNodeChildren reads the child node elements of a container (rdf:RDF) until
// its EndElement.
func (p *xmlParser) parseNodeChildren(container xml.StartElement) error {
	for {
		tok, err := p.dec.Token()
		if err != nil {
			return err
		}
		switch t := tok.(type) {
		case xml.StartElement:
			if _, err := p.parseNode(t); err != nil {
				return err
			}
		case xml.EndElement:
			if t.Name == container.Name {
				return nil
			}
		}
	}
}

// parseProperties reads the property-element children of a node until its
// EndElement.
func (p *xmlParser) parseProperties(node xml.StartElement, subject Term) error {
	for {
		tok, err := p.dec.Token()
		if err != nil {
			return err
		}
		switch t := tok.(type) {
		case xml.StartElement:
			if err := p.parseProperty(subject, t); err != nil {
				return err
			}
		case xml.EndElement:
			if t.Name == node.Name {
				return nil
			}
		}
	}
}

// parseProperty parses one property element and emits the (subject, predicate,
// object) triple, consuming the property's content and EndElement.
func (p *xmlParser) parseProperty(subject Term, se xml.StartElement) error {
	pred := NewIRI(iriOf(se.Name))

	if res, ok := attr(se, NS, "resource"); ok {
		p.emit(subject, pred, NewIRI(res))
		return p.skipTo(se.Name)
	}
	if nid, ok := attr(se, NS, "nodeID"); ok {
		p.emit(subject, pred, docBlank(nid))
		return p.skipTo(se.Name)
	}
	if pt, ok := attr(se, NS, "parseType"); ok && pt == "Resource" {
		obj := p.fresh()
		p.emit(subject, pred, obj)
		return p.parseProperties(se, obj)
	}
	datatype, _ := attr(se, NS, "datatype")
	lang, _ := attr(se, xmlNS, "lang")

	// Look at the content: a nested node element, or literal text.
	var text strings.Builder
	for {
		tok, err := p.dec.Token()
		if err != nil {
			return err
		}
		switch t := tok.(type) {
		case xml.StartElement:
			child, err := p.parseNode(t)
			if err != nil {
				return err
			}
			p.emit(subject, pred, child)
			return p.skipTo(se.Name) // consume any trailing whitespace + EndElement
		case xml.CharData:
			if text.Len()+len(t) > maxLiteralBytes {
				return errLiteralTooLarge
			}
			text.Write(t)
		case xml.EndElement:
			if t.Name == se.Name {
				p.emit(subject, pred, NewLiteral(text.String(), lang, datatype))
				return nil
			}
		}
	}
}

// skipTo consumes tokens until the EndElement matching name.
func (p *xmlParser) skipTo(name xml.Name) error {
	depth := 0
	for {
		tok, err := p.dec.Token()
		if err != nil {
			return err
		}
		switch t := tok.(type) {
		case xml.StartElement:
			depth++
		case xml.EndElement:
			if depth == 0 && t.Name == name {
				return nil
			}
			depth--
		}
	}
}

// subjectOf returns a node element's subject from rdf:about / rdf:nodeID / rdf:ID,
// or a fresh blank node.
func (p *xmlParser) subjectOf(se xml.StartElement) Term {
	if v, ok := attr(se, NS, "about"); ok {
		return NewIRI(v)
	}
	if v, ok := attr(se, NS, "nodeID"); ok {
		return docBlank(v)
	}
	if v, ok := attr(se, NS, "ID"); ok {
		return NewIRI("#" + v)
	}
	return p.fresh()
}

// isStructuralAttr reports whether an attribute carries node identity or XML
// machinery rather than a property statement.
func isStructuralAttr(a xml.Attr) bool {
	if a.Name.Space == "xmlns" || a.Name.Local == "xmlns" || a.Name.Space == xmlNS {
		return true
	}
	if a.Name.Space == NS {
		switch a.Name.Local {
		case "about", "nodeID", "ID", "resource", "datatype", "parseType":
			return true
		}
	}
	return false
}

The pages are generated with Golds v0.8.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.