earl-report 0.4.9 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e76543b490f30df2542076f3beb58514e02346c964e716aed470ea1f1dd1dcac
-  data.tar.gz: e03701faad62e4ea150911a1bdca0a875839276ddc28604e1066a5a532ac0509
+  metadata.gz: 77b18a547a9e1721a2c32e83abc8230dfb5c8a4a7170874cda1b4cf41d50d4d8
+  data.tar.gz: 04654044c3dfca443518097550ef07bd68b74203ca9dfc239a49c1a62a5c7556
 SHA512:
-  metadata.gz: 7a5f474b6b1fe4d1f1c259d93048b2a2299dd56ff88fd82d215f8f55cf6f51c20706ccac8189bf6d250d16a0a1c5f614d90c30f6f0212c2beaab65ddf13a03b2
-  data.tar.gz: fa242658e76b29269cf820834f83df03b6bef2d3b30e018d420ace79dd0b2b0afdde97708fb8183a3afbbce397f9339a7920795cbe697b2eeeef15035d9aaf3d
+  metadata.gz: 743c19a11e2b87f8819d841df0d37b9a6693b8eac15546d87e025d2c14f3464604cacc78adadc6d08103326070975334cb77e50a7da7b1824baf1babc4dbd33f
+  data.tar.gz: 23524a7e72dfd286504c422b05defa55e1ae00343a348926180d5d252a3ca041bc6a948cd929eca6e4183bdc2f8c1a0ff3b39861c34417ead1360bce7cd77525

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,11 +29,16 @@ 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 [
+                         doap:name "RDF::Turtle 3.1.0" ;
+                         doap:created "2015-09-27"^^xsd:date ;
+                         doap:revision "3.1.0"
+      ] ;
       doap:programming-language "Ruby" .
 
 The [DOAP]() description may be included in the [EARL]() report. If not found,
@@ -44,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.
@@ -91,14 +96,14 @@ Version 0.3 and prior re-constructed the test manifest used to create the body o
        mf:result <http://example/test-00.out>;
        earl: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>
          ]) .
 
@@ -127,7 +132,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.4.9
+0.6.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.rb

@@ -11,6 +11,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.
@@ -33,13 +34,14 @@ class EarlReport
     PREFIX doap: <http://usefulinc.com/ns/doap#>
     PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
