Linked Data Microframework: Linked Ratpack

The other day I ran across some of the Sinatra inspired web microframeworks available in various languages, including Ratpack for Groovy.  Given RDF builder DSL in Groovy Sparql, I thought it would be a nice thought expertiment to create a microframework for linked data and RDF.  After an afternoon of coding and testing, the results look quite promising.  So here it is - Linked Ratpack, a microframework for Linked Data.

Linked RP works the same way Ratpack does - you provide a single Domain Specific Language (DSL) script where you write your methods to perform some function on a URL, and it weaves those in to a Jetty container.  In this case, I've added some capabilities to Ratpack to work with linked data:

• RDFBuilder from Groovy SPARQL is automatically available to the DSL script under the 'rdf' variable
• link(String endpoint) is available as a function to get an instance of the Groovy SPARQL Sparql class for performing Sparql queries.
• resolve(String uri) is a new piece of functionality that uses Groovy's HTTPBuilder DSL and Jena to retrieve a URL and read it into RDF.  It should work across various RDF serialization types, and likely bomb out on HTML or anything else if you feed it an incorrect URI

The following Gist illustrates everything fairly nicely:

	set 'port', 4999
	// All three methods (RDFBuilder closure, construct, resolve) return
	// Jena models and can be further processed with Groovy SPARQL's Sparql class
	// link(String endpoint) returns the Sparql endpoint or you can instantiate new
	// ones. Jena+ ARQ will be on the classpath
	get("/") {
	setHeader("Content-Type", "application/rdf+xml")
	rdf.xml {
	defaultNamespace "http://localhost:4999/test"
	namespace foaf:"http://xmlns.com/foaf/0.1"
	subject("#clarkkent") {
	property "foaf:gender":"male"
	property "foaf:title":"Mr"
	property "foaf:givenname":"Clark"
	property "foaf:family_name":"Kent"
	}
	};return null; // using the builder already sends output
	// and lets you customize the serialization format
	}
	get("/groovy") {
	link("http://dbpedia.org/sparql").construct("""
	CONSTRUCT {
	<http://dbpedia.org/resource/Groovy_%28programming_language%29> <http://dbpedia.org/ontology/abstract> ?b
	} wHERE {
	<http://dbpedia.org/resource/Groovy_%28programming_language%29> <http://dbpedia.org/ontology/abstract> ?b
	}
	""")
	}
	get("/tim") {
	resolve('http://www.w3.org/People/Berners-Lee/card')
	}

view raw sample.groovy hosted with ❤ by GitHub

You can now browse to the following URLs:

• localhost:4999/
• localhost:4999/tim
• localhost:4999/groovy

Note: since Jena models being returned by those functions get automatically serialized back out - if you want to do serialization inline - return null

To get started with Linked Ratpack, you must do the following:

1. Get Groovy SPARQL from Github, and build/install it with Gradle
2. Get Linked Ratpack from Github, and build it
3. Create simple groovy scripts, like the above gist, and run "ratpack path/to/whatever.groovy"

This will start an HTTP server on whatever port you define in the DSL.  After that, you can start browsing to your URLs, hooking up SPARQL endpoint and generating RDF.

For me, this is one of the missing pieces in building linked data applications - an easy way to stand up little RDF servers to test walking RDF graphs hop-by-hop and perform URI de-referencing, and experimenting with generating derivative RDF sites from other RDF data sources (e.g. SPARQL Construct).

Many thanks to Justin Voss ( @ github ) for creating Ratpack in the first place, it was a solid foundation to build off of.

Enjoy!

Groovy SPARQL 0.2 Available

Version 0.2 of Groovy SPARQL is now available.  This minor release includes a Groovy DSL for RDF, now you can build RDF and then query it.  The Groovy DSL is fairly flexible and takes advantage of a number of Groovy features including:

1. Optional syntax in Groovy 1.8 for more fluid DSLs
2. GPars, aka the Groovy Parallelizer for asynchronous output hooks
3. Usage of the BuilderSupport class

 Per previous posts on the blog, if you want to use it in Grails / GroovyConsole / other apps, I recommend downloading, doing the Gradle build, install into your local Maven repo and then you can include it easily enough in whatever build environment you are using.

