earl-report 0.5.3 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47de1e3c1d07adb1a2ae440c1c53f72ceeb2c7b4e33d947739474225c802ed50
-  data.tar.gz: 611468fcef85b3a812ae184759d3c9806106ac2d15611f63cdbbe08fe194202b
+  metadata.gz: c6dcbb408bb40367d46daa74a9992ccb11b5ccec84d63ab89eb75cc94ad45fdb
+  data.tar.gz: 5731c42e85ff773264d754c3cf7aea3ecb7eedfa0507e5c7289e7390de669f11
 SHA512:
-  metadata.gz: e023c3c5a1c42da0dbfc976149e50e590b3c9b770e0e66372794f68b2e881de064a515d0c6d8f73ac7a2acf1920cc95e0b35735a3a4897742ac6cb9d3385d8fa
-  data.tar.gz: e1c6bc8836bc9629fd36c0bc67e2f5dd30694a28f64da9ee06d864e29b0ce3d1636a83e755f878cb756d424f93b739f01246e08156085d73e8ccc48867c8bc09
+  metadata.gz: 76722b2059adaf67a4ab6166e9d7c8ed1f1216f9026598f93597ec0bfcaf724b7ea09f8612045f86857c47cf51e8943a3bc274b3e1d1397c3ccdee04b938c95c
+  data.tar.gz: cd209db5e59d358121730784e2b2f76da344dd2d324e50df5bc2b70013ccabd4aff341c58d637fc11a11f3adccc7ebaf52cf86912ac051ec4ac647df6c8dc707

data/README.md

@@ -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,7 +104,7 @@ 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 <https://greggkellogg.net/foaf#me>;
            earl:mode earl:automatic;

data/VERSION

@@ -1 +1 @@
-0.5.3
+0.7.1

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/views/earl_report.html.haml

@@ -333,7 +333,7 @@
                   - assertion = test['assertions'].detect {|a| a['subject'] == subject['@id']}
                   - pass_fail = assertion['result']['outcome'].split(':').last.upcase.sub(/(PASS|FAIL)ED$/, '\1')
                   - passed_tests[ndx2][ndx] = (passed_tests[ndx2][ndx] || 0) + (pass_fail == 'PASS' ? 1 : 0)
-                  %td{class: pass_fail, property: "earl:assertions", typeof: assertion['@type']}
+                  %td{class: pass_fail, typeof: assertion['@type']}
                     - if assertion['assertedBy'] && !assertion['assertedBy'].start_with?('_:')
                       %link{property: "earl:assertedBy", href: assertion['assertedBy']}
                     - if assertion['test'] && !assertion['test'].start_with?('_:')
@@ -418,7 +418,7 @@
                         %td{class: (pct == 100.0 ? 'passed-all' : (pct >= 85.0 ? 'passed-most' : 'passed-some'))}
                           = "#{passed}/#{total} (#{'%.1f' % pct}%)"
     - unless tests['assertions'].empty?
-      %section.appendix#individual-test-results{rel: "xhv:related earl:assertions"}
+      %section.appendix#individual-test-results{rel: "xhv:related mf:report"}
         %h2
           %span.secno="B."
           Individual Test Results

data/lib/earl_report.rb

@@ -1,5 +1,8 @@
 # EARL reporting
-require 'linkeddata'
+require 'json/ld'
+require 'rdf/ordered_repo'
+require 'rdf/turtle'
+require 'rdf/vocab'
 require 'sparql'
 require 'haml'
 require 'open-uri'
@@ -11,6 +14,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 +94,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 +123,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#"}
     },
@@ -181,34 +192,41 @@ class EarlReport
   ).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|
@@ -223,25 +241,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
@@ -262,7 +280,7 @@ class EarlReport
       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"
@@ -293,19 +311,22 @@ class EarlReport
         end
 
         # Load developers referenced from Test Subjects
-        if !solutions.first[:developer]
+        if !solutions.all? {|s| s[:developer]}
           warn "\nNo developer identified for #{solutions.first[:uri]}"
-        elsif !solutions.first[:devName]
-          status "  read description for developer #{solutions.first[:developer].inspect}"
-          begin
-            foaf_graph = RDF::Graph.load(solutions.first[:developer])
-            status "    loaded #{foaf_graph.count} triples"
-            file_graph << foaf_graph.to_a
-            # Reload solutions
-            solutions = SPARQL.execute(TEST_SUBJECT_QUERY, file_graph)
-          rescue
-            warn "\nfailed to load FOAF from #{solutions.first[:developer]}: #{$!}"
+        elsif !solutions.all? {|s| s[:devName]}
+          solutions.reject {|s| s[:devName]}.each do |no_foaf|
+            status "  read description for developer #{no_foaf[:developer].inspect}"
+            begin
+              foaf_graph = RDF::Graph.load(no_foaf[:developer])
+              status "    loaded #{foaf_graph.count} triples"
+              file_graph << foaf_graph.to_a
+            rescue
+              warn "\nfailed to load FOAF from #{no_foaf[:developer]}: #{$!}"
+            end
           end
+
+          # Reload solutions
+          solutions = SPARQL.execute(TEST_SUBJECT_QUERY, file_graph)
         end
 
         release = nil
@@ -314,15 +335,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
@@ -350,12 +371,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
@@ -366,19 +387,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
 
@@ -390,17 +411,14 @@ 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
 
@@ -409,10 +427,10 @@ class EarlReport
     # Add report wrapper to graph
     ttl = TURTLE_PREFIXES + %(
     <> a earl:Software, doap:Project;
-    doap:name #{quoted(@options.fetch(:name, 'Unknown'))};
-    dc:bibliographicCitation "#{@options.fetch(:bibRef, 'Unknown reference')}";
+    doap:name #{quoted(name)};
+    dc:bibliographicCitation "#{bibRef}";
     earl:generatedBy <https://rubygems.org/gems/earl-report>;
-    earl:assertions #{subjects.values.map {|f| f.to_ntriples}.join(",\n          ")};
+    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(/^    /, '') +
@@ -421,19 +439,21 @@ class EarlReport
 
     # 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
 
   ##
@@ -441,48 +461,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)
+  def generate(format: :html, io: nil, template: nil, **options)
 
-    io = options[:io]
-
-    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
 
@@ -519,12 +538,11 @@ 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)
+  def earl_turtle(io: $stdout)
     context = JSON::LD::Context.parse(json_hash['@context'])
-    io = options[:io]
     io.write(TURTLE_PREFIXES + "\n")
 
     # Write project header
@@ -564,7 +582,11 @@ class EarlReport
       when '@type'
         "a " + ttl_value(dv)
       when 'assertions'
-        "earl:assertions #{dv.map {|a| ttl_assertion(a)}.join(", ")}"
+        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'
@@ -628,10 +650,11 @@ class EarlReport
   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