-    SELECT DISTINCT ?uri ?name ?doapDesc ?revision ?homepage ?language ?developer ?devName ?devType ?devHomepage
+    SELECT DISTINCT ?uri ?name ?doapDesc ?release ?revision ?homepage ?language ?developer ?devName ?devType ?devHomepage
     WHERE {
       ?uri a doap:Project; doap:name ?name; doap:developer ?developer .
       OPTIONAL { ?uri doap:homepage ?homepage . }
       OPTIONAL { ?uri doap:description ?doapDesc . }
       OPTIONAL { ?uri doap:programming-language ?language . }
-      OPTIONAL { ?uri doap:release [ doap:revision ?revision] .}
+      OPTIONAL { ?uri doap:release ?release . }
+      OPTIONAL { ?release doap:revision ?revision .}
       OPTIONAL { ?developer a ?devType .}
       OPTIONAL { ?developer foaf:name ?devName .}
       OPTIONAL { ?developer foaf:homepage ?devHomepage .}
@@ -151,35 +153,71 @@ 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|
@@ -194,25 +232,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
@@ -220,13 +258,20 @@ class EarlReport
     test_resources = tests.values.map {|v| v[:uri]}.uniq.compact
     subjects = {}
 
-    assertion_graph = RDF::Graph.new
+    # Initialize test assertions with an entry for each test subject
+    test_assertion_lists = {}
+    test_assertion_lists = tests.keys.inject({}) do |memo, test|
+      memo.merge(test => [])
+    end
+
+    assertion_stats = {}
+
     # 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"
@@ -237,10 +282,10 @@ class EarlReport
 
           # Load DOAP definitions
           unless solution[:name] # not loaded
-            status "read doap description for #{subject}"
+            status "  read doap description for #{subject}"
             begin
               doap_graph = RDF::Graph.load(subject)
-              status "  loaded #{doap_graph.count} triples"
+              status "    loaded #{doap_graph.count} triples"
               file_graph << doap_graph.to_a
             rescue
               warn "\nfailed to load DOAP from #{subject}: #{$!}"
@@ -260,10 +305,10 @@ class EarlReport
         if !solutions.first[:developer]
           warn "\nNo developer identified for #{solutions.first[:uri]}"
         elsif !solutions.first[:devName]
-          status "read description for developer #{solutions.first[:developer].inspect}"
+          status "  read description for developer #{solutions.first[:developer].inspect}"
           begin
             foaf_graph = RDF::Graph.load(solutions.first[:developer])
-            status "  loaded #{foaf_graph.count} triples"
+            status "    loaded #{foaf_graph.count} triples"
             file_graph << foaf_graph.to_a
             # Reload solutions
             solutions = SPARQL.execute(TEST_SUBJECT_QUERY, file_graph)
@@ -272,12 +317,13 @@ class EarlReport
           end
         end
 
+        release = nil
         solutions.each do |solution|
           # Kepp track of subjects
           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
@@ -285,7 +331,7 @@ class EarlReport
           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::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
@@ -294,59 +340,60 @@ class EarlReport
           graph << RDF::Statement(solution[:developer], RDF::Vocab::FOAF.name, devName) if devName
           graph << RDF::Statement(solution[:developer], RDF::Vocab::FOAF.homepage, solution[:devHomepage]) if solution[:devHomepage]
 
-          rev = RDF::Node.new
-          graph << RDF::Statement(solution[:uri], RDF::Vocab::DOAP.release, rev)
-          graph << RDF::Statement(rev, RDF::Vocab::DOAP.revision, (solution[:revision] || "unknown"))
+          # Make sure BNode identifiers don't leak
+          release ||= if !solution[:release] || solution[:release].node?
+            RDF::Node.new
+          else
+            solution[:release]
+          end
+          graph << RDF::Statement(solution[:uri], RDF::Vocab::DOAP.release, release)
+          graph << RDF::Statement(release, RDF::Vocab::DOAP.revision, (solution[:revision] || "unknown"))
         end
 
-        assertion_graph << file_graph
-      end
-    end
+        # Make sure that each assertion matches a test and add reference from test to assertion
+        found_solutions = false
+        subject = nil
 
-    # Make sure that each assertion matches a test and add reference from test to assertion
-    found_solutions = {}
+        status "  query assertions"
+        SPARQL.execute(ASSERTION_QUERY, file_graph).each do |solution|
+          subject = solution[:subject]
+          unless tests[solution[:test]]
+            assertion_stats["Skipped"] = assertion_stats["Skipped"].to_i + 1
+            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
+            warn "No test result subject found for #{subject}: in #{subjects.keys.join(', ')}"
+            next
+          end
+          found_solutions ||= true
+          assertion_stats["Found"] = assertion_stats["Found"].to_i + 1
 
-    # Initialize test assertions with an entry for each test subject
-    test_assertion_lists = {}
-    test_assertion_lists = tests.keys.inject({}) do |memo, test|
-      memo.merge(test => Array.new(subjects.length))
-    end
+          # Add this solution at the appropriate index within that list
+          ndx = subjects.keys.find_index(subject)
+          ary = test_assertion_lists[solution[:test]]
 
-    status "query assertions"
-    assertion_stats = {}
-    SPARQL.execute(ASSERTION_QUERY, assertion_graph).each do |solution|
-      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"
-        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(', ')}"
-        next
+          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]
+          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])
+        end
+
+        # See if subject did not report results, which may indicate a formatting error in the EARL source
+        warn "No results found for #{subject} using #{ASSERTION_QUERY}" unless found_solutions
       end
-      found_solutions[subject] = true
-      assertion_stats["Found"] = assertion_stats["Found"].to_i + 1
-
-      # Add this solution at the appropriate index within that list
-      ndx = subjects.keys.find_index(subject)
-      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]
-      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])
     end
 
     # Add ordered assertions for each test
     test_assertion_lists.each do |test, ary|
+      ary[subjects.length - 1] ||= nil # extend for all subjects
       # Fill any missing entries with an untested outcome
       ary.each_with_index do |a, ndx|
         unless a
@@ -368,42 +415,17 @@ class EarlReport
 
     assertion_stats.each {|stat, count| status("Assertions #{stat}: #{count}")}
 
-    # See if any subject did not report results, which may indicate a formatting error in the EARL source
-    subjects.reject {|s| found_solutions[s]}.each do |sub|
-      $stderr.puts "No results found for #{sub} using #{ASSERTION_QUERY}"
-    end
-
     # 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>;
+    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          ")}) .
+    ).gsub(/^    /, '') +
+      TURTLE_SOFTWARE
     RDF::Turtle::Reader.new(ttl) {|r| graph << r}
 
     # Each manifest is an earl:Report
@@ -421,6 +443,8 @@ class EarlReport
       graph << RDF::Statement.new(u, RDF.type, EARL.TestCriterion)
       graph << RDF::Statement.new(u, RDF.type, EARL.TestCase)
     end
+
+    raise "Warnings issued in strict mode" if strict && @warnings > 0
   end
 
   ##
@@ -428,48 +452,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
 
@@ -482,13 +505,15 @@ class EarlReport
     @json_hash ||= begin
       # Customized JSON-LD output
       result = JSON::LD::API.fromRDF(graph) do |expanded|
-        framed = JSON::LD::API.frame(expanded, TEST_FRAME, expanded: true, embed: '@never')
+        framed = JSON::LD::API.frame(expanded, TEST_FRAME,
+          expanded: true,
+          embed: '@never',
+          pruneBlankNodeIdentifiers: false)
         # Reorder test subjects by @id
-        #require 'byebug'; byebug
-        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
@@ -504,61 +529,119 @@ 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'
+        "earl:assertions #{dv.map {|a| ttl_assertion(a)}.join(", ")}"
+      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