earl-report 0.5.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6800a858dd4353459625a138afe4b5b4c47d59771ee8bbb3328774972c3b9af3
-  data.tar.gz: 859d2c311f4d513b241fcde1f0cb870966aaa8bd0bbc7e12ac0171c0ef148167
+  metadata.gz: 7879d1953b9802807a57232a01207aa3b63f5ed80c025273ccdfe826e6f86c93
+  data.tar.gz: bf899c9f720aa8b8f67694e7398f693502fef7fb748b3fa5136acd05fe7495ca
 SHA512:
-  metadata.gz: e0660a76bf2001368ffc9334c31cdaeffed3b650297a8e39f9b052d75b158f7b5229ded5c2e137100022053d979c3f96422eccc63f2aee8296f39841c6c7fdd3
-  data.tar.gz: 6d0dd67e204827807dee1d1136e76f8a3de24dafb4b29d7bf9a9138c22c18bdb48d7994ef06d503b124e6b77f8e12f12385cbcc1c5d0fb536ac994eeb630f7b0
+  metadata.gz: 57c7ec9fff3d0634c35fc96d646febda4c7ce71fdaa9f8c8f78702335fdedb7c0babe6ccddf515cd17065284dc0627d085a3d41ee05dfeea5dd96b73b25b61d5
+  data.tar.gz: fdee07b06ca6344764876c8649f0c906c974326f27427120afb0455ef47fd35d4387e9f64b9f84ecf552bad44581769eec9455e3c27612b66ba26c8ac510a609

data/README.md

