public function testParseWithFormatObject()
{
$format = EasyRdf_Format::getFormat('json');
$this->_parser->parse($this->_graph, $this->_data, $format, null);
$joe = $this->_graph->resource('http://www.example.com/joe#me');
$this->assertStringEquals('Joe Bloggs', $joe->get('foaf:name'));
}
public function setUp()
{
EasyRdf_Http::setDefaultHttpClient($this->_client = new EasyRdf_Http_MockClient());
$this->_graphStore = new EasyRdf_GraphStore('http://localhost:8080/data/');
// Ensure that the built-in n-triples parser is used
EasyRdf_Format::registerSerialiser('ntriples', 'EasyRdf_Serialiser_Ntriples');
}
protected function getTriples($file)
{
if (!file_exists($file)) {
throw new Exception($file . ' not found');
}
// validate the file to import
$parser = new tao_models_classes_Parser($file, array('extension' => 'rdf'));
$parser->validate();
if (!$parser->isValid()) {
throw new common_Exception('Invalid RDF file ' . $file);
}
$modelDefinition = new EasyRdf_Graph();
$modelDefinition->parseFile($file);
/*
$graph = $modelDefinition->toRdfPhp();
$resources = $modelDefinition->resources();
*/
$format = EasyRdf_Format::getFormat('php');
$data = $modelDefinition->serialise($format);
$triples = array();
foreach ($data as $subjectUri => $propertiesValues) {
foreach ($propertiesValues as $prop => $values) {
foreach ($values as $k => $v) {
$triples[] = array('s' => $subjectUri, 'p' => $prop, 'o' => $v['value'], 'l' => isset($v['lang']) ? $v['lang'] : '');
}
}
}
return $triples;
}
/**
* @author "Lionel Lecaque, <*****@*****.**>"
* @param string $namespace
* @param string $data xml content
*/
public function createModel($namespace, $data)
{
$modelId = $this->getModelId($namespace);
if ($modelId === false) {
common_Logger::d('modelId not found, need to add namespace ' . $namespace);
$this->addNewModel($namespace);
//TODO bad way, need to find better
$modelId = $this->getModelId($namespace);
}
$modelDefinition = new EasyRdf_Graph($namespace);
if (is_file($data)) {
$modelDefinition->parseFile($data);
} else {
$modelDefinition->parse($data);
}
$graph = $modelDefinition->toRdfPhp();
$resources = $modelDefinition->resources();
$format = EasyRdf_Format::getFormat('php');
$data = $modelDefinition->serialise($format);
foreach ($data as $subjectUri => $propertiesValues) {
foreach ($propertiesValues as $prop => $values) {
foreach ($values as $k => $v) {
$this->addStatement($modelId, $subjectUri, $prop, $v['value'], isset($v['lang']) ? $v['lang'] : null);
}
}
}
return true;
}
/**
* Retrieve the latest RDFA version of schema.org and converts it to JSON-LD.
*
* Note: caches the file in data and retrieves it from there as long as it exists.
*/
private function getJSONVersionOfSchema()
{
// Set cachefile
$cacheFile = dirname(dirname(__DIR__)) . '/data/schemaorg.cache';
if (!file_exists($cacheFile)) {
// Create dir
if (!file_exists(dirname($cacheFile))) {
mkdir(dirname($cacheFile), 0777, true);
}
// Load RDFA Schema
$graph = new \EasyRdf_Graph(self::RDFA_SCHEMA);
$graph->load(self::RDFA_SCHEMA, 'rdfa');
// Lookup the output format
$format = \EasyRdf_Format::getFormat('jsonld');
// Serialise to the new output format
$output = $graph->serialise($format);
if (!is_scalar($output)) {
$output = var_export($output, true);
}
$this->schema = \ML\JsonLD\JsonLD::compact($graph->serialise($format), 'http://schema.org/');
// Write cache file
file_put_contents($cacheFile, serialize($this->schema));
} else {
$this->schema = unserialize(file_get_contents($cacheFile));
}
}
public function setup()
{
// Reset to built-in parsers
EasyRdf_Format::registerParser('ntriples', 'EasyRdf_Parser_Ntriples');
EasyRdf_Format::registerParser('rdfxml', 'EasyRdf_Parser_RdfXml');
EasyRdf_Format::registerParser('turtle', 'EasyRdf_Parser_Turtle');
}
/**
* @Route("/create-person")
*/
public function createPersonAction()
{
\EasyRdf_Format::registerSerialiser('ntriples', 'EasyRdf_Serialiser_Arc');
\EasyRdf_Format::registerSerialiser('posh', 'EasyRdf_Serialiser_Arc');
\EasyRdf_Format::registerSerialiser('rdfxml', 'EasyRdf_Serialiser_Arc');
\EasyRdf_Format::registerSerialiser('turtle', 'EasyRdf_Serialiser_Arc');
\EasyRdf_Namespace::set('foaf', 'http://xmlns.com/foaf/0.1/');
$uri = 'http://www.example.com/emi#me';
$name = 'Emi Berea';
$emailStr = '*****@*****.**';
$homepageStr = 'http://bereae.me/';
$graph = new \EasyRdf_Graph();
# 1st Technique
$me = $graph->resource($uri, 'foaf:Person');
$me->set('foaf:name', $name);
if ($emailStr) {
$email = $graph->resource("mailto:" . $emailStr);
$me->add('foaf:mbox', $email);
}
if ($homepageStr) {
$homepage = $graph->resource($homepageStr);
$me->add('foaf:homepage', $homepage);
}
# Finally output the graph
$data = $graph->serialise('rdfxml');
if (!is_scalar($data)) {
$data = var_export($data, true);
}
var_dump($data);
die;
}
public function testParseWithFormatObject()
{
$data = readFixture('foaf.jsonld');
$format = EasyRdf_Format::getFormat('jsonld');
$count = $this->parser->parse($this->graph, $data, $format, null);
$this->assertSame(14, $count);
$joe = $this->graph->resource('http://www.example.com/joe#me');
$this->assertStringEquals('Joe Bloggs', $joe->get('foaf:name'));
}
public function __construct(EasyRdf_Graph $graph = null)
{
if ($graph === null) {
$graph = new EasyRdf_Graph();
}
$this->graph = $graph;
$this->uriGenerators = array();
EasyRdf_Format::register('rdfxml', 'RDF/XML', 'http://www.w3.org/TR/rdf-syntax-grammar', 'application/rdf+xml');
//EasyRdf_Format::registerParser( 'rdfxml', 'EasyRdf_Parser_RdfXml');
EasyRdf_Format::registerSerialiser('rdfxml', 'EasyRdf_Serialiser_RdfXml');
}
public static function toFile($filePath, $triples)
{
$graph = new \EasyRdf_Graph();
foreach ($triples as $triple) {
if (!empty($triple->lg)) {
$graph->addLiteral($triple->subject, $triple->predicate, $triple->object, $triple->lg);
} elseif (\common_Utils::isUri($triple->object)) {
$graph->add($triple->subject, $triple->predicate, $triple->object);
} else {
$graph->addLiteral($triple->subject, $triple->predicate, $triple->object);
}
}
$format = \EasyRdf_Format::getFormat('rdfxml');
return file_put_contents($filePath, $graph->serialise($format));
}
/**
* Export to xml-rdf the ontology of the Class in parameter.
* All the ontologies are exported if the class is not set
*
* @access public
* @author Jerome Bogaerts, <*****@*****.**>
* @param Class source
* @return string
*/
public function export(core_kernel_classes_Class $source = null)
{
$rdf = '';
if (is_null($source)) {
return core_kernel_api_ModelExporter::exportAll();
}
$graph = new EasyRdf_Graph();
if ($source->isClass()) {
$this->addClass($graph, $source);
} else {
$this->addResource($graph, $source);
}
$format = EasyRdf_Format::getFormat('rdfxml');
return $graph->serialise($format);
}
/**
* @ignore
*/
private static function statement2rdf(PDOStatement $statement)
{
$graph = new EasyRdf_Graph();
while ($r = $statement->fetch()) {
if (isset($r['l_language']) && !empty($r['l_language'])) {
$graph->addLiteral($r['subject'], $r['predicate'], $r['object'], $r['l_language']);
} elseif (common_Utils::isUri($r['object'])) {
$graph->add($r['subject'], $r['predicate'], $r['object']);
} else {
$graph->addLiteral($r['subject'], $r['predicate'], $r['object']);
}
}
$format = EasyRdf_Format::getFormat('rdfxml');
return $graph->serialise($format);
}
/**
* Imports the rdf file into the selected class
*
* @param string $file
* @param core_kernel_classes_Class $class
* @return common_report_Report
*/
private function flatImport($file, core_kernel_classes_Class $class)
{
$report = common_report_Report::createSuccess(__('Data imported successfully'));
$graph = new EasyRdf_Graph();
$graph->parseFile($file);
// keep type property
$map = array(RDF_PROPERTY => RDF_PROPERTY);
foreach ($graph->resources() as $resource) {
$map[$resource->getUri()] = common_Utils::getNewUri();
}
$format = EasyRdf_Format::getFormat('php');
$data = $graph->serialise($format);
foreach ($data as $subjectUri => $propertiesValues) {
$resource = new core_kernel_classes_Resource($map[$subjectUri]);
$subreport = $this->importProperties($resource, $propertiesValues, $map, $class);
$report->add($subreport);
}
return $report;
}
public function addMock($method, $uri, $body, $options = array())
{
$match = array();
$match['method'] = $method;
$match['uri'] = array();
if (isset($options['callback'])) {
$match['callback'] = $options['callback'];
if (isset($options['callbackArgs'])) {
$match['callbackArgs'] = $options['callbackArgs'];
} else {
$match['callbackArgs'] = array();
}
}
if (!isset($uri)) {
$match['uri'] = null;
} else {
$match['uri'] = strval($uri);
}
if ($body instanceof EasyRdf_Http_Response) {
$response = $body;
} else {
if (isset($options['status'])) {
$status = $options['status'];
} else {
$status = 200;
}
if (isset($options['headers'])) {
$headers = $options['headers'];
} else {
$headers = array();
$format = EasyRdf_Format::guessFormat($body);
if (isset($format)) {
$headers['Content-Type'] = $format->getDefaultMimeType();
}
if (isset($body)) {
$headers['Content-Length'] = strlen($body);
}
}
$response = new EasyRdf_Http_Response($status, $headers, $body);
}
$once = isset($options['once']) ? $options['once'] : false;
$this->_mocks[] = array($match, $response, $once);
}
/** Send some graph data to the graph store
*
* This method is used by insert() and replace()
*
* @ignore
*/
protected function sendGraph($method, $graph, $uriRef, $format)
{
if (is_object($graph) and $graph instanceof EasyRdf_Graph) {
if ($uriRef == null) {
$uriRef = $graph->getUri();
}
$data = $graph->serialise($format);
} else {
$data = $graph;
}
$formatObj = EasyRdf_Format::getFormat($format);
$mimeType = $formatObj->getDefaultMimeType();
$graphUri = $this->_parsedUri->resolve($uriRef)->toString();
$dataUrl = $this->urlForGraph($graphUri);
$client = EasyRdf_Http::getDefaultHttpClient();
$client->resetParameters(true);
$client->setUri($dataUrl);
$client->setMethod($method);
$client->setRawData($data);
$client->setHeaders('Content-Type', $mimeType);
$client->setHeaders('Content-Length', strlen($data));
$response = $client->request();
if (!$response->isSuccessful()) {
throw new EasyRdf_Exception("HTTP request for {$dataUrl} failed: " . $response->getMessage());
}
return $response;
}
*
* @param object EasyRdf_Graph $graph the graph to load the data into
* @param string $data the RDF document data
* @param string $format the format of the input data
* @param string $baseUri the base URI of the data being parsed
* @return boolean true if parsing was successful
*/
public function parse($graph, $data, $format, $baseUri)
{
parent::checkParseParams($graph, $data, $format, $baseUri);
if (array_key_exists($format, self::$_supportedTypes)) {
$className = self::$_supportedTypes[$format];
} else {
throw new EasyRdf_Exception("EasyRdf_Parser_Arc does not support: {$format}");
}
$parser = ARC2::getParser($className);
if ($parser) {
$parser->parse($baseUri, $data);
$rdfphp = $parser->getSimpleIndex(false);
return parent::parse($graph, $rdfphp, 'php', $baseUri);
} else {
throw new EasyRdf_Exception("ARC2 failed to get a {$className} parser.");
}
}
}
## FIXME: do this automatically
EasyRdf_Format::registerParser('rdfxml', 'EasyRdf_Parser_Arc');
EasyRdf_Format::registerParser('turtle', 'EasyRdf_Parser_Arc');
EasyRdf_Format::registerParser('ntriples', 'EasyRdf_Parser_Arc');
EasyRdf_Format::registerParser('rdfa', 'EasyRdf_Parser_Arc');
EasyRdf_Format::register('turtle', 'Turtle Terse RDF Triple Language', 'http://www.dajobe.org/2004/01/turtle', array('text/turtle' => 0.8, 'application/turtle' => 0.7, 'application/x-turtle' => 0.7), array('ttl'));
EasyRdf_Format::register('rdfxml', 'RDF/XML', 'http://www.w3.org/TR/rdf-syntax-grammar', array('application/rdf+xml' => 0.8), array('rdf', 'xrdf'));
EasyRdf_Format::register('dot', 'Graphviz', 'http://www.graphviz.org/doc/info/lang.html', array('text/vnd.graphviz' => 0.8), array('gv', 'dot'));
EasyRdf_Format::register('json-triples', 'RDF/JSON Triples');
EasyRdf_Format::register('n3', 'Notation3', 'http://www.w3.org/2000/10/swap/grammar/n3#', array('text/n3' => 0.5, 'text/rdf+n3' => 0.5), array('n3'));
EasyRdf_Format::register('rdfa', 'RDFa', 'http://www.w3.org/TR/rdfa-core/', array('text/html' => 0.4, 'application/xhtml+xml' => 0.4), array('html'));
EasyRdf_Format::register('sparql-xml', 'SPARQL XML Query Results', 'http://www.w3.org/TR/rdf-sparql-XMLres/', array('application/sparql-results+xml' => 1.0));
EasyRdf_Format::register('sparql-json', 'SPARQL JSON Query Results', 'http://www.w3.org/TR/rdf-sparql-json-res/', array('application/sparql-results+json' => 1.0));
EasyRdf_Format::register('png', 'Portable Network Graphics (PNG)', 'http://www.w3.org/TR/PNG/', array('image/png' => 0.3), array('png'));
EasyRdf_Format::register('gif', 'Graphics Interchange Format (GIF)', 'http://www.w3.org/Graphics/GIF/spec-gif89a.txt', array('image/gif' => 0.2), array('gif'));
EasyRdf_Format::register('svg', 'Scalable Vector Graphics (SVG)', 'http://www.w3.org/TR/SVG/', array('image/svg+xml' => 0.3), array('svg'));
/*
Register default set of parsers and serialisers
*/
EasyRdf_Format::registerParser('json', 'EasyRdf_Parser_Json');
EasyRdf_Format::registerParser('ntriples', 'EasyRdf_Parser_Ntriples');
EasyRdf_Format::registerParser('php', 'EasyRdf_Parser_RdfPhp');
EasyRdf_Format::registerParser('rdfxml', 'EasyRdf_Parser_RdfXml');
EasyRdf_Format::registerParser('turtle', 'EasyRdf_Parser_Turtle');
EasyRdf_Format::registerParser('rdfa', 'EasyRdf_Parser_Rdfa');
EasyRdf_Format::registerSerialiser('json', 'EasyRdf_Serialiser_Json');
EasyRdf_Format::registerSerialiser('n3', 'EasyRdf_Serialiser_Turtle');
EasyRdf_Format::registerSerialiser('ntriples', 'EasyRdf_Serialiser_Ntriples');
EasyRdf_Format::registerSerialiser('php', 'EasyRdf_Serialiser_RdfPhp');
EasyRdf_Format::registerSerialiser('rdfxml', 'EasyRdf_Serialiser_RdfXml');
EasyRdf_Format::registerSerialiser('turtle', 'EasyRdf_Serialiser_Turtle');
EasyRdf_Format::registerSerialiser('dot', 'EasyRdf_Serialiser_GraphViz');
EasyRdf_Format::registerSerialiser('gif', 'EasyRdf_Serialiser_GraphViz');
EasyRdf_Format::registerSerialiser('png', 'EasyRdf_Serialiser_GraphViz');
EasyRdf_Format::registerSerialiser('svg', 'EasyRdf_Serialiser_GraphViz');
}
/**
* Parse an RDF/XML document into an EasyRdf_Graph
*
* @param object EasyRdf_Graph $graph the graph to load the data into
* @param string $data the RDF document data
* @param string $format the format of the input data
* @param string $baseUri the base URI of the data being parsed
* @return boolean true if parsing was successful
*/
public function parse($graph, $data, $format, $baseUri)
{
parent::checkParseParams($graph, $data, $format, $baseUri);
if ($format != 'rdfxml') {
throw new EasyRdf_Exception("EasyRdf_Parser_RdfXml does not support: {$format}");
}
$this->init($graph, $baseUri);
$this->resetBnodeMap();
/* xml parser */
$this->initXMLParser();
/* parse */
if (!xml_parse($this->_xmlParser, $data, false)) {
throw new EasyRdf_Exception('XML error: "' . xml_error_string(xml_get_error_code($this->_xmlParser)) . '" at line ' . xml_get_current_line_number($this->_xmlParser));
}
xml_parser_free($this->_xmlParser);
// Success
return true;
}
}
EasyRdf_Format::registerParser('rdfxml', 'EasyRdf_Parser_RdfXml');
* can have resource URIs replaced with text based labels and using
* 'Only Labelled' option, only the resources and properties with
* a label will be displayed.
*
* Rending a graph to an image will only work if you have the
* GraphViz 'dot' command installed.
*
* @package EasyRdf
* @copyright Copyright (c) 2012-2013 Nicholas J Humfrey
* @license http://unlicense.org/
*/
set_include_path(get_include_path() . PATH_SEPARATOR . '../lib/');
require_once "EasyRdf.php";
require_once "html_tag_helpers.php";
$formats = array('PNG' => 'png', 'GIF' => 'gif', 'SVG' => 'svg');
$format = EasyRdf_Format::getFormat(isset($_REQUEST['format']) ? $_REQUEST['format'] : 'png');
// Construct a graph of three people
$graph = new EasyRdf_Graph();
$graph->set('foaf:knows', 'rdfs:label', 'knows');
$bob = $graph->resource('http://www.example.com/bob', 'foaf:Person');
$alice = $graph->resource('http://www.example.com/alice', 'foaf:Person');
$carol = $graph->resource('http://www.example.com/carol', 'foaf:Person');
$bob->set('foaf:name', 'Bob');
$alice->set('foaf:name', 'Alice');
$carol->set('foaf:name', 'Carol');
$bob->add('foaf:knows', $alice);
$bob->add('foaf:knows', $carol);
$alice->add('foaf:knows', $bob);
$alice->add('foaf:knows', $carol);
// Create a GraphViz serialiser
$gv = new EasyRdf_Serialiser_GraphViz();
public function parse($graph, $data, $format, $baseUri)
{
parent::checkParseParams($graph, $data, $format, $baseUri);
if ($format != 'php') {
throw new EasyRdf_Exception("EasyRdf_Parser_RdfPhp does not support: {$format}");
}
// Reset the bnode mapping
$this->resetBnodeMap();
foreach ($data as $subject => $properties) {
if (substr($subject, 0, 2) === '_:') {
$subject = $this->remapBnode($graph, $subject);
} elseif (preg_match('/^\\w+$/', $subject)) {
# Cope with invalid RDF/JSON serialisations that
# put the node name in, without the _: prefix
# (such as net.fortytwo.sesametools.rdfjson)
$subject = $this->remapBnode($graph, $subject);
}
foreach ($properties as $property => $objects) {
foreach ($objects as $object) {
if ($object['type'] === 'bnode') {
$object['value'] = $this->remapBnode($graph, $object['value']);
}
$graph->add($subject, $property, $object);
}
}
}
return true;
}
}
EasyRdf_Format::registerParser('php', 'EasyRdf_Parser_RdfPhp');
/** Make a query to the SPARQL endpoint
*
* SELECT and ASK queries will return an object of type
* EasyRdf_Sparql_Result.
*
* CONSTRUCT and DESCRIBE queries will return an object
* of type EasyRdf_Graph.
*
* @param string $query The query string to be executed
* @return object EasyRdf_Sparql_Result|EasyRdf_Graph Result of the query.
*/
public function query($query)
{
# Add namespaces to the queryString
$prefixes = '';
foreach (EasyRdf_Namespace::namespaces() as $prefix => $uri) {
if (strpos($query, "{$prefix}:") !== false and strpos($query, "PREFIX {$prefix}:") === false) {
$prefixes .= "PREFIX {$prefix}: <{$uri}>\n";
}
}
$client = EasyRdf_Http::getDefaultHttpClient();
$client->resetParameters();
$client->setUri($this->_uri);
$client->setMethod('GET');
$accept = EasyRdf_Format::getHttpAcceptHeader(array('application/sparql-results+json' => 1.0, 'application/sparql-results+xml' => 0.8));
$client->setHeaders('Accept', $accept);
$client->setParameterGet('query', $prefixes . $query);
$response = $client->request();
if ($response->isSuccessful()) {
$type = $response->getHeader('Content-Type');
if (strpos($type, 'application/sparql-results') === 0) {
return new EasyRdf_Sparql_Result($response->getBody(), $type);
} else {
return new EasyRdf_Graph($this->_uri, $response->getBody(), $type);
}
} else {
throw new EasyRdf_Exception("HTTP request for SPARQL query failed: " . $response->getBody());
}
}
<> a ldp:DirectContainer, foaf:Document ;
foaf:primaryTopic :dataset ;
ldp:membershipResource :dataset ;
ldp:hasMemberRelation void:dataDump ;
ldp:insertedContentRelation foaf:primaryTopic ;
.
:dataset a void:Dataset, prov:Entity ;
prov:wasGeneratedBy [
a prov:Activity ;
prov:used <{queryResource}> ;
prov:wasAssociatedWith :sparqlServerUser
]
.
:sparqlServerUser a foaf:Agent;
foaf:account [
a foaf:OnlineAccount ;
foaf:accountServiceHomepage <{endpoint}> ;
foaf:accountname "{username}" ;
]
.
';
}
// fix a bug of Easy RDF
EasyRdf_Format::register('turtle', 'Turtle Terse RDF Triple Language', 'http://www.w3.org/TR/turtle/', array('text/turtle' => 1.0, 'application/turtle' => 0.7, 'application/x-turtle' => 0.7), array('ttl'));
$errorManager = BOTK\Core\ErrorManager::getInstance()->registerErrorHandler();
try {
echo BOTK\Core\EndPointFactory::make('MyRouter')->run();
} catch (Exception $e) {
echo $errorManager->render($e);
}
public function testParseFormatObject()
{
$format = EasyRdf_Format::getFormat('json');
$this->assertTrue($this->_parser->parse($this->_graph, $this->_data, $format, null));
}
}
$stream = librdf_parser_parse_string_as_stream($parser, $data, $rdfUri);
if (!$stream) {
throw new EasyRdf_Exception("Failed to parse RDF stream for: {$rdfUri}");
}
do {
$statement = librdf_stream_get_object($stream);
if ($statement) {
$subject = EasyRdf_Parser_Redland::nodeUriString(librdf_statement_get_subject($statement));
$predicate = EasyRdf_Parser_Redland::nodeUriString(librdf_statement_get_predicate($statement));
$object = EasyRdf_Parser_Redland::nodeToArray(librdf_statement_get_object($statement));
$graph->add($subject, $predicate, $object);
}
} while (!librdf_stream_next($stream));
$errorCount = $this->parserErrorCount($parser);
if ($errorCount) {
throw new EasyRdf_Exception("{$errorCount} errors while parsing.");
}
librdf_free_uri($rdfUri);
librdf_free_stream($stream);
librdf_free_parser($parser);
// Success
return true;
}
}
## FIXME: do this automatically
EasyRdf_Format::registerParser('rdfxml', 'EasyRdf_Parser_Redland');
EasyRdf_Format::registerParser('turtle', 'EasyRdf_Parser_Redland');
EasyRdf_Format::registerParser('ntriples', 'EasyRdf_Parser_Redland');
EasyRdf_Format::registerParser('rdfa', 'EasyRdf_Parser_Redland');
print label_tag('output_format', 'Output Format: ') . select_tag('output_format', $output_format_options) . "<br />\n";
print label_tag('raw', 'Raw Output: ') . check_box_tag('raw') . "<br />\n";
print reset_tag() . submit_tag();
print form_end_tag();
print "</div>\n";
}
if (isset($_REQUEST['uri']) or isset($_REQUEST['data'])) {
// Parse the input
$graph = new EasyRdf_Graph($_REQUEST['uri']);
if (empty($_REQUEST['data'])) {
$graph->load($_REQUEST['uri'], $_REQUEST['input_format']);
} else {
$graph->parse($_REQUEST['data'], $_REQUEST['input_format'], $_REQUEST['uri']);
}
// Lookup the output format
$format = EasyRdf_Format::getFormat($_REQUEST['output_format']);
// Serialise to the new output format
$output = $graph->serialise($format);
if (!is_scalar($output)) {
$output = var_export($output, true);
}
// Send the output back to the client
if (isset($_REQUEST['raw'])) {
header('Content-Type: ' . $format->getDefaultMimeType());
print $output;
} else {
print '<pre>' . htmlspecialchars($output) . '</pre>';
}
}
if (!isset($_REQUEST['raw'])) {
print "</body>\n";
}
/**
* Serialise an EasyRdf_Graph into RDF format of choice.
*
* @param object EasyRdf_Graph $graph An EasyRdf_Graph object.
* @param string $format The name of the format to convert to.
* @return string The RDF in the new desired format.
*/
public function serialise($graph, $format)
{
parent::checkSerialiseParams($graph, $format);
if (array_key_exists($format, self::$_supportedTypes)) {
$className = self::$_supportedTypes[$format];
} else {
throw new EasyRdf_Exception("EasyRdf_Serialiser_Arc does not support: {$format}");
}
$serialiser = ARC2::getSer($className);
if ($serialiser) {
return $serialiser->getSerializedIndex(parent::serialise($graph, 'php'));
} else {
throw new EasyRdf_Exception("ARC2 failed to get a {$className} serialiser.");
}
}
}
# FIXME: to this automatically
EasyRdf_Format::register('posh', 'poshRDF');
EasyRdf_Format::registerSerialiser('ntriples', 'EasyRdf_Serialiser_Arc');
EasyRdf_Format::registerSerialiser('posh', 'EasyRdf_Serialiser_Arc');
EasyRdf_Format::registerSerialiser('rdfxml', 'EasyRdf_Serialiser_Arc');
EasyRdf_Format::registerSerialiser('turtle', 'EasyRdf_Serialiser_Arc');
* supported input and output formats. These options are then
* displayed on the HTML form.
*
* The input data is loaded or parsed into an EasyRdf_Graph.
* That graph is than outputted again in the desired output format.
*
* @package EasyRdf
* @copyright Copyright (c) 2009-2011 Nicholas J Humfrey
* @license http://unlicense.org/
*/
set_include_path(get_include_path() . PATH_SEPARATOR . '../lib/');
require_once "EasyRdf.php";
require_once "html_tag_helpers.php";
$input_format_options = array('Guess' => 'guess');
$output_format_options = array();
foreach (EasyRdf_Format::getFormats() as $format) {
if ($format->getSerialiserClass()) {
$output_format_options[$format->getLabel()] = $format->getName();
}
if ($format->getParserClass()) {
$input_format_options[$format->getLabel()] = $format->getName();
}
}
?>
<html>
<head><title>EasyRdf Converter</title></head>
<body>
<h1>EasyRdf Converter</h1>
<div style="margin: 10px">
<?php
/* not defined => ignore */
}
/**
* Serialise an EasyRdf_Graph into N-Triples
*
* @param object EasyRdf_Graph $graph An EasyRdf_Graph object.
* @param string $format The name of the format to convert to.
* @return string The RDF in the new desired format.
*/
public function serialise($graph, $format)
{
parent::checkSerialiseParams($graph, $format);
if ($format != 'ntriples') {
throw new EasyRdf_Exception("EasyRdf_Serialiser_Ntriples does not support: {$format}");
}
$nt = '';
foreach ($graph->resources() as $resource) {
foreach ($resource->propertyUris() as $property) {
$objects = $resource->all($property);
foreach ($objects as $object) {
$nt .= $this->ntriplesResource($resource) . " ";
$nt .= "<" . $this->escape($property) . "> ";
$nt .= $this->ntriplesObject($object) . " .\n";
}
}
}
return $nt;
}
}
EasyRdf_Format::registerSerialiser('ntriples', 'EasyRdf_Serialiser_Ntriples');
/** Serialise the graph into RDF
*
* @param string $format The format to serialise to
* @return mixed The serialised graph
*/
public function serialise($format)
{
$format = EasyRdf_Format::getFormat($format);
$serialiser = $format->newSerialiser();
return $serialiser->serialise($this, $format->getName());
}
public function __construct()
{
require_once 'arc/ARC2.php';
}
/**
* Serialise an EasyRdf_Graph into RDF format of choice.
*
* @param EasyRdf_Graph $graph An EasyRdf_Graph object.
* @param string $format The name of the format to convert to.
* @param array $options
* @throws EasyRdf_Exception
* @return string The RDF in the new desired format.
*/
public function serialise($graph, $format, array $options = array())
{
parent::checkSerialiseParams($graph, $format);
if (array_key_exists($format, self::$supportedTypes)) {
$className = self::$supportedTypes[$format];
} else {
throw new EasyRdf_Exception("EasyRdf_Serialiser_Arc does not support: {$format}");
}
$serialiser = ARC2::getSer($className);
if ($serialiser) {
return $serialiser->getSerializedIndex(parent::serialise($graph, 'php'));
} else {
throw new EasyRdf_Exception("ARC2 failed to get a {$className} serialiser.");
}
}
}
EasyRdf_Format::register('posh', 'poshRDF');
