/*
* Copyright (c) 2009-2012 Clark & Parsia, LLC. <http://www.clarkparsia.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.clarkparsia.empire.codegen;
import com.complexible.common.collect.Iterables2;
import com.complexible.common.collect.Iterators2;
import com.complexible.common.openrdf.model.Statements;
import com.complexible.common.openrdf.repository.Repositories;
import com.google.common.collect.Iterables;
import org.openrdf.model.Resource;
import org.openrdf.model.URI;
import org.openrdf.model.Statement;
import org.openrdf.model.Value;
import org.openrdf.model.Literal;
import org.openrdf.model.BNode;
import org.openrdf.model.vocabulary.OWL;
import org.openrdf.model.vocabulary.XMLSchema;
import org.openrdf.model.vocabulary.RDFS;
import org.openrdf.model.vocabulary.RDF;
import org.openrdf.model.impl.ValueFactoryImpl;
import org.openrdf.query.QueryLanguage;
import org.openrdf.repository.Repository;
import org.openrdf.rio.RDFFormat;
import org.openrdf.query.BindingSet;
import org.openrdf.query.TupleQueryResult;
import com.complexible.common.openrdf.util.AdunaIterations;
import com.complexible.common.collect.MultiIterator;
import com.complexible.common.net.NetUtils;
import com.complexible.common.base.Functions2;
import com.google.common.base.Predicate;
import com.google.common.base.Charsets;
import com.google.common.base.Function;
import com.google.common.base.Functions;
import com.google.common.collect.Collections2;
import com.google.common.collect.Sets;
import com.google.common.collect.Iterators;
import com.google.common.io.Files;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Collection;
import java.util.Map;
import java.util.List;
import java.util.Arrays;
import java.util.HashSet;
import java.util.HashMap;
import java.io.File;
import java.io.IOException;
import java.net.URL;
/**
* <p>Generate a set of Java beans which are compatible with Empire from a given RDF schema, OWL ontology, or blob
* of RDF data. The generated source code will map to the domain represented in the RDF.</p>
*
* @author Michael Grove
* @since 0.5.1
* @version 0.7.3
*/
public final class BeanGenerator {
/**
* The logger
*/
private static final Logger LOGGER = LoggerFactory.getLogger(BeanGenerator.class);
/**
* String URI constant for the owl:Thing conccept
*/
private static final URI OWL_THING = ValueFactoryImpl.getInstance().createURI(OWL.NAMESPACE + "Thing");
/**
* The list of xsd datatypes which map to Integer
*/
private static final List<URI> integerTypes = Arrays.asList(XMLSchema.INT, XMLSchema.INTEGER, XMLSchema.POSITIVE_INTEGER,
XMLSchema.NEGATIVE_INTEGER, XMLSchema.NON_NEGATIVE_INTEGER,
XMLSchema.NON_POSITIVE_INTEGER, XMLSchema.UNSIGNED_INT);
/**
* The list of xsd datatypes which map to Long
*/
private static final List<URI> longTypes = Arrays.asList(XMLSchema.LONG, XMLSchema.UNSIGNED_LONG);
/**
* The list of xsd datatypes which map to Float
*/
private static final List<URI> floatTypes = Arrays.asList(XMLSchema.FLOAT, XMLSchema.DECIMAL);
/**
* The list of xsd datatypes which map to Short
*/
private static final List<URI> shortTypes = Arrays.asList(XMLSchema.SHORT, XMLSchema.UNSIGNED_SHORT);
/**
* The list of xsd datatypes which map to Byte
*/
private static final List<URI> byteTypes = Arrays.asList(XMLSchema.BYTE, XMLSchema.UNSIGNED_BYTE);
private static final Map<Resource, String> NAMES = new HashMap<Resource, String>();
private static final Map<String, Integer> NAMES_TO_COUNT = new HashMap<String, Integer>();
/**
* NO instances
*/
private BeanGenerator() {
}
/**
* Return the Java bean source code that represents the given RDF class
* @param thePackageName the name of the package the source will be in
* @param theGraph the repository containing information about the class
* @param theClass the class that is to be turned into Java source
* @param theMap the map of classes to the properties in their domain
* @return a string of the source code of the equivalent Java bean
* @throws Exception if there is an error while converting
*/
private static String toSource(final String thePackageName, final Repository theGraph, final Resource theClass, final Map<Resource, Collection<URI>> theMap) throws Exception {
StringBuffer aSrc = new StringBuffer();
aSrc.append("package ").append(thePackageName).append(";\n\n");
aSrc.append("import java.util.*;\n");
aSrc.append("import javax.persistence.Entity;\n");
aSrc.append("import com.clarkparsia.empire.SupportsRdfId;\n");
aSrc.append("import com.clarkparsia.empire.annotation.*;\n\n");
// TODO: more imports? less?
Iterable<Resource> aSupers = Iterables2.present(Iterables.transform(AdunaIterations.iterable(Repositories.getStatements(theGraph, theClass, RDFS.SUBCLASSOF, null)),
Statements.objectAsResource()));
aSrc.append("@Entity\n");
aSrc.append("@RdfsClass(\"").append(theClass).append("\")\n");
aSrc.append("public interface ").append(className(theClass));
aSupers = Collections2.filter(Sets.newHashSet(aSupers), new Predicate<Resource>() {
public boolean apply(final Resource theValue) {
return theValue != null &&
!theValue.toString().startsWith(OWL.NAMESPACE)
&& !theValue.toString().startsWith(RDFS.NAMESPACE)
&& !theValue.toString().startsWith(RDF.NAMESPACE);
}
});
boolean aNeedsComma = false;
aSrc.append(" extends");
if (aSupers.iterator().hasNext()) {
for (Resource aSuper : aSupers) {
if (aNeedsComma) {
aSrc.append(",");
}
else {
aNeedsComma = true;
}
aSrc.append(" ").append(className(aSuper));
}
}
if (aNeedsComma) {
aSrc.append(",");
}
aSrc.append(" SupportsRdfId");
aSrc.append(" { \n\n");
Collection<URI> aProps = props(theClass, theMap);
for (URI aProp : aProps) {
aSrc.append("@RdfProperty(\"").append(aProp).append("\")\n");
aSrc.append("public ").append(functionType(theGraph, aProp)).append(" get").append(functionName(aProp)).append("();\n");
aSrc.append("public void set").append(functionName(aProp)).append("(").append(functionType(theGraph, aProp)).append(" theValue);\n\n");
}
aSrc.append("}");
return aSrc.toString();
}
/**
* Return the type of the function (getter & setter), i.e. the bean property type, for the given rdf:Property
* @param theRepo the graph of the ontology/data
* @param theProp the property
* @return the String representation of the property type
* @throws Exception if there is an error querying the data
*/
private static String functionType(final Repository theRepo, final URI theProp) throws Exception {
String aType;
Resource aRangeRes = Statements.objectAsResource().apply(AdunaIterations.singleResult(Repositories.getStatements(theRepo, theProp, RDFS.RANGE, null)).orNull()).orNull();
if (aRangeRes instanceof BNode) {
// we can't handle bnodes very well, so we're just going to assume Object
return "Object";
}
URI aRange = (URI) aRangeRes;
if (aRange == null) {
// no explicit range, try to infer it...
try {
TupleQueryResult aResults = Repositories.selectQuery(theRepo, QueryLanguage.SERQL, "select distinct r from {s} <"+theProp+"> {o}, {o} rdf:type {r}");
if (aResults.hasNext()) {
URI aTempRange = (URI) aResults.next().getValue("r");
if (!aResults.hasNext()) {
aRange = aTempRange;
}
else {
// TODO: leave range as null, the property is used for things of multiple different values. so here
// we should try and find the superclass of all the values and use that as the range.
}
}
aResults.close();
if (aRange == null) {
// could not get it from type usage, so maybe its a literal and we can guess it from datatype
aResults = Repositories.selectQuery(theRepo, QueryLanguage.SERQL, "select distinct datatype(o) as dt from {s} <"+theProp+"> {o} where isLiteral(o)");
if (aResults.hasNext()) {
URI aTempRange = null;
while (aTempRange == null && aResults.hasNext()) {
Literal aLit = (Literal) aResults.next().getValue("o");
if (aLit != null){
aTempRange = aLit.getDatatype();
}
}
if (!aResults.hasNext()) {
aRange = aTempRange;
}
else {
// TODO: do something here, literals of multiple types used
}
}
aResults.close();
}
}
catch (Exception e) {
// don't worry about it
e.printStackTrace();
}
}
if (XMLSchema.STRING.equals(aRange) || RDFS.LITERAL.equals(aRange)) {
aType = "String";
}
else if (XMLSchema.BOOLEAN.equals(aRange)) {
aType = "Boolean";
}
else if (integerTypes.contains(aRange)) {
aType = "Integer";
}
else if (longTypes.contains(aRange)) {
aType = "Long";
}
else if (XMLSchema.DOUBLE.equals(aRange)) {
aType = "Double";
}
else if (floatTypes.contains(aRange)) {
aType = "Float";
}
else if (shortTypes.contains(aRange)) {
aType = "Short";
}
else if (byteTypes.contains(aRange)) {
aType = "Byte";
}
else if (XMLSchema.ANYURI.equals(aRange)) {
aType = "java.net.URI";
}
else if (XMLSchema.DATE.equals(aRange) || XMLSchema.DATETIME.equals(aRange)) {
aType = "Date";
}
else if (XMLSchema.TIME.equals(aRange)) {
aType = "Date";
}
else if (aRange == null || aRange.equals(OWL_THING)) {
aType = "Object";
}
else {
aType = className(aRange);
}
if (isCollection(theRepo, theProp)) {
aType = "Collection<? extends " + aType + ">";
}
return aType;
}
/**
* Determine whether or not the property's range is a collection. This will inspect both the ontology, for cardinality
* restrictions, and when that is not available, it will use the actual structure of the data.
* @param theRepo the graph of the ontology/data
* @param theProp the property
* @return true if the property has a collection as it's value, false if it's just a single valued property
* @throws Exception if there is an error querying the data
*/
private static boolean isCollection(final Repository theRepo, final URI theProp) throws Exception {
// TODO: this is not fool proof.
String aCardQuery = "select distinct ?card where {\n" +
"?s rdf:type owl:Restriction.\n" +
"?s owl:onProperty <"+theProp+">.\n" +
"?s ?cardProp ?card.\n" +
"FILTER (?cardProp = owl:cardinality || ?cardProp = owl:minCardinality || ?cardProp = owl:maxCardinality)\n" +
"}";
TupleQueryResult aResults = Repositories.selectQuery(theRepo, QueryLanguage.SPARQL ,aCardQuery);
if (aResults.hasNext()) {
Literal aCard = (Literal) aResults.next().getValue("card") ;
try {
return Integer.parseInt(aCard.getLabel()) > 1;
}
catch (NumberFormatException e) {
LOGGER.error("Unparseable cardinality value for '" + theProp + "' of '" + aCard + "'", e);
}
}
aResults.close();
try {
aResults = Repositories.selectQuery(theRepo, QueryLanguage.SPARQL, "select distinct ?s where { ?s <"+theProp+"> ?o}");
for (BindingSet aBinding : AdunaIterations.iterable(aResults)) {
Collection aCollection = Sets.newHashSet(Iterators2.present(Iterators.transform(AdunaIterations.iterator(Repositories.getStatements(theRepo, (Resource) aBinding.getValue("s"), theProp, null)),
Statements.objectOptional())));
if (aCollection.size() > 1) {
return true;
}
}
return false;
}
finally {
aResults.close();
}
}
/**
* Return the name of the function (the bean property) for this rdf:Property
* @param theProp the rdf:Property
* @return the name of the Java property/function name
*/
private static String functionName(final URI theProp) {
return className(theProp);
}
/**
* Return all the properties for the given resource. This will return only the properties which are directly
* associated with the class, not any properties from its parent, or otherwise inferred from the data.
* @param theRes the resource
* @param theMap the map of resources to properties
* @return a collection of the proeprties associated with the class
*/
private static Collection<URI> props(final Resource theRes, final Map<Resource, Collection<URI>> theMap) {
Collection<URI> aProps = new HashSet<URI>();
if (theMap.containsKey(theRes)) {
aProps.addAll(theMap.get(theRes));
}
return aProps;
}
/**
* Given a Resource, return the Java class name for that resource
* @param theClass the resource
* @return the name of the Java class
*/
private static String className(Resource theClass) {
if (NAMES.containsKey(theClass)) {
return NAMES.get(theClass);
}
String aLabel;
if (theClass instanceof URI) {
aLabel = ((URI) theClass).getLocalName();
}
else {
aLabel = theClass.stringValue();
}
aLabel = String.valueOf(aLabel.charAt(0)).toUpperCase() + aLabel.substring(1);
aLabel = aLabel.replaceAll(" ", "");
if (NAMES_TO_COUNT.containsKey(aLabel)) {
String aNewLabel = aLabel + NAMES_TO_COUNT.get(aLabel);
NAMES_TO_COUNT.put(aLabel, NAMES_TO_COUNT.get(aLabel)+1);
aLabel = aNewLabel;
}
else {
NAMES_TO_COUNT.put(aLabel, 0);
}
NAMES.put(theClass, aLabel);
return aLabel;
}
/**
* Given an ontology/schema, generate Empire compatible Java beans for each class in the ontology.
* @param thePackageName the name of the packages the source should belong to
* @param theOntology the location of the ontology to load
* @param theFormat the RDF format the ontology is in
* @param theDirToSave where to save the generated source code
* @throws Exception if there is an error while generating the source
*/
public static void generateSourceFiles(String thePackageName, URL theOntology, RDFFormat theFormat, File theDirToSave) throws Exception {
NAMES_TO_COUNT.clear();
Repository aRepository = Repositories.createInMemoryRepo();
Repositories.add(aRepository, theOntology.openStream(), theFormat);
Collection<Resource> aClasses = Sets.newHashSet(Iterators.transform(new MultiIterator<Statement>(AdunaIterations.iterator(Repositories.getStatements(aRepository, null, RDF.TYPE, RDFS.CLASS)),
AdunaIterations.iterator(Repositories.getStatements(aRepository, null, RDF.TYPE, OWL.CLASS))),
new StatementToSubject()));
aClasses = Collections2.filter(aClasses, new Predicate<Resource>() { public boolean apply(Resource theRes) { return theRes instanceof URI; } });
Collection<Resource> aIndClasses = Sets.newHashSet(Iterators.transform(AdunaIterations.iterator(Repositories.getStatements(aRepository, null, RDF.TYPE, null)),
Functions.compose(Functions2.<Value, Resource>cast(Resource.class),
new StatementToObject())));
aClasses.addAll(aIndClasses);
aClasses = Collections2.filter(aClasses, new Predicate<Resource>() {
public boolean apply(final Resource theValue) {
return !theValue.stringValue().startsWith(RDFS.NAMESPACE)
&& !theValue.stringValue().startsWith(RDF.NAMESPACE)
&& !theValue.stringValue().startsWith(OWL.NAMESPACE);
}
});
Map<Resource, Collection<URI>> aMap = new HashMap<Resource, Collection<URI>>();
for (Resource aClass : aClasses) {
if (aClass instanceof BNode) { continue; }
Collection<URI> aProps = Sets.newHashSet(Iterators.transform(AdunaIterations.iterator(Repositories.getStatements(aRepository, null, RDFS.DOMAIN, aClass)),
Functions.compose(Functions2.<Resource, URI>cast(URI.class),
new StatementToSubject())));
// infer properties based on usage in actual instance data
for (BindingSet aBinding : AdunaIterations.iterable(Repositories.selectQuery(aRepository, QueryLanguage.SPARQL, "select distinct ?p where { ?s rdf:type <" + aClass + ">. ?s ?p ?o }"))) {
aProps.add( (URI) aBinding.getValue("p"));
}
// don't include rdf:type as a property
aProps = Collections2.filter(aProps, new Predicate<URI>() {
public boolean apply(final URI theValue) {
return !RDF.TYPE.equals(theValue);
}
});
aMap.put(aClass, aProps);
}
if (!theDirToSave.exists()) {
if (!theDirToSave.mkdirs()) {
throw new IOException("Could not create output directory");
}
}
for (Resource aClass : aMap.keySet()) {
String aSrc = toSource(thePackageName, aRepository, aClass, aMap);
if (aSrc == null) {
continue;
}
File aFile = new File(theDirToSave, className(aClass) + ".java");
System.out.println("Writing source to file: " + aFile.getName());
Files.write(aSrc, aFile, Charsets.UTF_8);
}
}
public static void main(String[] args) throws Exception {
//aGraph.read(new URL("http://xmlns.com/foaf/spec/index.rdf").openStream());
// File aOut = new File("/Users/mhgrove/work/GitHub/empire/core/src/com/clarkparsia/empire/codegen/test/");
//
// generateSourceFiles("com.clarkparsia.empire.codegen.test", new File("test/data/nasa.nt").toURI().toURL(), RDFFormat.NTRIPLES, aOut);
if (args.length < 4) {
System.err.println("Must provide four arguments to the program, the package name, ontology URL, rdf format of the ontology (rdf/xml|turtle|ntriples), and the output directory for the source code.\n");
System.err.println("For example:\n");
System.err.println("\tBeanGenerator my.package.domain /usr/local/files/myontology.ttl turtle /usr/local/code/src/my/package/domain");
return;
}
URL aURL;
if (NetUtils.isURL(args[1])) {
aURL = new URL(args[1]);
}
else {
aURL = new File(args[1]).toURI().toURL();
}
generateSourceFiles(args[0], aURL, RDFFormat.valueOf(args[2]), new File(args[3]));
}
private static class StatementToObject implements Function<Statement, Value> {
public Value apply(final Statement theIn) {
return theIn.getObject();
}
}
private static class StatementToSubject implements Function<Statement, Resource> {
public Resource apply(final Statement theIn) {
return theIn.getSubject();
}
}
}