earl-report 0.5.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49a823f243638c7162903264e52f226f6f02e8e85943f1a4cd97a12594b080ab
-  data.tar.gz: b4855bcd3dbddc0e3b8eff04dbfd1ff8e8ed062827878471268e11b0fd509dbb
+  metadata.gz: a5d9b1de6d1ff74153dad8f2ff10691a43066da67b118c2c3cac375d030963e9
+  data.tar.gz: 2717c41b45c6f878157d070e34ca459530eda435b668e83141e6acb730f0be7b
 SHA512:
-  metadata.gz: c971edc43f724554263423eb192fde98aa810cf2eaed21a5349f3199e765550087e8ce34ee0e8191c073b075415cf49f40ae5905b41bcc5954b0221fb7667c36
-  data.tar.gz: bf787b883a24228aab04490fb93b32e26b9763dd67e00565f61040b0a1bfd0e1bef4a41e91353182c685c5bf7913e8c5d17a141feeac691abfb7d3b36695bc91
+  metadata.gz: f32d6ee582e6fb93c7a87f43a88c8146ec2ca952cb6000e8459213d65260cb454a253947adefe013d8cd0026aa847fde157a0eda0949077cb72e265f06ed61b3
+  data.tar.gz: 6ade127c2bb38bb1bec57106a71672d091a107799e6b2e1f37e65ecc66e4608a2573455a50470be918636aa230669b88fbde660e65c9172d660619982539dd73

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.
@@ -96,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>
          ]) .
 
@@ -132,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.5.0
+0.6.2

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.
@@ -152,35 +155,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|
@@ -195,25 +234,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
@@ -234,7 +273,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"
@@ -286,7 +325,7 @@ 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
@@ -294,7 +333,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
@@ -303,7 +342,12 @@ 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]
 
-          release ||= solution[:release] || RDF::Node.new
+          # 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
@@ -317,12 +361,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
@@ -345,7 +389,7 @@ class EarlReport
         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
 
@@ -374,36 +418,16 @@ class EarlReport
     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>;
+    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 +445,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 +454,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
 
@@ -487,10 +512,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
@@ -506,61 +531,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]
-
-    top_level = graph.first_subject(predicate: EARL.generatedBy)
+  def earl_turtle(io: $stdout)
+    context = JSON::LD::Context.parse(json_hash['@context'])
+    io.write(TURTLE_PREFIXES + "\n")
 
-    # 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)
+    @warnings += 1
     $stderr.puts message
   end
 
   def status(message)
-    $stderr.puts message if @options[:verbose]
+    $stderr.puts message if verbose
   end
 end