Merge pull request 'Make UniqueNamer->order public to satisfy usage in JsonLdProcessor' (#4) from bug/13265-uniquenamer-order into master

Reviewed-on: #4

.travis.yml

@@ -1,14 +0,0 @@
-language: php
-php:
-  - 5.5
-  - 5.4
-  - 5.3
-# download test suite and run tests... submodule? meta testing project with
-# all of the reference implementations?
-script: 
-  - git clone https://github.com/json-ld/json-ld.org.git spec
-  - phpunit test.php -d spec/test-suite
-notifications:
-  email:
-    on_success: change
-    on_failure: change

README.md

@@ -1,27 +1,29 @@
+php-json-ld
+===========
+
 Introduction
 ------------
 
-JSON, as specified in RFC4627, is a simple language for representing
+This library is an implementation of the [JSON-LD][] specification in [PHP][].
+
+JSON, as specified in [RFC7159][], is a simple language for representing
 objects on the Web. Linked Data is a way of describing content across
 different documents or Web sites. Web resources are described using
 IRIs, and typically are dereferencable entities that may be used to find
-more information, creating a "Web of Knowledge". JSON-LD is intended to
-be a simple publishing method for expressing not only Linked Data in
+more information, creating a "Web of Knowledge". [JSON-LD][] is intended
+to be a simple publishing method for expressing not only Linked Data in
 JSON, but for adding semantics to existing JSON.
 
-This library is an implementation of the [JSON-LD] specification
-in [PHP].
-
 JSON-LD is designed as a light-weight syntax that can be used to express
 Linked Data. It is primarily intended to be a way to express Linked Data
-in Javascript and other Web-based programming environments. It is also
+in JavaScript and other Web-based programming environments. It is also
 useful when building interoperable Web Services and when storing Linked
 Data in JSON-based document storage engines. It is practical and
 designed to be as simple as possible, utilizing the large number of JSON
 parsers and existing code that is in use today. It is designed to be
-able to express key-value pairs, RDF data, RDFa [RDFA-CORE] data,
-Microformats [MICROFORMATS] data, and Microdata [MICRODATA]. That is, it
-supports every major Web-based structured data model in use today.
+able to express key-value pairs, RDF data, [RDFa][] data,
+[Microformats][] data, and [Microdata][]. That is, it supports every
+major Web-based structured data model in use today.
 
 The syntax does not require many applications to change their JSON, but
 easily add meaning by adding context in a way that is either in-band or
@@ -88,40 +90,92 @@ $flattened = jsonld_flatten($doc);
 $framed = jsonld_frame($doc, $frame);
 // document transformed into a particular tree structure per the given frame
 
-// normalize a document
-$normalized = jsonld_normalize($doc, array('format' => 'application/nquads'));
+// normalize a document using the RDF Dataset Normalization Algorithm
+// (URDNA2015), see: http://json-ld.github.io/normalization/spec/
+$normalized = jsonld_normalize(
+  $doc, array('algorithm' => 'URDNA2015', 'format' => 'application/nquads'));
 // normalized is a string that is a canonical representation of the document
-// that can be used for hashing
+// that can be used for hashing, comparison, etc.
+
+// force HTTPS-only context loading:
+// use built-in secure document loader
+jsonld_set_document_loader('jsonld_default_secure_document_loader');
+
+// set a default custom document loader
+jsonld_set_document_loader('my_custom_doc_loader');
+
+// a custom loader that demonstrates using a simple in-memory mock for
+// certain contexts before falling back to the default loader
+// note: if you want to set this loader as the new default, you'll need to
+// store the previous default in another variable first and access that inside
+// the loader
+global $mocks;
+$mocks = array('http://example.com/mycontext' => (object)array(
+  'hombre' => 'http://schema.org/name'));
+function mock_load($url) {
+  global $jsonld_default_load_document, $mocks;
+  if(isset($mocks[$url])) {
+    // return a "RemoteDocument", it has these three properties:
+    return (object)array(
+      'contextUrl' => null,
+      'document' => $mocks[$url],
+      'documentUrl' => $url);
+  }
+  // use default loader
+  return call_user_func($jsonld_default_load_document, $url);
+}
+
+// use the mock loader for just this call, witout modifying the default one
+$compacted = jsonld_compact($foo, 'http://example.com/mycontext', array(
+  'documentLoader' => 'mock_load'));
+
+// a custom loader that uses a simplistic in-memory cache (no invalidation)
+global $cache;
+$cache = array();
+function cache_load($url) {
+  global $jsonld_default_load_document, $cache;
+  if(isset($cache[$url])) {
+    return $cache[$url];
+  }
+  // use default loader
+  $doc = call_user_func($jsonld_default_load_document, $url);
+  $cache[$url] = $doc;
+  return $doc;
+}
+
+// use the cache loader for just this call, witout modifying the default one
+$compacted = jsonld_compact($foo, 'http://schema.org', array(
+  'documentLoader' => 'cache_load'));
 ```
 
-Commercial Support
-------------------
-
-Commercial support for this library is available upon request from
-Digital Bazaar: support@digitalbazaar.com
-
 Source
 ------
 
-The source code for the PHP implementation of the JSON-LD API
-is available at:
+The source code for the PHP implementation of the JSON-LD API is available at:
 
-http://github.com/digitalbazaar/php-json-ld
+https://git.friendi.ca/friendica/php-json-ld
+
+Tests
+-----
 
 This library includes a sample testing utility which may be used to verify
 that changes to the processor maintain the correct output.
 
 To run the sample tests you will need to get the test suite files by cloning
-the [json-ld.org repository][json-ld.org] hosted on GitHub.
+the `json-ld.org` and `normalization` repositories hosted on GitHub:
 
-https://github.com/json-ld/json-ld.org
+- https://github.com/json-ld/json-ld.org
+- https://github.com/json-ld/normalization
 
-Then run the PHPUnit test.php application and point it at the directory
-containing the tests.
+Then run the PHPUnit test.php application and point it at the directories
+containing the tests:
 
-    phpunit test.php -d {PATH_TO_JSON_LD_ORG/test-suite}
+    phpunit --group json-ld.org test.php -d {PATH_TO_JSON_LD_ORG/test-suite}
+    phpunit --group normalization test.php -d {PATH_TO_NORMALIZATION/tests}
 
-[PHP]: http://php.net
 [JSON-LD]: http://json-ld.org/
-[json-ld.org]: https://github.com/json-ld/json-ld.org
-
+[Microdata]: http://www.w3.org/TR/microdata/
+[Microformats]: http://microformats.org/
+[PHP]: http://php.net
+[RDFa]: http://www.w3.org/TR/rdfa-core/
+[RFC7159]: http://tools.ietf.org/html/rfc7159

composer.json

@@ -0,0 +1,33 @@
+{
+    "name": "friendica/json-ld",
+    "type": "library",
+    "description": "A JSON-LD Processor and API implementation in PHP.",
+    "keywords": [
+        "JSON",
+        "Linked Data",
+        "JSON-LD",
+        "RDF",
+        "Semantic Web",
+        "jsonld"
+    ],
+    "homepage": "https://git.friendi.ca/friendica/php-json-ld",
+    "license": "BSD-3-Clause",
+    "authors": [
+        {
+            "name": "Digital Bazaar, Inc.",
+            "email": "support@digitalbazaar.com",
+            "homepage": "http://digitalbazaar.com/"
+        },
+        {
+            "name": "Friendica Team",
+            "homepage": "https://friendi.ca/"
+        }
+    ],
+    "require": {
+        "php": ">=5.4.0",
+        "ext-json": "*"
+    },
+    "autoload": {
+        "files": ["jsonld.php"]
+    }
+}

test.php

@@ -1,4 +1,5 @@
 <?php
+
 /**
  * PHP unit tests for JSON-LD.
  *
@@ -8,14 +9,16 @@
  */
 require_once('jsonld.php');
 
-class JsonLdTestCase extends PHPUnit_Framework_TestCase {
+class JsonLdTestCase extends PHPUnit_Framework_TestCase
+{
 	/**
 	 * Runs this test case. Overridden to attach to EARL report w/o need for
 	 * an external XML configuration file.
 	 *
 	 * @param PHPUnit_Framework_TestResult $result the test result.
 	 */
-  public function run(PHPUnit_Framework_TestResult $result = NULL) {
+	public function run(PHPUnit_Framework_TestResult $result = NULL)
+	{
 		global $EARL;
 		$EARL->attach($result);
 		$this->result = $result;
@@ -28,13 +31,15 @@ class JsonLdTestCase extends PHPUnit_Framework_TestCase {
 	 * @param JsonLdTest $test the test to run.
 	 *
 	 * @group expand
+	 * @group json-ld.org
 	 * @dataProvider expandProvider
 	 */
-  public function testExpand($test) {
+	public function testExpand($test)
+	{
 		$this->test = $test;
 		$input = $test->readUrl('input');
 		$options = $test->createOptions();
-    $test->run('jsonld_expand', array($input, $options));
+		$test->run('jsonld_expand', [$input, $options]);
 	}
 
 	/**
@@ -43,14 +48,16 @@ class JsonLdTestCase extends PHPUnit_Framework_TestCase {
 	 * @param JsonLdTest $test the test to run.
 	 *
 	 * @group compact
+	 * @group json-ld.org
 	 * @dataProvider compactProvider
 	 */
-  public function testCompact($test) {
+	public function testCompact($test)
+	{
 		$this->test = $test;
 		$input = $test->readUrl('input');
 		$context = $test->readProperty('context');
 		$options = $test->createOptions();
-    $test->run('jsonld_compact', array($input, $context, $options));
+		$test->run('jsonld_compact', [$input, $context, $options]);
 	}
 
 	/**
@@ -59,14 +66,16 @@ class JsonLdTestCase extends PHPUnit_Framework_TestCase {
 	 * @param JsonLdTest $test the test to run.
 	 *
 	 * @group flatten
+	 * @group json-ld.org
 	 * @dataProvider flattenProvider
 	 */
-  public function testFlatten($test) {
+	public function testFlatten($test)
+	{
 		$this->test = $test;
 		$input = $test->readUrl('input');
 		$context = $test->readProperty('context');
 		$options = $test->createOptions();
-    $test->run('jsonld_flatten', array($input, $context, $options));
+		$test->run('jsonld_flatten', [$input, $context, $options]);
 	}
 
 	/**
@@ -75,13 +84,15 @@ class JsonLdTestCase extends PHPUnit_Framework_TestCase {
 	 * @param JsonLdTest $test the test to run.
 	 *
 	 * @group toRdf
+	 * @group json-ld.org
 	 * @dataProvider toRdfProvider
 	 */
-  public function testToRdf($test) {
+	public function testToRdf($test)
+	{
 		$this->test = $test;
 		$input = $test->readUrl('input');
-    $options = $test->createOptions(array('format' => 'application/nquads'));
-    $test->run('jsonld_to_rdf', array($input, $options));
+		$options = $test->createOptions(['format' => 'application/nquads']);
+		$test->run('jsonld_to_rdf', [$input, $options]);
 	}
 
 	/**
@@ -90,13 +101,15 @@ class JsonLdTestCase extends PHPUnit_Framework_TestCase {
 	 * @param JsonLdTest $test the test to run.
 	 *
 	 * @group fromRdf
+	 * @group json-ld.org
 	 * @dataProvider fromRdfProvider
 	 */
-  public function testFromRdf($test) {
+	public function testFromRdf($test)
+	{
 		$this->test = $test;
 		$input = $test->readProperty('input');
-    $options = $test->createOptions(array('format' => 'application/nquads'));
-    $test->run('jsonld_from_rdf', array($input, $options));
+		$options = $test->createOptions(['format' => 'application/nquads']);
+		$test->run('jsonld_from_rdf', [$input, $options]);
 	}
 
 	/**
@@ -105,14 +118,16 @@ class JsonLdTestCase extends PHPUnit_Framework_TestCase {
 	 * @param JsonLdTest $test the test to run.
 	 *
 	 * @group frame
+	 * @group json-ld.org
 	 * @dataProvider frameProvider
 	 */
-  public function testFrame($test) {
+	public function testFrame($test)
+	{
 		$this->test = $test;
 		$input = $test->readUrl('input');
 		$frame = $test->readProperty('frame');
 		$options = $test->createOptions();
-    $test->run('jsonld_frame', array($input, $frame, $options));
+		$test->run('jsonld_frame', [$input, $frame, $options]);
 	}
 
 	/**
@@ -121,73 +136,142 @@ class JsonLdTestCase extends PHPUnit_Framework_TestCase {
 	 * @param JsonLdTest $test the test to run.
 	 *
 	 * @group normalize
+	 * @group json-ld.org
 	 * @dataProvider normalizeProvider
 	 */
-  public function testNormalize($test) {
+	public function testNormalize($test)
+	{
 		$this->test = $test;
 		$input = $test->readUrl('input');
-    $options = $test->createOptions(array('format' => 'application/nquads'));
-    $test->run('jsonld_normalize', array($input, $options));
+		$options = $test->createOptions(['format' => 'application/nquads']);
+		$test->run('jsonld_normalize', [$input, $options]);
 	}
 
-  public function expandProvider() {
+	/**
+	 * Tests URGNA2012 normalization.
+	 *
+	 * @param JsonLdTest $test the test to run.
+	 *
+	 * @group normalize
+	 * @group normalization
+	 * @dataProvider urgna2012Provider
+	 */
+	public function testUrgna2012($test)
+	{
+		$this->test = $test;
+		$input = $test->readProperty('action');
+		$options = $test->createOptions([
+			'algorithm' => 'URGNA2012',
+			'inputFormat' => 'application/nquads',
+			'format' => 'application/nquads']);
+		$test->run('jsonld_normalize', [$input, $options]);
+	}
+
+	/**
+	 * Tests URDNA2015 normalization.
+	 *
+	 * @param JsonLdTest $test the test to run.
+	 *
+	 * @group normalize
+	 * @group normalization
+	 * @dataProvider urdna2015Provider
+	 */
+	public function testUrdna2015($test)
+	{
+		$this->test = $test;
+		$input = $test->readProperty('action');
+		$options = $test->createOptions([
+			'algorithm' => 'URDNA2015',
+			'inputFormat' => 'application/nquads',
+			'format' => 'application/nquads']);
+		$test->run('jsonld_normalize', [$input, $options]);
+	}
+
+	public function expandProvider()
+	{
 		return new JsonLdTestIterator('jld:ExpandTest');
 	}
 
-  public function compactProvider() {
+	public function compactProvider()
+	{
 		return new JsonLdTestIterator('jld:CompactTest');
 	}
 
-  public function flattenProvider() {
+	public function flattenProvider()
+	{
 		return new JsonLdTestIterator('jld:FlattenTest');
 	}
 
-  public function toRdfProvider() {
+	public function toRdfProvider()
+	{
 		return new JsonLdTestIterator('jld:ToRDFTest');
 	}
 
-  public function fromRdfProvider() {
+	public function fromRdfProvider()
+	{
 		return new JsonLdTestIterator('jld:FromRDFTest');
 	}
 
-  public function normalizeProvider() {
+	public function normalizeProvider()
+	{
 		return new JsonLdTestIterator('jld:NormalizeTest');
 	}
 
-  public function frameProvider() {
+	public function frameProvider()
+	{
 		return new JsonLdTestIterator('jld:FrameTest');
 	}
+
+	public function urgna2012Provider()
+	{
+		return new JsonLdTestIterator('rdfn:Urgna2012EvalTest');
+	}
+
+	public function urdna2015Provider()
+	{
+		return new JsonLdTestIterator('rdfn:Urdna2015EvalTest');
+	}
 }
 
-class JsonLdManifest {
-  public function __construct($data, $filename) {
+class JsonLdManifest
+{
+	public function __construct($data, $filename)
+	{
 		$this->data = $data;
 		$this->filename = $filename;
 		$this->dirname = dirname($filename);
 	}
 
-  public function load(&$tests) {
-    $sequence = JsonLdProcessor::getValues($this->data, 'sequence');
-    foreach($sequence as $entry) {
+	public function load(&$tests)
+	{
+		$entries = array_merge(
+		JsonLdProcessor::getValues($this->data, 'sequence'), JsonLdProcessor::getValues($this->data, 'entries'));
+		$includes = JsonLdProcessor::getValues($this->data, 'include');
+		foreach ($includes as $include) {
+			array_push($entries, $include . '.jsonld');
+		}
+		foreach ($entries as $entry) {
 			if (is_string($entry)) {
 				$filename = join(
-          DIRECTORY_SEPARATOR, array($this->dirname, $entry));
+				DIRECTORY_SEPARATOR, [$this->dirname, $entry]);
 				$entry = Util::readJson($filename);
 			} else {
 				$filename = $this->filename;
 			}
 
-      if(JsonLdProcessor::hasValue($entry, '@type', 'mf:Manifest')) {
+			if (JsonLdProcessor::hasValue($entry, '@type', 'mf:Manifest') ||
+			JsonLdProcessor::hasValue($entry, 'type', 'mf:Manifest')) {
 				// entry is another manifest
 				$manifest = new JsonLdManifest($entry, $filename);
 				$manifest->load($tests);
 			} else {
 				// assume entry is a test
 				$test = new JsonLdTest($this, $entry, $filename);
-        $types = JsonLdProcessor::getValues($test->data, '@type');
+				$types = array_merge(
+				JsonLdProcessor::getValues($test->data, '@type'), JsonLdProcessor::getValues($test->data, 'type'));
 				foreach ($types as $type) {
 					if (!isset($tests[$type])) {
-            $tests[$type] = array();
+						$tests[$type] = [];
 					}
 					$tests[$type][] = $test;
 				}
@@ -196,33 +280,72 @@ class JsonLdManifest {
 	}
 }
 
-class JsonLdTest {
-  public function __construct($manifest, $data, $filename) {
+class JsonLdTest
+{
+	public function __construct($manifest, $data, $filename)
+	{
 		$this->manifest = $manifest;
 		$this->data = $data;
 		$this->filename = $filename;
 		$this->dirname = dirname($filename);
 		$this->isPositive = JsonLdProcessor::hasValue(
-      $data, '@type', 'jld:PositiveEvaluationTest');
+		$data, '@type', 'jld:PositiveEvaluationTest') ||
+		JsonLdProcessor::hasValue(
+		$data, 'type', 'jld:PositiveEvaluationTest');
 		$this->isNegative = JsonLdProcessor::hasValue(
-      $data, '@type', 'jld:NegativeEvaluationTest');
+		$data, '@type', 'jld:NegativeEvaluationTest') ||
+		JsonLdProcessor::hasValue(
+		$data, 'type', 'jld:NegativeEvaluationTest');
 
 		// generate test name
-    $this->name = $manifest->data->name . ' ' . substr($data->{'@id'}, 2) .
-      ' - ' . $this->data->name;
+		if (isset($manifest->data->name)) {
+			$manifestLabel = $manifest->data->name;
+		} else if (isset($manifest->data->label)) {
+			$manifestLabel = $manifest->data->label;
+		} else {
+			$manifestLabel = 'UNNAMED';
+		}
+		if (isset($this->data->id)) {
+			$testId = $this->data->id;
+		} else {
+			$testId = $this->data->{'@id'};
+		}
+		if (isset($this->data->name)) {
+			$testLabel = $this->data->name;
+		} else if (isset($this->data->label)) {
+			$testLabel = $this->data->label;
+		} else {
+			$testLabel = 'UNNAMED';
+		}
+
+		$this->name = $manifestLabel . ' ' . $testId . ' - ' . $testLabel;
 
 		// expand @id and input base
+		if (isset($manifest->data->baseIri)) {
 			$data->{'@id'} = ($manifest->data->baseIri .
 			basename($manifest->filename) . $data->{'@id'});
 			$this->base = $manifest->data->baseIri . $data->input;
 		}
+	}
 
-  public function run($fn, $params) {
+	private function _getResultProperty()
+	{
+		if (isset($this->data->expect)) {
+			return 'expect';
+		} else if (isset($this->data->result)) {
+			return 'result';
+		} else {
+			throw new Exception('No test result property found.');
+		}
+	}
+
+	public function run($fn, $params)
+	{
 		// read expected data
 		if ($this->isNegative) {
 			$this->expected = $this->data->expect;
 		} else {
-      $this->expected = $this->readProperty('expect');
+			$this->expected = $this->readProperty($this->_getResultProperty());
 		}
 
 		try {
@@ -232,70 +355,81 @@ class JsonLdTest {
 			}
 			PHPUnit_Framework_TestCase::assertEquals($this->expected, $this->actual);
 		} catch (Exception $e) {
-      if($this->isPositive) {
+			// assume positive test
+			if ($this->isNegative) {
+				$this->actual = $this->getJsonLdErrorCode($e);
+				PHPUnit_Framework_TestCase::assertEquals(
+				$this->expected, $this->actual);
+			} else {
 				throw $e;
 			}
-      $this->actual = $this->getJsonLdErrorCode($e);
-      PHPUnit_Framework_TestCase::assertEquals($this->expected, $this->actual);
 		}
 	}
 
-  public function readUrl($property) {
+	public function readUrl($property)
+	{
 		if (!property_exists($this->data, $property)) {
 			return null;
 		}
 		return $this->manifest->data->baseIri . $this->data->{$property};
 	}
 
-  public function readProperty($property) {
+	public function readProperty($property)
+	{
 		$data = $this->data;
 		if (!property_exists($data, $property)) {
 			return null;
 		}
 		$filename = join(
-      DIRECTORY_SEPARATOR, array($this->dirname, $data->{$property}));
+		DIRECTORY_SEPARATOR, [$this->dirname, $data->{$property}]);
 		$extension = pathinfo($filename, PATHINFO_EXTENSION);
 		if ($extension === 'jsonld') {
 			return Util::readJson($filename);
 		}
+
 		return Util::readFile($filename);
 	}
 
-  public function createOptions($opts=array()) {
-    $http_options = array(
-      'contentType', 'httpLink', 'httpStatus', 'redirectTo');
+	public function createOptions($opts = [])
+	{
+		$http_options = [
+			'contentType', 'httpLink', 'httpStatus', 'redirectTo'];
 		$test_options = (property_exists($this->data, 'option') ?
-      $this->data->option : array());
-    $options = array();
+		$this->data->option : []);
+		$options = [];
 		foreach ($test_options as $k => $v) {
 			if (!in_array($k, $http_options)) {
 				$options[$k] = $v;
 			}
 		}
+
 		$options['documentLoader'] = $this->createDocumentLoader();
 		$options = array_merge($options, $opts);
 		if (isset($options['expandContext'])) {
 			$filename = join(
-        DIRECTORY_SEPARATOR, array($this->dirname, $options['expandContext']));
+			DIRECTORY_SEPARATOR, [$this->dirname, $options['expandContext']]);
 			$options['expandContext'] = Util::readJson($filename);
 		}
+
 		return $options;
 	}
 
-  public function createDocumentLoader() {
+	public function createDocumentLoader()
+	{
 		$base = 'http://json-ld.org/test-suite';
 		$test = $this;
 
 		$load_locally = function($url) use ($test, $base) {
-      $doc = (object)array(
-        'contextUrl' => null, 'documentUrl' => $url, 'document' => null);
+			$doc = (object) [
+				'contextUrl' => null, 'documentUrl' => $url, 'document' => null];
 			$options = (property_exists($test->data, 'option') ?
 			$test->data->option : null);
 			if ($options and $url === $test->base) {
 				if (property_exists($options, 'redirectTo') &&
 					property_exists($options, 'httpStatus') &&
-          $options->httpStatus >= '300') {
-          $doc->documentUrl = ($test->manifest->data->{'baseIri'} .
+					$options->httpStatus >= '300'
+				) {
+					$doc->documentUrl = ($test->manifest->data->baseIri .
 					$options->redirectTo);
 				} else if (property_exists($options, 'httpLink')) {
 					$content_type = (property_exists($options, 'contentType') ?
@@ -304,38 +438,51 @@ class JsonLdTest {
 					if (!$content_type && $extension === 'jsonld') {
 						$content_type = 'application/ld+json';
 					}
+
 					$link_header = $options->httpLink;
 					if (is_array($link_header)) {
 						$link_header = join(',', $link_header);
 					}
+
 					$link_header = jsonld_parse_link_header($link_header);
 					if (isset($link_header['http://www.w3.org/ns/json-ld#context'])) {
 						$link_header = $link_header['http://www.w3.org/ns/json-ld#context'];
 					} else {
 						$link_header = null;
 					}
+
 					if ($link_header && $content_type !== 'application/ld+json') {
 						if (is_array($link_header)) {
 							throw new Exception('multiple context link headers');
 						}
-            $doc->{'contextUrl'} = $link_header->target;
+						$doc->contextUrl = $link_header->target;
 					}
 				}
 			}
 			global $ROOT_MANIFEST_DIR;
-      $filename = $ROOT_MANIFEST_DIR .
-        substr($doc->{'documentUrl'}, strlen($base));
+			if (strpos($doc->documentUrl, ':') === false) {
+				$filename = join(
+				DIRECTORY_SEPARATOR, [
+					$ROOT_MANIFEST_DIR, $doc->documentUrl]);
+				$doc->documentUrl = 'file://' . $filename;
+			} else {
+				$filename = join(
+				DIRECTORY_SEPARATOR, [
+					$ROOT_MANIFEST_DIR, substr($doc->documentUrl, strlen($base))]);
+			}
+
 			try {
-        $doc->{'document'} = Util::readJson($filename);
+				$doc->document = Util::readJson($filename);
 			} catch (Exception $e) {
 				throw new Exception('loading document failed');
 			}
+
 			return $doc;
 		};
 
 		$local_loader = function($url) use ($test, $base, $load_locally) {
 			// always load remote-doc and non-base tests remotely
-      if(strpos($url, $base) !== 0 ||
+			if ((strpos($url, $base) !== 0 && strpos($url, ':') !== false) ||
 			$test->manifest->data->name === 'Remote document') {
 				return call_user_func('jsonld_default_document_loader', $url);
 			}
@@ -347,20 +494,25 @@ class JsonLdTest {
 		return $local_loader;
 	}
 
-  public function getJsonLdErrorCode($err) {
+	public function getJsonLdErrorCode($err)
+	{
 		if ($err instanceof JsonLdException) {
 			if ($err->getCode()) {
 				return $err->getCode();
 			}
+
 			if ($err->cause) {
 				return $this->getJsonLdErrorCode($err->cause);
 			}
 		}
+
 		return $err->getMessage();
 	}
+
 }
 
-class JsonLdTestIterator implements Iterator {
+class JsonLdTestIterator implements Iterator
+{
 	/**
 	 * The current test index.
 	 */
@@ -376,13 +528,15 @@ class JsonLdTestIterator implements Iterator {
 	 *
 	 * @param string $type the type of tests to iterate over.
 	 */
-  public function __construct($type) {
+	public function __construct($type)
+	{
 		global $TESTS;
 		if (isset($TESTS[$type])) {
 			$this->tests = $TESTS[$type];
 		} else {
-      $this->tests = array();
+			$this->tests = [];
 		}
+
 		$this->count = count($this->tests);
 	}
 
@@ -391,8 +545,9 @@ class JsonLdTestIterator implements Iterator {
 	 *
 	 * @return assoc the parameters for the next test.
 	 */
-  public function current() {
-    return array('test' => $this->tests[$this->index]);
+	public function current()
+	{
+		return ['test' => $this->tests[$this->index]];
 	}
 
 	/**
@@ -400,21 +555,24 @@ class JsonLdTestIterator implements Iterator {
 	 *
 	 * @return int the current test number.
 	 */
-  public function key() {
+	public function key()
+	{
 		return $this->index;
 	}
 
 	/**
 	 * Proceeds to the next test.
 	 */
-  public function next() {
+	public function next()
+	{
 		$this->index += 1;
 	}
 
 	/**
 	 * Rewinds to the first test.
 	 */
-  public function rewind() {
+	public function rewind()
+	{
 		$this->index = 0;
 	}
 
@@ -423,36 +581,38 @@ class JsonLdTestIterator implements Iterator {
 	 *
 	 * @return bool true if there are more tests to be run.
 	 */
-  public function valid() {
+	public function valid()
+	{
 		return $this->index < $this->count;
 	}
 }
 
-class EarlReport extends PHPUnit_Util_Printer
-  implements PHPUnit_Framework_TestListener {
-  public function __construct() {
+class EarlReport extends PHPUnit_Util_Printer implements PHPUnit_Framework_TestListener
+{
+	public function __construct()
+	{
 		$this->filename = null;
 		$this->attached = false;
-    $this->report = (object)array(
-      '@context' => (object)array(
+		$this->report = (object) [
+			'@context' => (object) [
 				'doap' => 'http://usefulinc.com/ns/doap#',
 				'foaf' => 'http://xmlns.com/foaf/0.1/',
 				'dc' => 'http://purl.org/dc/terms/',
 				'earl' => 'http://www.w3.org/ns/earl#',
 				'xsd' => 'http://www.w3.org/2001/XMLSchema#',
-        'doap:homepage' => (object)array('@type' => '@id'),
-        'doap:license' => (object)array('@type' => '@id'),
-        'dc:creator' => (object)array('@type' => '@id'),
-        'foaf:homepage' => (object)array('@type' => '@id'),
-        'subjectOf' => (object)array('@reverse' => 'earl:subject'),
-        'earl:assertedBy' => (object)array('@type' => '@id'),
-        'earl:mode' => (object)array('@type' => '@id'),
-        'earl:test' => (object)array('@type' => '@id'),
-        'earl:outcome' => (object)array('@type' => '@id'),
-        'dc:date' => (object)array('@type' => 'xsd:date')
-      ),
+				'doap:homepage' => (object) ['@type' => '@id'],
+				'doap:license' => (object) ['@type' => '@id'],
+				'dc:creator' => (object) ['@type' => '@id'],
+				'foaf:homepage' => (object) ['@type' => '@id'],
+				'subjectOf' => (object) ['@reverse' => 'earl:subject'],
+				'earl:assertedBy' => (object) ['@type' => '@id'],
+				'earl:mode' => (object) ['@type' => '@id'],
+				'earl:test' => (object) ['@type' => '@id'],
+				'earl:outcome' => (object) ['@type' => '@id'],
+				'dc:date' => (object) ['@type' => 'xsd:date']
+			],
 			'@id' => 'https://github.com/digitalbazaar/php-json-ld',
-      '@type' => array('doap:Project', 'earl:TestSubject', 'earl:Software'),
+			'@type' => ['doap:Project', 'earl:TestSubject', 'earl:Software'],
 			'doap:name' => 'php-json-ld',
 			'dc:title' => 'php-json-ld',
 			'doap:homepage' => 'https://github.com/digitalbazaar/php-json-ld',
@@ -460,18 +620,18 @@ class EarlReport extends PHPUnit_Util_Printer
 			'doap:description' => 'A JSON-LD processor for PHP',
 			'doap:programming-language' => 'PHP',
 			'dc:creator' => 'https://github.com/dlongley',
-      'doap:developer' => (object)array(
+			'doap:developer' => (object) [
 				'@id' => 'https://github.com/dlongley',
-        '@type' => array('foaf:Person', 'earl:Assertor'),
+				'@type' => ['foaf:Person', 'earl:Assertor'],
 				'foaf:name' => 'Dave Longley',
 				'foaf:homepage' => 'https://github.com/dlongley'
-      ),
-      'dc:date' => array(
+			],
+			'dc:date' => [
 				'@value' => gmdate('Y-m-d'),
 				'@type' => 'xsd:date'
-      ),
-      'subjectOf' => array()
-    );
+			],
+			'subjectOf' => []
+		];
 	}
 
 	/**
@@ -479,7 +639,8 @@ class EarlReport extends PHPUnit_Util_Printer
 	 *
 	 * @param PHPUnit_Framework_Test $result the result to attach to.
 	 */
-  public function attach(PHPUnit_Framework_TestResult $result) {
+	public function attach(PHPUnit_Framework_TestResult $result)
+	{
 		if (!$this->attached && $this->filename) {
 			$this->attached = true;
 			$result->addListener($this);
@@ -492,25 +653,28 @@ class EarlReport extends PHPUnit_Util_Printer
 	 * @param JsonLdTest $test the JsonLdTest for the assertion is for.
 	 * @param bool $passed whether or not the test passed.
 	 */
-  public function addAssertion($test, $passed) {
-    $this->report->{'subjectOf'}[] = (object)array(
+	public function addAssertion($test, $passed)
+	{
+		$this->report->{'subjectOf'}[] = (object) [
 			'@type' => 'earl:Assertion',
 			'earl:assertedBy' => $this->report->{'doap:developer'}->{'@id'},
 			'earl:mode' => 'earl:automatic',
 			'earl:test' => $test->data->{'@id'},
-      'earl:result' => (object)array(
+			'earl:result' => (object) [
 				'@type' => 'earl:TestResult',
 				'dc:date' => gmdate(DateTime::ISO8601),
 				'earl:outcome' => $passed ? 'earl:passed' : 'earl:failed'
-      )
-    );
+			]
+		];
+
 		return $this;
 	}
 
 	/**
 	 * Writes this EARL report to a file.
 	 */
-  public function flush() {
+	public function flush()
+	{
 		if ($this->filename) {
 			printf("\nWriting EARL report to: %s\n", $this->filename);
 			$fd = fopen($this->filename, 'w');
@@ -519,22 +683,31 @@ class EarlReport extends PHPUnit_Util_Printer
 		}
 	}
 
-  public function endTest(PHPUnit_Framework_Test $test, $time) {
+	public function endTest(PHPUnit_Framework_Test $test, $time)
+	{
 		$this->addAssertion($test->test, true);
 	}
 
 	public function addError(
-    PHPUnit_Framework_Test $test, Exception $e, $time) {
+	PHPUnit_Framework_Test $test, Exception $e, $time)
+	{
 		$this->addAssertion($test->test, false);
 	}
 
 	public function addFailure(
-    PHPUnit_Framework_Test $test,
-    PHPUnit_Framework_AssertionFailedError $e, $time) {
+	PHPUnit_Framework_Test $test, PHPUnit_Framework_AssertionFailedError $e, $time)
+	{
 		$this->addAssertion($test->test, false);
 		if ($test->result->shouldStop()) {
+			if (isset($test->test->name)) {
+				$name = $test->test->name;
+			} else if (isset($test->test->label)) {
+				$name = $test->test->label;
+			} else {
+				$name = 'UNNAMED';
+			}
 			printf("\n\nFAILED\n");
-      printf("Test: %s\n", $test->test->name);
+			printf("Test: %s\n", $name);
 			printf("Purpose: %s\n", $test->test->data->purpose);
 			printf("EXPECTED: %s\n", Util::jsonldEncode($test->test->expected));
 			printf("ACTUAL: %s\n", Util::jsonldEncode($test->test->actual));
@@ -542,41 +715,68 @@ class EarlReport extends PHPUnit_Util_Printer
 	}
 
 	public function addIncompleteTest(
-    PHPUnit_Framework_Test $test, Exception $e, $time) {
+	PHPUnit_Framework_Test $test, Exception $e, $time)
+	{
 		$this->addAssertion($test->test, false);
 	}
 
 	public function addRiskyTest(
-    PHPUnit_Framework_Test $test, Exception $e, $time) {}
-  public function addSkippedTest(
-    PHPUnit_Framework_Test $test, Exception $e, $time) {}
-  public function startTest(PHPUnit_Framework_Test $test) {}
-  public function startTestSuite(PHPUnit_Framework_TestSuite $suite) {}
-  public function endTestSuite(PHPUnit_Framework_TestSuite $suite) {}
+	PHPUnit_Framework_Test $test, Exception $e, $time)
+	{
+
 	}
 
-class Util {
-  public static function readFile($filename) {
+	public function addSkippedTest(
+	PHPUnit_Framework_Test $test, Exception $e, $time)
+	{
+
+	}
+
+	public function startTest(PHPUnit_Framework_Test $test)
+	{
+
+	}
+
+	public function startTestSuite(PHPUnit_Framework_TestSuite $suite)
+	{
+
+	}
+
+	public function endTestSuite(PHPUnit_Framework_TestSuite $suite)
+	{
+
+	}
+}
+
+class Util
+{
+	public static function readFile($filename)
+	{
 		$rval = @file_get_contents($filename);
 		if ($rval === false) {
 			throw new Exception('File read error: ' . $filename);
 		}
+
 		return $rval;
 	}
 
-  public static function readJson($filename) {
+	public static function readJson($filename)
+	{
 		$rval = json_decode(self::readFile($filename));
 		if ($rval === null) {
 			throw new Exception('JSON parse error');
 		}
+
 		return $rval;
 	}
 
-  public static function readNQuads($filename) {
+	public static function readNQuads($filename)
+	{
 		return self::readFile($filename);
 	}
 
-  public static function jsonldEncode($input) {
+	public static function jsonldEncode($input)
+	{
 		// newer PHP has a flag to avoid escaped '/'
 		if (defined('JSON_UNESCAPED_SLASHES')) {
 			$options = JSON_UNESCAPED_SLASHES;
@@ -588,21 +788,22 @@ class Util {
 			// use a simple string replacement of '\/' to '/'.
 			$json = str_replace('\\/', '/', json_encode($input));
 		}
+
 		return $json;
 	}
 }
 
 // tests to skip
-$SKIP_TESTS = array();
+$SKIP_TESTS = [];
 
 // root manifest directory
 $ROOT_MANIFEST_DIR;
 
 // parsed tests; keyed by type
-$TESTS = array();
+$TESTS = [];
 
 // parsed command line options
-$OPTIONS = array();
+$OPTIONS = [];
 
 // parse command line options
 global $argv;
@@ -623,11 +824,13 @@ for($i = 0; $i < $total; ++$i) {
 	$i += 1;
 	$OPTIONS[$arg] = $args[$i];
 }
+
 if (!isset($OPTIONS['-d'])) {
 	$dvar = 'path to json-ld.org/test-suite';
 	$evar = 'file to write EARL report to';
 	echo "php-json-ld Tests\n";
 	echo "Usage: phpunit test.php -d <$dvar> [-e <$evar>]\n\n";
+
 	exit(0);
 }
 
@@ -640,7 +843,7 @@ if(isset($OPTIONS['-e'])) {
 // load root manifest
 $ROOT_MANIFEST_DIR = realpath($OPTIONS['-d']);
 $filename = join(
-  DIRECTORY_SEPARATOR, array($ROOT_MANIFEST_DIR, 'manifest.jsonld'));
+DIRECTORY_SEPARATOR, [$ROOT_MANIFEST_DIR, 'manifest.jsonld']);
 $root_manifest = Util::readJson($filename);
 $manifest = new JsonLdManifest($root_manifest, $filename);
 $manifest->load($TESTS);