Lift RDFa Templates

A very important and powerful part of the eniLINK Lift template system is its support for using RDFa annotations to query the underlying triplestore and create dynamic page content from the query results.

The RDFa support is implemented with a Snippet, Rdfa, and follow the principles outlined in the Lift template basics.

When talking about creating dynamic web pages from templates, it is of interest how to request content from the data storage backend that matches certain patterns, then filter, sort and format it in different ways for the output.

The eniLINK platform with its base framework KOMMA are built on top of the Linked Data principles, using triples in graph databases or triplestores as the underlying information repository. As usual with triplestores, queries are expressed in SPARQL as a set of triple patterns.

In effect, what a dynamic page request would need to to do is to bind certain variables from such a SPARQL query to template elements or attributes to create the final page. One would already know which variable should be bound to which element or attribute and could, in other words, add additional markup to these template elements to describe such bindings.

Say we meant to display a list of certain types of resources in our triplestore, using some attribute as their description in the list. We would query for the relevant types of resources with their values for the given attribute, and bind those values to new elements on our final page.

We would need to write a SPARQL query with variables, and code that iterated over the query result to generate our elements and bind the variable values to the attributes for these elements.

Or… would we?

Consider that we also knew where the variable was used in the SPARQL query, or what it was bound from in terms of our triplestore, so why not also add a description of that to the markup?

Considering our premise from above, we could have markup for

Now… the good news is that there already is markup available that helps us express triple patterns in terms of RDF types and properties from our triplestore, as needed to construct the SPARQL query. It’s called RDFa (Resource Description Framework in Attributes).

While the original intention of RDFa is the reverse of what we want to use it for, the general idea of augmenting content with meta-information in RDF terms applies, and has benefits, for our use-case as well.

Let us get back to our premise and, since we already linked to the apply it to Example 15 from there.

As stated, the example is just using the RDFa annotations to further describe content on some static html page, but we want to use them to actually create such a page, dynamically, from a query against some triplestore with maybe more than one <foaf:Person>.

This is the HTML from Example 15, wrapped in an extra <div> that invokes the Rdfa snippet, and with the static content replaced by an additional snippet invocation that will actually bind the variable values to the individual fields for the final page. Another small difference is the definition and use of the foaf: prefix for the annotations. (FIXME: vocab not supported right now!)

The Rdfa snippet, when executed with those XML nodes, will create the following SPARQL query, as a set of triple patterns using the type and property information from the annotations:

Supposing we had the triples from Example 15 in our triplestore, this would then result in: