rcc

rcc – RDFa content compiler

rcc [-d datatype] [-t template] file

The rcc command builds individual pieces of content. Input is file, formatted as RDFa Lite. Content is printed to stdout and is built using a selection of customizable mustache(5) templates.

All standard templates use properties from the schema.org types Thing, CreativeWork and SoftwareApplication. This makes rcc a great tool for publishing personal websites, blogs and software documentation in multiple formats. See rdfaprimer(7) for an introduction to RDFa Lite.

The options are as follows:

-d datatype
Data type that string literals should be formatted as. Valid arguments are html, man, md or empty which will render properties as plain strings. Default value is empty.
-t template
Name of a file in /usr/share/rcc/ including the language notation but excluding the .mustache file extension. See Localization and Templates for more information. Default value is: html.en
file
Input file formatted as RDFa Lite.

Localization

rcc is able to manage content translated to multiple languages if (i) your templates are translated and (ii) your content language is annotated correctly in RDFa Lite properties.

Templates are identified as name.language with a dot separating the template name and the intended language. A real example would be the blog.en template.

RDFa Lite content can make use of two important localization features (i) annotating its own language with the lang property and (ii) linking between translations using the two properties below. See schema.org for more information.

schema:workTranslation
Used on original work for linking to its translations.
schema:translationOfWork
Used on translations of original work for linking back.

Templates

rcc is using mustache(7) as its templating language. When an RDFa Lite document is processed, each individual property becomes available as a normal variable in any template its rendered with.

Given the following simple RDFa Lite document:

<article typeof="schema:webpage" resource="bonjour.html" lang="fr">
<h1 property="schema:headline">Bonjour monde</h1>
<p property="schema:abstract">Bienvenue sur mon site</p>
<p>Éteignez votre ordinateur!</p>
</article>

The following normal variables will be available:

{{schema.headline}}
With the value "Bonjour monde".
{{schema.abstract}}
With the value "Bienvenue sur mon site".

Additionally, three special variables will always be available:

{{schema.inLanguage}}
Derived from the lang attribute with the value "fr".
{{schema.webpage}}
Derived from the typeof attribute with the value "1".
{{_base}}
Populated with the value of the BASE environment variable.
{{_main}}
With the full HTML body as its value, even including HTML elements without RDFa Lite attributes.

There are two kinds of templates (i) those meant to build single piece of content (ii) those meant to build lists of content. List templates are used by rcclist(1) come in pairs of two, for example blog and blog.item. The former is the wrapping template and the latter is the template for each individual item in the list.

Below is the list of standard templates. Unless specified, all templates will render content with the schemas CreativeWork or Thing.

Single templates

html
Renders a basic HTML page.
man
Renders a Unix manual page formatted with mdoc(7) for a SoftwareApplication.
readme
Renders a README file formatted with markdown(7) for a SoftwareApplication.
xml
Renders the header for a XML page.

List templates

blog
Renders an HTML list of blog posts.
feed
Renders an Atom XML syndication feed.
index
Renders an unordered HTML item list.
sitemap
Renders an XML sitemap feed.
terms
Renders a plain HTML list of terms and descriptions.

Build system

rcc comes with a simple content build system based on make(1). This system will build content automatically for a few common scenarios, without the user having to interact with rcc at all.

Website content

For a simple website, a Makefile like the sample below should be placed at the document root of the website:

DOMAIN= www.example.com
.include <rcc.html.mk>
.include <rcc.blog.mk>
.include <rcc.feed.mk>

The rcc.html.mk file provide the base functionality with all common make(1) targets for building HTML pages. Content is treated in two ways (i) posts authored as plain markdown(7) documents and (ii) pages authored as RDFa Lite documents. Posts are any file ending with *.md. Pages are any file ending with *.rdfa. In practice, the only difference between these two is that posts go through an extra build step for processing the markdown to RDFa Lite. From that point all files are equal.

Environment

The following environment variables affect the execution:

BASE
Sets the value of in the template variable {{_base}}. To be used for embedding the base URL of a website in templates.
TEMPLATE
Affects which template that will be used. Same as: -t template

Examples

Given doc.rdfa is a description of a CreativeWork, then the following command will produce a basic web page using the html.en template.

$ rcc -t html.en doc.rdfa

Given tool.rdfa is a description of a SoftwareApplication, then the following command will produce a suitable web page using the software.en template.

$ rcc -t software.en tool.rdfa

Create a pipeline converting post.md from markdown, to html, to RDFA Lite and render a simple web page using the default template. This example is using lowdown(1) to process markdown, and triple-rdfa(1) to enrich the plain HTML with RDFa Lite terms from the schema.org vocabulary.

$ lowdown post.md | triple-rdfa | rcc

Caveats

Due to a limitation in how triple-turtle(1) currently parses HTML, it's required to have at least one non-void element before a mustache(7) partial tag appear in the body.