This document is a specification for a vocabulary to represent content in the Resource Description Framework (RDF). This vocabulary is intended to provide a flexible framework within different usage scenarios to semantically represent any type of content, be it on the Web or in local storage media. For example, it can be used by web quality assurance tools such as web accessibility evaluation tools to record a representation of the assessed web content, including text, images, or other types of formats. In many cases, it can be used together with HTTP Vocabulary in RDF 1.0, which allows quality assurance tools to record the HTTP headers that have been exchanged between a client and a server. This is particularly useful for quality assurance testing, conformance claims, and reporting languages like the W3C Evaluation And Report Language (EARL).
Status of this Document
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at https://www.w3.org/TR/.
Representing Content in RDF 1.0 is a supporting document for the Evaluation and Report Language (EARL) 1.0 Schema but can be used in other contexts too. It is considered to be complete and mature but at this time there are not sufficient implementations to finalize this work.
If you wish to make comments regarding this Representing Content in RDF 1.0 document, please send them to [email protected] (publicly visible mailing list archive).
Publication as a Working Group Note does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document is the specification for a vocabulary
to represent Content in the Resource Description Framework
(RDF). There is a wide variety of scenarios (see section
below) where a representation of any type of content, either on the Web or in
any local storage media, is necessary. This specification provides an
RDF application that allows to present semantically such
content. The vocabulary is built in a flexible manner, thus there are no
limitations known at the time of writing this specification. It also provides
opportunities for extensions to match particular needs of its users.
This document assumes the following background knowledge:
Basic knowledge of the Extensible Markup Language
(XML) [XML] and its associated
technologies.
Basic knowledge about the Semantic Web and RDF. For
references, consult [RDF], [RDF-PRIMER] and [RDFS].
Although the concepts of the Semantic Web are simple, their
abstraction with RDF is known to bring difficulties to
beginners. It is recommended to read carefully the aforementioned references
and other tutorials found on the Web. It must be also borne in mind that
RDF is primarily targeted to be machine processable, and
therefore, some of its expressions are not very intuitive for developers used
to work with XML only. The examples will be serialized
using the abbreviated RDF/XML
notation.
The keywords must,
required, recommended,
should, may, and optional
are used in accordance with [RFC2119].
For
limitations of this vocabulary, see section 5.
Table 1 presents the namespaces typically used by
this vocabulary. The core namespace has the URI
http://www.w3.org/2011/content# and the prefix cnt.
The prefix notation presents the typical conventions used in the Web and in
this document to denote a given namespace, and can be freely modified.
As
stated earlier, this framework is designed in an open way to facilitate
different implementation scenarios. The origin of the application comes from
vocabularies describing testing scenarios like the Evaluation And Report
Language (EARL) [EARL]. Typical
applications could be:
Applications dealing with retrieval, editing and storage of content.
For example, an archiving application could store in a database annotated
media content that includes a serialization of the media files with this
vocabulary.
Applications dealing with the exchange of text documents and other
types of media, like Web Services. For example, an AJAX application could
exchange document fragments and images with a Web server to react to
different user actions.
Applications dealing with the testing and/or repair of content. For
example, an accessibility testing tool could store together with the
results of a compliance test, the tested Web resources to ensure that the
correct version of the tested subject is available to the developers.
This section presents a description of the classes of this
RDF vocabulary. We
present every class together with its subclasses. We also include whenever
relevant short snippets and examples.
The cnt:Content
class is an overarching class for any content that could be found on the Web,
in an Intranet or in local storage media, for example. It is recommended
always to use one of its subclasses. There is no restriction within the
vocabulary scope on what can be represented with this class: textual content,
XML files, binary files
(e.g., images or movies), etc.
In order
to connect resources with different cnt:Content sub-types with
each other, use the dct:hasFormat and dct:isFormatOf
properties to point to each other. E.g. if there is an
XML resource transmitted via HTTP, the original version would
be a cnt:ContentAsBase64 resource. But
cnt:ContentAsText and cnt:ContentAsXML resource
could also be created and point to the cnt:ContentAsBase64
resource.
The cnt:ContentAsBase64 class
is a subclass of the cnt:Content
class for Base64 encoded binary content (as defined by [RFC2045]) and can be used for any type of content,
although its more typical use case is for binary files.
Example 2.2: This example displays the representation of
the W3C logo as a
ContentAsBase64 resource. (Note: due to its length, the encoded
string has been chunked until {...}.)
A document type declaration. This class is normally used in conjunction
with the ContentAsXML class,
when the corresponding XML resource contains a document
type declaration. The relation is expressed via the dtDecl
property.
When used with ContentAsBase64: If the byte sequence was
created from a given character sequence this property can be used to store
the character encoding that was applied to create the byte sequence.
When used with ContentAsText: If the character sequence
was created from a given byte sequence this property can be used to store
the character encoding that was applied to create the character
sequence.
When used with ContentAsXML: If the parser's input
character stream was created from a given byte stream this property can be
used to store the character encoding that was applied to create the
character stream. Note: This is the used
character encoding, not the one declared in an XML declaration.
The part of the XML information items
(whitespace, comments and processing instructions) following the
XML declaration and preceding the document type declaration
if there is one.
We have identified some situations to make clear when to
create which type of content resources. The following are only recommendations
and are non-normative:
This includes images,
multimedia, or other non-text resources. The byte sequence is recorded in
Base64 format and represented as a literal using the cnt:bytes
property of the cnt:ContentAsBase64. Non-text content should not
be represented using cnt:ContentAsText.
This includes
HTML, CSS, client-side script, or other
text-based resources. Given the byte sequence of text content
(byteSeq) received from a Web server and an appropriate character
encoding (ce). byteSeq is recorded in Base64 format and
represented as a literal using the cnt:bytes property of the
cnt:ContentAsBase64.
After transforming the
byteSeq to a character sequence charSeq using character
encoding ce, charSeq is represented as a literal using
the cnt:chars property of the cnt:ContentAsText and
ce as a literal usind the cnt:characterEncoding
property.
Given the byte sequence of text content
(byteSeq) received from a Web server and an inappropriate character
encoding (ce). byteSeq is recorded in Base64 format and
represented as a literal using the cnt:bytes property of the
cnt:ContentAsBase64. Because transforming byteSeq to a
character sequence charSeq using character encoding ce
fails, no cnt:ContentAsText resource can be created.
Given the
character sequence of text content (charSeq) created in memory and
an appropriate character encoding (ce). A
cnt:ContentAsText resource may be created with a
cnt:chars property with an object literal created from
charSeq. After transforming charSeq to byte sequence
byteSeq using character encoding ce, a
cnt:ContentAsBase64 resource may be created with
cnt:bytes property with an object literal byteSeq and
cnt:characterEncoding property with an object literal
ce.
Given the byte
sequence of wellformed XML content (byteSeq)
received from a Web server and an appropriate character encoding
(ce). cnt:ContentAsBase64 and
cnt:ContentAsText resources may be created as in situation B.
Additionally, an cnt:ContentAsXML resource may be created.
Given a
DOM Document in memory, originally created by parsing some
XML source, but afterwards changed by
DOM operations. A cnt:XMLDecl resource may be
created from the information in the Document node itself (version,
declaredEncoding and standalone), and a cnt:DoctypeDecl resource
from the information in the DocumentType node. A cnt:ContentAsXML
resource may be created after serializing the relevant child nodes of the
Document node to create object literals for cnt:leadingMisc
(serialize Comment and ProcessingInstruction nodes preceding a DocumentType
node) and cnt:rest (serialize nodes following a DocumentType
node). See the Mapping between the Document Object
Model (DOM) and Content-in-RDF properties.
The vocabulary provides a framework that allows the
representation of any type of content. Of course, there are many possibilities
for extensions that will allow the inclusion of additional metadata, like,
e.g., that included in some multimedia formats. Typical scenarios
for extensions could be:
Classes to specify the metadata of multimedia content like audio or
image files.
Properties to ensure the integrity of data by providing some kind of
checksum algorithm.
However, at the point of writing this specification, the Working
Group has decided to provide the basic framework that will support the
immediate needs of vocabularies using this specification like the Evaluation
and Report Language (EARL) [EARL],
leaving the room open for further extensions as new use cases are presented to
us.
To understand the versatility of the
vocabulary, let us assume we have a given XHTML page containing
an XML declaration, a
comment preceding a document type declaration and some
XHTML elements.
Example 2.6: A typical XHTML page.
<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<!-- this is a comment -->
<!DOCTYPE html "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
<head>
<title>The title</title>
</head>
<body>
<p>Some paragraph.</p>
</body>
</html>
This page could be represented as simple ContentAsText:
<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:cnt="http://www.w3.org/2011/content#">
<cnt:ContentAsText>
<cnt:chars><?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<!-- this is a comment -->
<!DOCTYPE html "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<title>The title</title>
</head>
<body>
<p>Some paragraph.</p>
</body>
</html></cnt:chars>
<dct:isFormatOf rdf:resource="http://example.org/example207.html"/>
</cnt:ContentAsText>
</rdf:RDF>
or likewise as ContentAsXML. As the comment
<!-- this is a comment --> precedes the document type
declaration a cnt:leadingMisc property is created with its object
literal containing the comment. The document type declaration is modelled as a
DoctypeDecl resource and refered to from the
cnt:ContentAsXML resource by the cnt:dtDecl
property.