@@ -2,8 +2,8 @@
 Ruby gem to consolidate multiple EARL report and generate a rollup conformance report.
 
 [![Gem Version](https://badge.fury.io/rb/earl-report.png)](http://badge.fury.io/rb/earl-report)
-[![Build Status](https://travis-ci.org/gkellogg/earl-report.png?branch=master)](http://travis-ci.org/gkellogg/earl-report)
-[![Coverage Status](https://coveralls.io/repos/gkellogg/earl-report/badge.svg)](https://coveralls.io/r/gkellogg/earl-report)
+[![Build Status](https://github.com/gkellogg/earl-report/workflows/CI/badge.svg?branch=develop)](https://github.com/gkellogg/earl-report/actions?query=workflow%3ACI)
+[![Coverage Status](https://coveralls.io/repos/gkellogg/earl-report/badge.svg?branch=develop)](https://coveralls.io/r/gkellogg/earl-report?branch=develop)
 
 ## Description
 Reads a test manifest in the
@@ -17,8 +17,8 @@ may be specified in an any compatible RDF serialization. The report is composed
 in the following form:
 
     [ a earl:Assertion;
-      earl:assertedBy <http://greggkellogg.net/foaf#me>;
-      earl:subject <http://rubygems.org/gems/rdf-turtle>;
+      earl:assertedBy <https://greggkellogg.net/foaf#me>;
+      earl:subject <https://rubygems.org/gems/rdf-turtle>;
       earl:test <http://dvcs.w3.org/hg/rdf/raw-file/default/rdf-turtle/tests-ttl/manifest.ttl#turtle-syntax-file-01>;
       earl:result [
         a earl:TestResult;
@@ -29,9 +29,9 @@ in the following form:
 Additionally, `earl:subject` is expected to reference a [DOAP]() description
 of the reported software, in the following form:
 
-    <http://rubygems.org/gems/rdf-turtle> a doap:Project, earl:TestSubject, earl:Software ;
+    <https://rubygems.org/gems/rdf-turtle> a doap:Project, earl:TestSubject, earl:Software ;
       doap:name          "RDF::Turtle" ;
-      doap:developer     <http://greggkellogg.net/foaf#me> ;
+      doap:developer     <https://greggkellogg.net/foaf#me> ;
       doap:homepage      <http://ruby-rdf.github.com/rdf-turtle> ;
       doap:description   "RDF::Turtle is an Turtle reader/writer for the RDF.rb library suite."@en ;
       doap:release [
@@ -49,7 +49,7 @@ The `doap:developer` is expected to reference a [FOAF]() profile for the agent
 (user or organization) responsible for the test subject. It is expected to be
 of the following form:
 
-    <http://greggkellogg.net/foaf#me> foaf:name "Gregg Kellogg" .
+    <https://greggkellogg.net/foaf#me> foaf:name "Gregg Kellogg" .
 
 If not found, the IRI identified by `doap:developer`
 will be dereferenced and is presumed to provide a [FOAF]() profile of the developer.
@@ -78,11 +78,21 @@ can be used by specifying a customized manifest query, but may require a custom
 The report template is in [ReSpec][] form using [Haml]() to generate individual report elements.
 
 ## Changes from previous versions
-Version 0.3 and prior re-constructed the test manifest used to create the body of the report, which caused information not described within the query to be lost. Starting with 0.4, all manifests and assertions are read into a single graph, and each test references a list of assertions against it using a list referenced by `earl:assertions`. Additionally, all included manifests are included in a top-level entity referenced via `mf:entries`. For example:
+### Version 0.7
+Version 0.7 creates incompatibilities with previous result formats. Previously, terms were "added" to the EARL vocabulary to help with coordination. This version pulls that back, but does depend on an added `earl:Report` class which acts as an appropriate container for for collections of  `earl:Assertion`.
+
+Within an `earl:TestCase`, the former `earl:assertions` property is replaced with a reverse property on `earl:test` so that, in the JSON-LD representation, an `earl:TestCase` will contain a property representing the related assertions.
+
+Also, `earl:assertions` had been miss-appropriated to reference the sources of the individual test results provided for each test subject. A new property as appropriated from the Test Manifest vocabulary: `mf:report`. The alias `assertions` continues to be used within the JSON-LD representation, although it now maps to `mf:report` at the top level, and as mentioned, is a reverse property of `earl:test` within an `earl:TestCase`.
+
+These changes may require updates to customized Haml templates.
+
+### Version 0.3
+Version 0.3 and prior re-constructed the test manifest used to create the body of the report, which caused information not described within the query to be lost. Starting with 0.4, all manifests and assertions are read into a single graph, and each test references a list of assertions against it using a list referenced by `mf:assertions`. Additionally, all included manifests are included in a top-level entity referenced via `mf:entries`. For example:
 
     <> a earl:Software, doap:Project;
        mf:entries (<http://example/manifest.ttl>);
-       earl:assertions (<spec/test-files/report-complete.ttl>)  .
+       mf:assertions (<spec/test-files/report-complete.ttl>)  .
 
     <http://example/manifest.ttl> a mf:Manifest, earl:Report;
        mf:name "Example Test Cases";
@@ -94,16 +104,16 @@ Version 0.3 and prior re-constructed the test manifest used to create the body o
        rdfs:comment "Blank subject";
        mf:action <http://example/test-00.ttl>;
        mf:result <http://example/test-00.out>;
-       earl:assertions ([
+       mf:assertions ([
            a earl:Assertion;
-           earl:assertedBy <http://greggkellogg.net/foaf#me>;
+           earl:assertedBy <https://greggkellogg.net/foaf#me>;
            earl:mode earl:automatic;
            earl:result [
              a earl:TestResult;
              dc:date "2012-11-06T19:23:29-08:00"^^xsd:dateTime;
              earl:outcome earl:passed
            ];
-           earl:subject <http://rubygems.org/gems/rdf-turtle>;
+           earl:subject <https://rubygems.org/gems/rdf-turtle>;
            earl:test <http://example/manifest.ttl#testeval00>
          ]) .
 
@@ -132,7 +142,7 @@ Generally, creating a `json` format first is more efficient. Subsequent invocati
 When run, `earl-report` attempts to open the file `.earl` in the current directory. This file is in [YAML][] format with entries for each option. Use the `--rc` option to automatically generate it.
 
 ## Author
-* [Gregg Kellogg](http://github.com/gkellogg) - <http://greggkellogg.net/>
+* [Gregg Kellogg](https://github.com/gkellogg) - <https://greggkellogg.net/>
 
 ## License
 

data/VERSION

@@ -1 +1 @@
-0.5.1
+0.7.0

data/bin/earl-report

@@ -15,6 +15,7 @@ OPT_ARGS = [
   ["--output", "-o",      GetoptLong::REQUIRED_ARGUMENT,"Output report to file"],
   ["--query",             GetoptLong::REQUIRED_ARGUMENT,"Query, or file containing query for extracting information from Test manifest"],
   ["--rc",                GetoptLong::NO_ARGUMENT,      "Write options to run-control file"],
+  ["--strict",            GetoptLong::NO_ARGUMENT,      "Fails if any skipped result is found"],
   ["--template",          GetoptLong::OPTIONAL_ARGUMENT,"Specify or return default report template"],
   ["--verbose",           GetoptLong::NO_ARGUMENT,      "Detail on execution"],
   ["--help", "-?",        GetoptLong::NO_ARGUMENT,      "This message"]
@@ -65,6 +66,7 @@ opts.each do |opt, arg|
   when '--name'         then options[:name] = arg
   when '--output'       then options[:io] = File.open(arg, "w")
   when '--rc'           then options[:rc] = true
+  when '--strict'       then options[:strict] = true
   when '--template'     then options[:template] = (File.open(arg, "r") unless arg.empty?)
   when '--verbose'      then options[:verbose] = true
   when '--help'         then usage
@@ -94,6 +96,6 @@ if options.has_key?(:template) && options[:template].nil?
 elsif ARGV.empty?
   usage
 else
-  earl = EarlReport.new(*ARGV, options)
-  earl.generate(options)
+  earl = EarlReport.new(*ARGV, **options)
+  earl.generate(**options)
 end

data/lib/earl_report.rb

@@ -1,5 +1,7 @@
 # EARL reporting
-require 'linkeddata'
+require 'json/ld'
+require 'rdf/turtle'
+require 'rdf/vocab'
 require 'sparql'
 require 'haml'
 require 'open-uri'
@@ -11,6 +13,7 @@ class EarlReport
   autoload :VERSION, 'earl_report/version'
 
   attr_reader :graph
+  attr_reader :verbose
 
   # Return information about each test.
   # Tests all have an mf:action property.
@@ -90,12 +93,20 @@ class EarlReport
       "foaf" =>         "http://xmlns.com/foaf/0.1/",
       "rdfs" =>         "http://www.w3.org/2000/01/rdf-schema#",
       "assertedBy" =>   {"@type" => "@id"},
-      "assertions" =>   {"@type" => "@id", "@container" => "@set"},
+      "assertions" =>   {"@id" => "mf:report", "@type" => "@id", "@container" => "@set"},
       "bibRef" =>       {"@id" => "dc:bibliographicCitation"},
       "created" =>      {"@id" => "doap:created", "@type" => "xsd:date"},
       "description" =>  {"@id" => "rdfs:comment", "@language" => "en"},
       "developer" =>    {"@id" => "doap:developer", "@type" => "@id", "@container" => "@set"},
       "doapDesc" =>     {"@id" => "doap:description", "@language" => "en"},
+      "entries" =>      {
+        "@id" => "mf:entries", "@type" => "@id", "@container" => "@list",
+        "@context" => {
+          "assertions" =>   {
+            "@reverse" => "earl:test", "@type" => "@id", "@container" => "@set"
+          },
+        }
+      },
       "generatedBy" =>  {"@type" => "@id"},
       "homepage" =>     {"@id" => "doap:homepage", "@type" => "@id"},
       "language" =>     {"@id" => "doap:programming-language"},
@@ -111,7 +122,6 @@ class EarlReport
       "testAction" =>   {"@id" => "mf:action", "@type" => "@id"},
       "testResult" =>   {"@id" => "mf:result", "@type" => "@id"},
       "title" =>        {"@id" => "mf:name"},
-      "entries" =>      {"@id" => "mf:entries", "@type" => "@id", "@container" => "@list"},
       "testSubjects" => {"@type" => "@id", "@container" => "@set"},
       "xsd" =>          {"@id" => "http://www.w3.org/2001/XMLSchema#"}
     },
@@ -152,35 +162,70 @@ class EarlReport
     }]
   }.freeze
 
+  TURTLE_PREFIXES = %(@prefix dc:   <http://purl.org/dc/terms/> .
+  @prefix doap: <http://usefulinc.com/ns/doap#> .
+  @prefix earl: <http://www.w3.org/ns/earl#> .
+  @prefix mf:   <http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#> .
+  @prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .
+  @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+  @prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+  @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+  ).gsub(/^  /, '')
+
+  TURTLE_SOFTWARE = %(
+  # Report Generation Software
+  <https://rubygems.org/gems/earl-report> a earl:Software, doap:Project;
+     doap:name "earl-report";
+     doap:shortdesc "Earl Report summary generator"@en;
+     doap:description "EarlReport generates HTML+RDFa rollups of multiple EARL reports"@en;
+     doap:homepage <https://github.com/gkellogg/earl-report>;
+     doap:programming-language "Ruby";
+     doap:license <http://unlicense.org>;
+     doap:release <https://github.com/gkellogg/earl-report/tree/#{VERSION}>;
+     doap:developer <https://greggkellogg.net/foaf#me> .
+
+  <https://github.com/gkellogg/earl-report/tree/#{VERSION}> a doap:Version;
+    doap:name "earl-report-#{VERSION}";
+    doap:created "#{File.mtime(File.expand_path('../../VERSION', __FILE__)).strftime('%Y-%m-%d')}"^^xsd:date;
+    doap:revision "#{VERSION}" .
+  ).gsub(/^  /, '')
+
   # Convenience vocabularies
-  class EARL < RDF::Vocabulary("http://www.w3.org/ns/earl#"); end
   class MF < RDF::Vocabulary("http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#"); end
 
   ##
   # Load test assertions and look for referenced software and developer information
-  # @overload initialize(*files)
-  #   @param [Array<String>] files Assertions
-  # @overload initialize(*files, options = {})
-  #   @param [Hash{Symbol => Object}] options
-  #   @option options [Boolean] :verbose (true)
-  #   @option options [String] :base Base IRI for loading Manifest
-  #   @option options [String] :bibRef
-  #     ReSpec bibliography reference for specification being tested
-  #   @option options [String] :json Result of previous JSON-LD generation
-  #   @option options [String, Array<String>] :manifest Test manifest
-  #   @option options [String] :name Name of specification
-  #   @option options [String] :query
-  #     Query, or file containing query for extracting information from Test manifests
-  def initialize(*files)
-    @options = files.last.is_a?(Hash) ? files.pop.dup : {}
-    @options[:query] ||= MANIFEST_QUERY
-    raise "Test Manifests must be specified with :manifest option" unless @options[:manifest] || @options[:json]
+  #
+  # @param [Array<String>] files Assertions
+  # @param [String] base (nil) Base IRI for loading Manifest
+  # @param [String] bibRef ('Unknown reference')
+  #   ReSpec bibliography reference for specification being tested
+  # @param [Boolean] json (false) File is in the JSON format of a report.
+  # @param [String, Array<String>] manifest (nil) Test manifest(s)
+  # @param [String] name ('Unknown') Name of specification
+  # @param [String] query (MANIFEST_QUERY)
+  #   Query, or file containing query for extracting information from Test manifests
+  # @param [Boolean] strict (false) Abort on any warning
+  # @param [Boolean] verbose (false)
+  def initialize(*files,
+                 base: nil,
+                 bibRef: 'Unknown reference',
+                 json: false,
+                 manifest: nil,
+                 name: 'Unknown',
+                 query: MANIFEST_QUERY,
+                 strict: false,
+                 verbose: false,
+                 **options)
+    @verbose = verbose
+    raise "Test Manifests must be specified with :manifest option" unless manifest || json
     raise "Require at least one input file" if files.empty?
     @files = files
     @prefixes = {}
+    @warnings = 0
 
-    # If provided :json, it is used for generating all other output forms
-    if @options[:json]
+    # If provided json, it is used for generating all other output forms
+    if json
       @json_hash = ::JSON.parse(File.read(files.first))
       # Add a base_uri so relative subjects aren't dropped
       JSON::LD::Reader.open(files.first, base_uri: "http://example.org/report") do |r|
@@ -195,25 +240,25 @@ class EarlReport
     end
 
     # Load manifests, possibly with base URI
-    status "read #{@options[:manifest].inspect}"
+    status "read #{manifest.inspect}"
     man_opts = {}
-    man_opts[:base_uri] = RDF::URI(@options[:base]) if @options[:base]
+    man_opts[:base_uri] = RDF::URI(base) if base
     @graph = RDF::Graph.new
-    Array(@options[:manifest]).each do |man|
+    Array(manifest).each do |man|
       g = RDF::Graph.load(man, unique_bnodes: true, **man_opts)
       status "  loaded #{g.count} triples from #{man}"
       graph << g
     end
 
     # Hash test cases by URI
-    tests = SPARQL.execute(@options[:query], graph)
+    tests = SPARQL.execute(query, graph)
       .to_a
       .inject({}) {|memo, soln| memo[soln[:uri]] = soln; memo}
 
     if tests.empty?
       raise "no tests found querying manifest.\n" +
             "Results are found using the following query, this can be overridden using the --query option:\n" +
-            "#{@options[:query]}"
+            "#{query}"
     end
 
     # Manifests in graph
@@ -228,14 +273,13 @@ class EarlReport
     end
 
     assertion_stats = {}
-    release_node_mapper = {}
 
     # Read test assertion files into assertion graph
     files.flatten.each do |file|
       status "read #{file}"
       file_graph = RDF::Graph.load(file)
       if file_graph.first_object(predicate: RDF::URI('http://www.w3.org/ns/earl#testSubjects'))
-        status "   skip #{file}, which seems to be a previous rollup earl report"
+        warn "   skip #{file}, which seems to be a previous rollup earl report"
         @files -= [file]
       else
         status "  loaded #{file_graph.count} triples"
@@ -287,15 +331,15 @@ class EarlReport
           subjects[solution[:uri]] = RDF::URI(file)
 
           # Add TestSubject information to main graph
-          name = solution[:name].to_s if solution[:name]
+          doapName = solution[:name].to_s if solution[:name]
           language = solution[:language].to_s if solution[:language]
           doapDesc = solution[:doapDesc] if solution[:doapDesc]
           doapDesc.language ||= :en if doapDesc
           devName = solution[:devName].to_s if solution[:devName]
           graph << RDF::Statement(solution[:uri], RDF.type, RDF::Vocab::DOAP.Project)
-          graph << RDF::Statement(solution[:uri], RDF.type, EARL.TestSubject)
-          graph << RDF::Statement(solution[:uri], RDF.type, EARL.Software)
-          graph << RDF::Statement(solution[:uri], RDF::Vocab::DOAP.name, name)
+          graph << RDF::Statement(solution[:uri], RDF.type, RDF::Vocab::EARL.TestSubject)
+          graph << RDF::Statement(solution[:uri], RDF.type, RDF::Vocab::EARL.Software)
+          graph << RDF::Statement(solution[:uri], RDF::Vocab::DOAP.name, doapName)
           graph << RDF::Statement(solution[:uri], RDF::Vocab::DOAP.developer, solution[:developer])
           graph << RDF::Statement(solution[:uri], RDF::Vocab::DOAP.homepage, solution[:homepage]) if solution[:homepage]
           graph << RDF::Statement(solution[:uri], RDF::Vocab::DOAP.description, doapDesc) if doapDesc
@@ -323,12 +367,12 @@ class EarlReport
           subject = solution[:subject]
           unless tests[solution[:test]]
             assertion_stats["Skipped"] = assertion_stats["Skipped"].to_i + 1
-            $stderr.puts "Skipping result for #{solution[:test]} for #{subject}, which is not defined in manifests"
+            warn "Skipping result for #{solution[:test]} for #{subject}, which is not defined in manifests"
             next
           end
           unless subjects[subject]
             assertion_stats["Missing Subject"] = assertion_stats["Missing Subject"].to_i + 1
-            $stderr.puts "No test result subject found for #{subject}: in #{subjects.keys.join(', ')}"
+            warn "No test result subject found for #{subject}: in #{subjects.keys.join(', ')}"
             next
           end
           found_solutions ||= true
@@ -339,19 +383,19 @@ class EarlReport
           ary = test_assertion_lists[solution[:test]]
 
           ary[ndx] = a = RDF::Node.new
-          graph << RDF::Statement(a, RDF.type, EARL.Assertion)
-          graph << RDF::Statement(a, EARL.subject, subject)
-          graph << RDF::Statement(a, EARL.test, solution[:test])
-          graph << RDF::Statement(a, EARL.assertedBy, solution[:by])
-          graph << RDF::Statement(a, EARL.mode, solution[:mode]) if solution[:mode]
+          graph << RDF::Statement(a, RDF.type, RDF::Vocab::EARL.Assertion)
+          graph << RDF::Statement(a, RDF::Vocab::EARL.subject, subject)
+          graph << RDF::Statement(a, RDF::Vocab::EARL.test, solution[:test])
+          graph << RDF::Statement(a, RDF::Vocab::EARL.assertedBy, solution[:by])
+          graph << RDF::Statement(a, RDF::Vocab::EARL.mode, solution[:mode]) if solution[:mode]
           r = RDF::Node.new
-          graph << RDF::Statement(a, EARL.result, r)
-          graph << RDF::Statement(r, RDF.type, EARL.TestResult)
-          graph << RDF::Statement(r, EARL.outcome, solution[:outcome])
+          graph << RDF::Statement(a, RDF::Vocab::EARL.result, r)
+          graph << RDF::Statement(r, RDF.type, RDF::Vocab::EARL.TestResult)
+          graph << RDF::Statement(r, RDF::Vocab::EARL.outcome, solution[:outcome])
         end
 
         # See if subject did not report results, which may indicate a formatting error in the EARL source
-        $stderr.puts "No results found for #{subject} using #{ASSERTION_QUERY}" unless found_solutions
+        warn "No results found for #{subject} using #{ASSERTION_QUERY}" unless found_solutions
       end
     end
 
@@ -363,70 +407,49 @@ class EarlReport
         unless a
           assertion_stats["Untested"] = assertion_stats["Untested"].to_i + 1
           ary[ndx] = a = RDF::Node.new
-          graph << RDF::Statement(a, RDF.type, EARL.Assertion)
-          graph << RDF::Statement(a, EARL.subject, subjects.keys[ndx])
-          graph << RDF::Statement(a, EARL.test, test)
+          graph << RDF::Statement(a, RDF.type, RDF::Vocab::EARL.Assertion)
+          graph << RDF::Statement(a, RDF::Vocab::EARL.subject, subjects.keys[ndx])
+          graph << RDF::Statement(a, RDF::Vocab::EARL.test, test)
           r = RDF::Node.new
-          graph << RDF::Statement(a, EARL.result, r)
-          graph << RDF::Statement(r, RDF.type, EARL.TestResult)
-          graph << RDF::Statement(r, EARL.outcome, EARL.untested)
+          graph << RDF::Statement(a, RDF::Vocab::EARL.result, r)
+          graph << RDF::Statement(r, RDF.type, RDF::Vocab::EARL.TestResult)
+          graph << RDF::Statement(r, RDF::Vocab::EARL.outcome, RDF::Vocab::EARL.untested)
         end
-
-        # This counts on order being preserved in default repository so we can avoid using an rdf:List
-        graph << RDF::Statement(test, EARL.assertions, a)
       end
     end
 
     assertion_stats.each {|stat, count| status("Assertions #{stat}: #{count}")}
 
     # Add report wrapper to graph
-    ttl = %(
-      @prefix dc:   <http://purl.org/dc/terms/> .
-      @prefix doap: <http://usefulinc.com/ns/doap#> .
-      @prefix earl: <http://www.w3.org/ns/earl#> .
-      @prefix mf:   <http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#> .
-      @prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .
-
-      <> a earl:Software, doap:Project;
-      doap:name #{quoted(@options.fetch(:name, 'Unknown'))};
-      dc:bibliographicCitation "#{@options.fetch(:bibRef, 'Unknown reference')}";
-      earl:generatedBy <http://rubygems.org/gems/earl-report>;
-      earl:assertions #{subjects.values.map {|f| f.to_ntriples}.join(",\n          ")};
-      earl:testSubjects #{subjects.keys.map {|f| f.to_ntriples}.join(",\n          ")};
-      mf:entries (#{man_uris.map {|f| f.to_ntriples}.join("\n          ")}) .
-
-      <http://rubygems.org/gems/earl-report> a earl:Software, doap:Project;
-         doap:name "earl-report";
-         doap:shortdesc "Earl Report summary generator"@en;
-         doap:description "EarlReport generates HTML+RDFa rollups of multiple EARL reports"@en;
-         doap:homepage <https://github.com/gkellogg/earl-report>;
-         doap:programming-language "Ruby";
-         doap:license <http://unlicense.org>;
-         doap:release <https://github.com/gkellogg/earl-report/tree/#{VERSION}>;
-         doap:developer <http://greggkellogg.net/foaf#me> .
-
-      <https://github.com/gkellogg/earl-report/tree/#{VERSION}> a doap:Version;
-        doap:name "earl-report-#{VERSION}";
-        doap:created "#{File.mtime(File.expand_path('../../VERSION', __FILE__)).strftime('%Y-%m-%d')}"^^xsd:date;
-        doap:revision "#{VERSION}" .
-    ).gsub(/^      /, '')
+    ttl = TURTLE_PREFIXES + %(
+    <> a earl:Software, doap:Project;
+    doap:name #{quoted(name)};
+    dc:bibliographicCitation "#{bibRef}";
+    earl:generatedBy <https://rubygems.org/gems/earl-report>;
+    mf:report #{subjects.values.map {|f| f.to_ntriples}.join(",\n          ")};
+    earl:testSubjects #{subjects.keys.map {|f| f.to_ntriples}.join(",\n          ")};
+    mf:entries (#{man_uris.map {|f| f.to_ntriples}.join("\n          ")}) .
+    ).gsub(/^    /, '') +
+      TURTLE_SOFTWARE
     RDF::Turtle::Reader.new(ttl) {|r| graph << r}
 
     # Each manifest is an earl:Report
     man_uris.each do |u|
-      graph << RDF::Statement.new(u, RDF.type, EARL.Report)
+      graph << RDF::Statement.new(u, RDF.type, RDF::Vocab::EARL.Report)
     end
 
     # Each subject is an earl:TestSubject
     subjects.keys.each do |u|
-      graph << RDF::Statement.new(u, RDF.type, EARL.TestSubject)
+      graph << RDF::Statement.new(u, RDF.type, RDF::Vocab::EARL.TestSubject)
     end
 
     # Each assertion test is a earl:TestCriterion and earl:TestCase
     test_resources.each do |u|
-      graph << RDF::Statement.new(u, RDF.type, EARL.TestCriterion)
-      graph << RDF::Statement.new(u, RDF.type, EARL.TestCase)
+      graph << RDF::Statement.new(u, RDF.type, RDF::Vocab::EARL.TestCriterion)
+      graph << RDF::Statement.new(u, RDF.type, RDF::Vocab::EARL.TestCase)
     end
+
+    raise "Warnings issued in strict mode" if strict && @warnings > 0
   end
 
   ##
@@ -434,48 +457,47 @@ class EarlReport
   #
   # If no `io` option is provided, the output is returned as a string
   #
+  # @param [Symbol] format (:html)
+  # @param [IO] io (nil)
+  #   `IO` to output results
   # @param [Hash{Symbol => Object}] options
-  # @option options [Symbol] format (:html)
-  # @option options[IO] :io
-  #   Optional `IO` to output results
+  # @param [String] template
+  #   HAML template for generating report
   # @return [String] serialized graph, if `io` is nil
-  def generate(options = {})
-    options = {format: :html}.merge(options)
-
-    io = options[:io]
+  def generate(format: :html, io: nil, template: nil, **options)
 
-    status("generate: #{options[:format]}")
+    status("generate: #{format}")
     ##
     # Retrieve Hashed information in JSON-LD format
-    case options[:format]
+    case format
     when :jsonld, :json
       json = json_hash.to_json(JSON::LD::JSON_STATE)
       io.write(json) if io
       json
     when :turtle, :ttl
       if io
-        earl_turtle(options)
+        earl_turtle(io: io)
       else
         io = StringIO.new
-        earl_turtle(options.merge(io: io))
+        earl_turtle(io: io)
         io.rewind
         io.read
       end
     when :html
-      template = case options[:template]
-      when String then options[:tempate]
-      when IO, StringIO then options[:template].read
+      haml = case template
+      when String then template
+      when IO, StringIO then template.read
       else
         File.read(File.expand_path('../earl_report/views/earl_report.html.haml', __FILE__))
       end
 
       # Generate HTML report
-      html = Haml::Engine.new(template, format: :xhtml).render(self, tests: json_hash)
+      html = Haml::Engine.new(haml, format: :xhtml).render(self, tests: json_hash)
       io.write(html) if io
       html
     else
-      writer = RDF::Writer.for(options[:format])
-      writer.dump(@graph, io, options.merge(standard_prefixes: true))
+      writer = RDF::Writer.for(format)
+      writer.dump(@graph, io, standard_prefixes: true, **options)
     end
   end
 
@@ -493,10 +515,10 @@ class EarlReport
           embed: '@never',
           pruneBlankNodeIdentifiers: false)
         # Reorder test subjects by @id
-        framed['testSubjects'] = framed['testSubjects'].sort_by {|t| t['@id']}
+        framed['testSubjects'] = Array(framed['testSubjects']).sort_by {|t| t['@id']}
 
         # Reorder test assertions to make them consistent with subject order
-        framed['entries'].each do |manifest|
+        Array(framed['entries']).each do |manifest|
           manifest['entries'].each do |test|
             test['assertions'] = test['assertions'].sort_by {|a| a['subject']}
           end
@@ -512,61 +534,123 @@ class EarlReport
 
   ##
   # Output consoloated EARL report as Turtle
-  # @param [Hash{Symbol => Object}] options
-  # @option options [IO, StringIO] :io
+  # @param [IO] io ($stdout)
+  #   `IO` to output results
   # @return [String]
-  def earl_turtle(options)
-    io = options[:io]
+  def earl_turtle(io: $stdout)
+    context = JSON::LD::Context.parse(json_hash['@context'])
+    io.write(TURTLE_PREFIXES + "\n")
 
-    top_level = graph.first_subject(predicate: EARL.generatedBy)
+    # Write project header
+    ttl_entity(io, json_hash, context)
 
-    # Write starting with the entire graph to get preamble
-    writer = RDF::Turtle::Writer.new(io, standard_prefixes: true)
-    writer << graph
+    # Write out each manifest entry
+    io.puts("# Manifests")
+    json_hash['entries'].each do |man|
+      ttl_entity(io, man, context)
 
-    writer.send(:preprocess)
-    writer.send(:start_document)
-
-    # Write top-level object referencing manifests and subjects
-    writer.send(:statement, top_level)
+      # Output each test entry with assertions
+      man['entries'].each do |entry|
+        ttl_entity(io, entry, context)
+      end
+    end
 
-    # Write each manifest
-    io.puts "\n# Manifests"
-    RDF::List.new(subject: graph.first_object(subject: top_level, predicate: MF[:entries]), graph: graph).each do |manifest|
-      writer.send(:statement, manifest)
+    # Output each DOAP
+    json_hash['testSubjects'].each do |doap|
+      ttl_entity(io, doap, context)
 
-      # Write each test case
-      RDF::List.new(subject: graph.first_object(subject: manifest, predicate: MF[:entries]), graph: graph).each do |tc|
-        writer.send(:statement, tc)
+      # FOAF
+      dev = doap['developer']
+      dev = [dev] unless dev.is_a?(Array)
+      dev.each do |foaf|
+        ttl_entity(io, foaf, context)
       end
     end
+    
+    io.write(TURTLE_SOFTWARE)
+  end
 
-    # Write test subjects
-    io.puts "\n# Test Subjects"
-    graph.query(subject: top_level, predicate: EARL.testSubjects).each do |s|
-      writer.send(:statement, s.object)
+  def ttl_entity(io, entity, context)
+    io.write(ttl_value(entity) + " " + entity.map do |dk, dv|
+      case dk
+      when '@context', '@id'
+        nil
+      when '@type'
+        "a " + ttl_value(dv)
+      when 'assertions'
+        if dv.all? {|a| a.is_a?(String)}
+          "mf:report #{ttl_value(dv, whitespace: "\n    ")}"
+        else
+          "earl:assertions #{dv.map {|a| ttl_assertion(a)}.join(", ")}"
+        end
+      when 'entries'
+        "mf:entries #{ttl_value({'@list' => dv}, whitespace: "\n    ")}"
+      when 'release'
+        "doap:release [doap:revision #{quoted(dv['revision'])}]"
+      else
+        dv = [dv] unless dv.is_a?(Array)
+        dv = dv.map {|v| v.is_a?(Hash) ? v : context.expand_value(dk, v)}
+        "#{ttl_value(dk)} #{ttl_value(dv, whitespace: "\n    ")}"
+      end
+    end.compact.join(" ;\n  ") + " .\n\n")
+  end
 
-      # Write each developer
-      graph.query(subject: s.object, predicate: RDF::Vocab::DOAP.developer).each do |d|
-        writer.send(:statement, d.object)
+  def ttl_value(value, whitespace: " ")
+    if value.is_a?(Array)
+      value.map {|v| ttl_value(v)}.join(",#{whitespace}")
+    elsif value.is_a?(Hash)
+      if value.key?('@list')
+        "(#{value['@list'].map {|vv| ttl_value(vv)}.join(whitespace)})"
+      elsif value.key?('@value')
+        quoted(value['@value'], language: value['@language'], datatype: value['@type'])
+      elsif value.key?('@id')
+        ttl_value(value['@id'])
+      else
+        "[]"
       end
+    elsif value.start_with?(/https?/) || value.start_with?('/')
+      "<#{value}>"
+    elsif value.include?(':')
+      value
+    elsif json_hash['@context'][value].is_a?(Hash)
+      json_hash['@context'][value].fetch('@id', "earl:#{value}")
+    elsif value.empty?
+      "<>"
+    else
+      "earl:#{value}"
     end
+  end
 
-    # Write generator
-    io.puts "\n# Report Generation Software"
-    writer.send(:statement, RDF::URI("http://rubygems.org/gems/earl-report"))
-    writer.send(:statement, RDF::URI("https://github.com/gkellogg/earl-report/tree/#{VERSION}"))
+  def ttl_assertion(value)
+    return ttl_value(value) if value.is_a?(String)
+    block = [
+      "[",
+      "    a earl:Assertion ;",
+      "    earl:test #{ttl_value(value['test'])} ;",
+      "    earl:subject #{ttl_value(value['subject'])} ;",
+      "    earl:result [",
+      "      a earl:TestResult ;",
+      "      earl:outcome #{ttl_value(value['result']['outcome'])}",
+      "    ] ;",
+    ]
+    block << "    earl:assertedBy #{ttl_value(value['assertedBy'])} ;" if value['assertedBy']
+
+    block.join("\n") + "\n  ]"
   end
 
-  def quoted(string)
-    (@turtle_writer ||= RDF::Turtle::Writer.new).send(:quoted, string)
+  def quoted(string, language: nil, datatype: nil)
+    str = (@turtle_writer ||= RDF::Turtle::Writer.new).send(:quoted, string)
+    str += "@#{language}" if language
+    str += "^^#{ttl_value(datatype)}" if datatype
+    str
   end
 
   def warn(message)
+    @warnings += 1
     $stderr.puts message
   end
 
   def status(message)
-    $stderr.puts message if @options[:verbose]
+    $stderr.puts message if verbose
   end
 end