earl-report 0.4.8 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6cc5d6fb36d7bd99ed84e9f141f1e169ab492096bbf53ea978955efdf17fb39
-  data.tar.gz: 97838f4eab1bf562050e629dc27b34fc7c82c714589f0a6efabce2873a2872fc
+  metadata.gz: 47de1e3c1d07adb1a2ae440c1c53f72ceeb2c7b4e33d947739474225c802ed50
+  data.tar.gz: 611468fcef85b3a812ae184759d3c9806106ac2d15611f63cdbbe08fe194202b
 SHA512:
-  metadata.gz: 86c5d742c3b08343123c7c8f4f4d898b15f1cccce163a21a31a89fbea9b50d22eb4f309c22ec8e402e5027d4b88f56490820340265a1ea419fb9c96863017ca1
-  data.tar.gz: c0ee051dd41ce7064e48ad352b074ec73054909b56516e4fcf44f07f885ffcaf38e4cf1a11bd1d60f2759e005c62450b8f9e4788539361852b22445a76223380
+  metadata.gz: e023c3c5a1c42da0dbfc976149e50e590b3c9b770e0e66372794f68b2e881de064a515d0c6d8f73ac7a2acf1920cc95e0b35735a3a4897742ac6cb9d3385d8fa
+  data.tar.gz: e1c6bc8836bc9629fd36c0bc67e2f5dd30694a28f64da9ee06d864e29b0ce3d1636a83e755f878cb756d424f93b739f01246e08156085d73e8ccc48867c8bc09

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.8
+0.5.3

data/lib/earl_report.rb

@@ -33,13 +33,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,6 +152,34 @@ 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
@@ -220,7 +249,14 @@ 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}"
@@ -237,10 +273,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 +296,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,6 +308,7 @@ class EarlReport
           end
         end
 
+        release = nil
         solutions.each do |solution|
           # Kepp track of subjects
           subjects[solution[:uri]] = RDF::URI(file)
@@ -294,59 +331,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
+            $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
+          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
+        $stderr.puts "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 +406,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(@options.fetch(:name, 'Unknown'))};
+    dc:bibliographicCitation "#{@options.fetch(:bibRef, 'Unknown reference')}";
+    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
@@ -482,7 +495,20 @@ class EarlReport
     @json_hash ||= begin
       # Customized JSON-LD output
       result = JSON::LD::API.fromRDF(graph) do |expanded|
-        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
+        framed['testSubjects'] = Array(framed['testSubjects']).sort_by {|t| t['@id']}
+
+        # Reorder test assertions to make them consistent with subject order
+        Array(framed['entries']).each do |manifest|
+          manifest['entries'].each do |test|
+            test['assertions'] = test['assertions'].sort_by {|a| a['subject']}
+          end
+        end
+        framed
       end
       unless result.is_a?(Hash)
         raise "Expected JSON result to have a single entry, it had #{result.length rescue 'unknown'} entries"
@@ -497,50 +523,108 @@ class EarlReport
   # @option options [IO, StringIO] :io
   # @return [String]
   def earl_turtle(options)
+    context = JSON::LD::Context.parse(json_hash['@context'])
     io = options[:io]
+    io.write(TURTLE_PREFIXES + "\n")
 
-    top_level = graph.first_subject(predicate: EARL.generatedBy)
-
-    # Write starting with the entire graph to get preamble
-    writer = RDF::Turtle::Writer.new(io, standard_prefixes: true)
-    writer << graph
+    # Write project header
+    ttl_entity(io, json_hash, context)
 
-    writer.send(:preprocess)
-    writer.send(:start_document)
+    # Write out each manifest entry
+    io.puts("# Manifests")
+    json_hash['entries'].each do |man|
+      ttl_entity(io, man, context)
 
-    # 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)