Here is a GIST showing the RDFBuilder DSL in action, with comments noting all of the 'features' available so far.  This is still a work in progress, and the more I attempt to use it to build FOAF and other vocabularies, I'm sure I'll be shaking some bugs out (not the least of which is the wonderful world of URI fragments).

	@Grab('org.codehaus.groovy.sparql:groovy-sparql:0.2')
	import groovy.sparql.*
	/**
	Can be constructed with:
	- Outputstream
	- PrintWriter
	- Model (all statements built will be copied into the input model
	via model.add(List<Statement>)
	Can register other output hooks
	builder.registerOutputHook(closure)
	If more than one output hook is registered, they're executed in parallel via GPars
	First closure in the builder is the output type, here are the format types (mapped to Jena):
	[xml:"RDF/XML", xmlabbrev:"RDF/XML-ABBREV", ntriple:"N-TRIPLE", n3:"N3", turtle:"TURTLE"]
	All other root closure names are ignored, and you just get the model returned
	Vocab in the DSL is:
	defaultNamespace "namespace"
	namespace prefix:"namespace"
	subject("uri or fragment) {
	property "predicate":object"
	property "predicate" {
	subject("uri or fragment") {
	....
	}
	}
	}
	You can nest subjects and properties per above, see the JUnit test for example
	**/
	def builder = new RDFBuilder(System.out)
	// model is a Jena Model
	def model = builder.n3 {
	defaultNamespace "http://www.example.org"
	namespace foaf:"http://xmlns.com/foaf/0.1"
	subject("#clarkkent") {
	property "foaf:gender":"male"
	property "foaf:title":"Mr"
	property "foaf:givenname":"Clark"
	property "foaf:family_name":"Kent"
	}
	}
	/**
	As N3
	<http://www.example.org#clarkkent>
	<http://xmlns.com/foaf/0.1/family_name>
	"Kent" ;
	<http://xmlns.com/foaf/0.1/gender>
	"male" ;
	<http://xmlns.com/foaf/0.1/givenname>
	"Clark" ;
	<http://xmlns.com/foaf/0.1/title>
	"Mr" .
	**/
	model = builder.xml {
	defaultNamespace "http://www.example.org"
	namespace foaf:"http://xmlns.com/foaf/0.1"
	subject("#clarkkent") {
	property "foaf:gender":"male"
	property "foaf:title":"Mr"
	property "foaf:givenname":"Clark"
	property "foaf:family_name":"Kent"
	}
	}
	/**
	As XML
	<rdf:RDF
	xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
	xmlns:j.0="http://xmlns.com/foaf/0.1/" >
	<rdf:Description rdf:about="http://www.example.org#clarkkent">
	<j.0:family_name>Kent</j.0:family_name>
	<j.0:givenname>Clark</j.0:givenname>
	<j.0:title>Mr</j.0:title>
	<j.0:gender>male</j.0:gender>
	</rdf:Description>
	</rdf:RDF>
	**/

view raw RDFDSL.groovy hosted with ❤ by GitHub

Enjoy!

Gradle, Maven, and Grapes Working Together

For Groovy SPARQL and Spring Jena, I wanted to start leveraging these in little test Groovy scripts running in the console or command line.  At first, I assumed the maven install that happens in their Gradle builds would immediately be picked up by Grape.  However, Grape uses Ant+Ivy, and Ivy does not look in your maven repo by default (doesn't it seem like it should?).

So here are the missing pieces of the puzzle:

1. Setup your Gradle build to create a POM and install your jars into your local maven repo
2. Add  Maven repo support to your Grape configuration.  Grape configuration is in ~/.groovy/grapeConfig.xml - and it's an Ivy file in disguise.  See [*] below for an example which is down near the bottom of the Grape documentation.
3. Install your POM artifacts into Grape.  For Groovy SPARQL, the command is:    grape install org.codehaus.groovy.sparql groovy-sparql 0.1
4. Now you can use Grape, e.g. @Grab('org.codehaus.groovy.sparql:groovy-sparql:0.1')

You can also use grape list to see what jars are now available.

All in all, this makes tools like the Groovy Console an excellent REPL for both Java, Groovy, and presumably other Java polyglot programming.

 * Here is the sample grapeConfig.xml file from the Groovy documentation.

	<?xml version="1.0"?>
	<ivysettings>
	<settings defaultResolver="downloadGrapes"/>
	<resolvers>
	<chain name="downloadGrapes">
	<!-- todo add 'endorsed groovy extensions' resolver here -->
	<ibiblio name="local" root="file:${user.home}/.m2/repository/" m2compatible="true"/>
	<filesystem name="cachedGrapes">
	<ivy pattern="${user.home}/.groovy/grapes/[organisation]/[module]/ivy-[revision].xml"/>
	<artifact pattern="${user.home}/.groovy/grapes/[organisation]/[module]/[type]s/[artifact]-[revision].[ext]"/>
	</filesystem>
	<ibiblio name="codehaus" root="http://repository.codehaus.org/" m2compatible="true"/>
	<ibiblio name="ibiblio" m2compatible="true"/>
	<ibiblio name="java.net2" root="http://download.java.net/maven/2/" m2compatible="true"/>
	</chain>
	</resolvers>
	</ivysettings>

view raw grapeConfig.xml hosted with ❤ by GitHub

Announcing Spring Jena

On the heels of Groovy SPARQL, here is an initial code base for standard Java and Spring applications -- Spring Jena!

The Spring folks have been putting together an impressive portfolio of data oriented capabilities for NoSQL data stores.  To compliment the those capabilities, here is Spring Jena - a project I hope to propose back to the Spring community to provide direct Jena API support and direct SPARQL.

Much like Groovy SPARQL, this is a relatively simple code base that applies the template design pattern to Jena and ARQ to simplify every day needs for creating, modifying, and querying RDF data.  There is a lot more work to do here, most noteably the parameterized queries.

Get Spring Jena @ Github here.

The roadmap includes:

• Spring datastore/mapping support for object relational mapping, once those projects reach 1.0
• Spring Transaction support - wrap Jena native transactions or provide app-level transaction management via Spring
• Abstraction for triple stores - likely aligned against the Datastore interface in Spring Data
• QuerySolutionMap overloading to the methods in the SparqlTemplate
• Web / MVC capabilities, such as a taglib

Here is a GIST to get you going:

	package com.example;
	import org.springframework.data.rdf.sparql.*;
	import org.springframework.data.rdf.jena.*;
	import org.junit.Before;
	import org.junit.Test;
	public class TestSpringJena {
	private Model model;
	private JenaTemplate jena;
	private SparqlTemplate sparql;
	@Before
	public void init() {
	model = ModelFactory.createDefaultModel();
	jena = new JenaTemplate();
	sparql = new SparqlTemplate();
	jena.setModel(model);
	sparql.setModel(model);
	}
	@Test
	public void testModel() {
	jena.add("urn:test", "urn:someProperty", "hello world");
	// Select by list
	String query1 = "SELECT ?x ?y ?z WHERE { ?x ?y ?z }";
	List<String> list = sparql.execSelectList(query1, new SolutionMapper<String>() {
	public String mapSelect(ResultSet rs, int rowNum) {
	QuerySolution sln = rs.nextSolution();
	RDFNode x = sln.get("x");
	RDFNode y = sln.get("y");
	RDFNode z = sln.get("z");
	return x.toString() + "|" + y.toString() + "|" + z.toString();
	} });
	// result set as a map of strings
	Map<String, String> map = sparql.execSelectStringMap(query1);
	// Need one parameter? select a string
	String query2 = "SELECT ?z WHERE { <urn:test> ?y ?z }";
	String result = sparql.execSelectString(query2);
	}
	}

view raw TestSpringJena.java hosted with ❤ by GitHub

Enjoy!