earl-report 0.0.3 → 0.1.0

data/README.md

@@ -1,42 +1,13 @@
 # earl-report
-============
-
 Ruby gem to consolidate multiple EARL report and generate a rollup conformance report.
 
 ## Description
-
 Reads a test manifest in the
 [standard RDF WG format](http://www.w3.org/2011/rdf-wg/wiki/Turtle_Test_Suite)
-and generates a rollup report in RDFa+HTML.
-
-## Test Specifications
-The test manifest is presumed to be of the following form:
-
-### Manifest Header
-
-The manifest header looks like:
-
-    <>  rdf:type mf:Manifest ;
-        rdfs:comment "Turtle tests" ;
-        mf:entries
-        (
-        ....
-        ) .
-
-where .... is a list of links to test descriptions, one per line.
-
-### Test description
-
-This is an example of a syntax test:
-
-    <#turtle-syntax-file-01> rdf:type rdft:TestTurtlePositiveSyntax ;
-       mf:name    "turtle-syntax-file-01" ;
-       rdfs:comment "Further description of the test" ;
-       mf:action  <turtle-syntax-file-01.ttl> ;
-       mf:result  <turtle-eval-struct-01.nt> .
+along with one or more individual EARL reports and generates a rollup report in
+HTML+RDFa in [ReSpec][] format.
 
 ## Individual EARL reports
-
 Results for individual implementations should be specified in Turtle form, but
 may be specified in an any compatible RDF serialization (JSON-LD is presumed to
 be a cached rollup report). The report is composed of `Assertion` declarations
@@ -75,9 +46,35 @@ of the following form:
 If not found, the IRI identified by `doap:developer`
 will be dereferenced and is presumed to provide a [FOAF]() profile of the developer.
 
-## Usage
+## Manifest query
+The test manifest is used to generate `earl:TestCase` entries for each test
+described in the test manifest. It will also summarize each test, including
+any input and result files associated with the tests. The built-in query
+is based on the [standard RDF WG format](). Alternative manifest formats
+can be used by specifying a customized manifest query. The default query
+is the following:
+
+    PREFIX dc: <http://purl.org/dc/terms/>
+    PREFIX mf: <http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#>
+    PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+
+    SELECT ?lh ?uri ?title ?description ?testAction ?testResult
+    WHERE {
+      ?uri mf:name ?title; mf:action ?testAction.
+      OPTIONAL { ?uri rdfs:comment ?description. }
+      OPTIONAL { ?uri mf:result ?testResult. }
+      OPTIONAL { [ mf:entries ?lh] . ?lh rdf:first ?uri . }
+    }
+
+If any result has a non-null `?lh`, it is taken as the list head and used
+to maintain the list order within `earl:tests`.
+
+## Report generation template
+The report template is in [ReSpec][] form using [Haml]() to generate individual report elements.
 
-The `earl` command may be used to directly create a report from zero or more input files, which are themselves [EARL][] report.
+## Usage
+The `earl-report` command may be used to directly create a report from zero or more input files, which are themselves [EARL][] report.
 
     gem install earl-report
     
@@ -86,12 +83,15 @@ The `earl` command may be used to directly create a report from zero or more inp
       --tempate [FILE]  # Location of report template file; returns default if not specified
       --bibRef          # The default ReSpec-formatted bibliographic reference for the report
       --name            # The name of the software being reported upon
-      manifest          # one or more test manifests used to define test descriptions
+      --manifest FILE   # a test manifest used to define test descriptions
+      --base URI        # Base URI to by applied when parsing test manifest
+      --query FILE      # Alternative SPARQL query for extracting information from manifest
       report*           # one or more EARL report in most RDF formats
 
-## Report generation template
-
-The report template is in ReSpec form using [Haml]() to generate individual elements.
+### Initialization File
+`earl-report` can take defaults for options from an initialization file.
+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.
 
 ## License
 

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.1.0

data/bin/earl-report

@@ -4,16 +4,21 @@ $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
 
 require 'earl_report'
 require 'getoptlong'
+require 'yaml'
 
 def run(input, options)
 end
 
 OPT_ARGS = [
+  ["--base",              GetoptLong::REQUIRED_ARGUMENT,"Base URI to use when loading test manifest"],
   ["--bibRef",            GetoptLong::REQUIRED_ARGUMENT,"ReSpec BibRef of specification being reported upon"],
   ["--format", "-f",      GetoptLong::REQUIRED_ARGUMENT,"Format of output, one of 'ttl', 'json', or 'html'"],
   ["--json",              GetoptLong::NO_ARGUMENT,      "Input is a JSON-LD formatted result"],
+  ["--manifest",          GetoptLong::REQUIRED_ARGUMENT,"Test manifest"],
   ["--name",              GetoptLong::REQUIRED_ARGUMENT,"Name of specification"],
   ["--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"],
   ["--template",          GetoptLong::OPTIONAL_ARGUMENT,"Specify or return default report template"],
   ["--verbose",           GetoptLong::NO_ARGUMENT,      "Detail on execution"],
   ["--help", "-?",        GetoptLong::NO_ARGUMENT,      "This message"]
@@ -22,6 +27,9 @@ def usage
   STDERR.puts %{
     Generate EARL report for mutliple test results against a test manifest.
     
+    Options are initialized by reading optional run-control file '.earl' in the local directory,
+    if it exists.
+    
     Usage: #{$0} [options] test-manifest test-result ...
   }.gsub(/^    /, '')
   width = OPT_ARGS.map do |o|
@@ -42,13 +50,20 @@ opts = GetoptLong.new(*OPT_ARGS.map {|o| o[0..-2]})
 options = {
   :format => :html,
   :io => STDOUT}
+options.merge!(YAML.load(File.open ".earl")) if File.exist?(".earl")
 
 opts.each do |opt, arg|
   case opt
+  when '--base'         then options[:base] = arg
   when '--bibRef'       then options[:bibRef] = arg
   when '--format'       then options[:format] = arg.to_sym
+  when '--manifest'     then options[:manifest] = arg
+  when '--query'        then options[:manifest] = arg
+  when '--base'         then options[:base] = arg
+  when '--json'         then options[:json] = true
   when '--name'         then options[:name] = arg
   when '--output'       then options[:io] = File.open(arg, "w")
+  when '--rc'           then options[:rc] = true
   when '--template'     then options[:template] = arg
   when '--verbose'      then options[:verbose] = true
   when '--help'         then usage
@@ -57,6 +72,19 @@ opts.each do |opt, arg|
   end
 end
 
+# Replace query from a specified file, with the query itself
+if options.has_key?(:query) && File.exist?(options[:query])
+  options[:query] = File.read(options[:query])
+end
+
+# Write run-control file to output
+if options.has_key?(:rc)
+  io = options.delete(:io) || STDOUT
+  options.delete_if {|k, v| [:rc, :json, :output, :verbose].include?(k)}
+  io.puts options.to_yaml
+  exit 0
+end
+
 # If requesting template, just return it
 if options.has_key?(:template) && options[:template].empty?
   File.open(File.expand_path("../../lib/earl_report/views/earl_report.html.haml", __FILE__)) do |f|
@@ -64,5 +92,5 @@ if options.has_key?(:template) && options[:template].empty?
   end
 else
   earl = EarlReport.new(*ARGV, options)
-  earl.generate(options.merge(:source_files => ARGV))
+  earl.generate(options)
 end

data/lib/earl_report.rb

@@ -8,19 +8,36 @@ require 'haml'
 # Instantiate a new class using one or more input graphs
 class EarlReport
   attr_reader :graph
+
+  MANIFEST_QUERY = %(
+    PREFIX dc: <http://purl.org/dc/terms/>
+    PREFIX mf: <http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#>
+    PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+
+    SELECT ?lh ?uri ?title ?description ?testAction ?testResult
+    WHERE {
+      ?uri mf:name ?title; mf:action ?testAction.
+      OPTIONAL { ?uri rdfs:comment ?description. }
+      OPTIONAL { ?uri mf:result ?testResult. }
+      OPTIONAL { [ mf:entries ?lh] . ?lh rdf:first ?uri . }
+    }
+  ).freeze
+
   TEST_SUBJECT_QUERY = %(
     PREFIX doap: <http://usefulinc.com/ns/doap#>
     PREFIX foaf: <http://xmlns.com/foaf/0.1/>
     
-    SELECT DISTINCT ?uri ?name ?developer ?dev_name ?dev_type ?doap_desc ?homepage ?language
+    SELECT DISTINCT ?uri ?name ?doapDesc ?homepage ?language ?developer ?devName ?devType ?devHomepage
     WHERE {
       ?uri a doap:Project; doap:name ?name .
       OPTIONAL { ?uri doap:developer ?developer .}
       OPTIONAL { ?uri doap:homepage ?homepage . }
-      OPTIONAL { ?uri doap:description ?doap_desc . }
+      OPTIONAL { ?uri doap:description ?doapDesc . }
       OPTIONAL { ?uri doap:programming-language ?language . }
-      OPTIONAL { ?developer foaf:name ?dev_name .}
-      OPTIONAL { ?developer a ?dev_type . }
+      OPTIONAL { ?developer foaf:name ?devName .}
+      OPTIONAL { ?developer a ?devType . }
+      OPTIONAL { ?developer foaf:homepage ?devHomepage . }
     }
   ).freeze
 
@@ -35,7 +52,7 @@ class EarlReport
         ?subject a doap:Project; doap:name ?name
       }
     }
-  )
+  ).freeze
 
   ASSERTION_QUERY = %(
     PREFIX earl: <http://www.w3.org/ns/earl#>
@@ -49,8 +66,39 @@ class EarlReport
         earl:subject ?subject;
         earl:test ?test ] .
     }
+    ORDER BY ?subject
   ).freeze
 
+  TEST_CONTEXT = {
+    "@vocab" =>   "http://www.w3.org/ns/earl#",
+    "foaf:homepage" => {"@type" => "@id"},
+    dc:           "http://purl.org/dc/terms/",
+    doap:         "http://usefulinc.com/ns/doap#",
+    earl:         "http://www.w3.org/ns/earl#",
+    mf:           "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#",
+    foaf:         "http://xmlns.com/foaf/0.1/",
+    rdfs:         "http://www.w3.org/2000/01/rdf-schema#",
+    assertedBy:   {"@type" => "@id"},
+    assertions:   {"@type" => "@id", "@container" => "@list"},
+    bibRef:       {"@id" => "dc:bibliographicCitation"},
+    description:  {"@id" => "dc:description"},
+    developer:    {"@id" => "doap:developer", "@type" => "@id", "@container" => "@set"},
+    doapDesc:     {"@id" => "doap:description"},
+    homepage:     {"@id" => "doap:homepage", "@type" => "@id"},
+    label:        {"@id" => "rdfs:label"},
+    language:     {"@id" => "doap:programming-language"},
+    mode:         {"@type" => "@id"},
+    name:         {"@id" => "doap:name"},
+    outcome:      {"@type" => "@id"},
+    subject:      {"@type" => "@id"},
+    test:         {"@type" => "@id"},
+    testAction:   {"@id" => "mf:action", "@type" => "@id"},
+    testResult:   {"@id" => "mf:result", "@type" => "@id"},
+    tests:        {"@type" => "@id", "@container" => "@list"},
+    testSubjects: {"@type" => "@id", "@container" => "@list"},
+    title:        {"@id" => "dc:title"}
+  }.freeze
+
   # 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
@@ -60,18 +108,36 @@ class EarlReport
   # @param [Array<String>] *files Assertions
   # @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] :manifest Test manifest
+  # @option options [String] :name Name of specification
+  # @option options [String] :query
+  #   Query, or file containing query for extracting information from Test manifest
   def initialize(*files)
     @options = files.last.is_a?(Hash) ? files.pop.dup : {}
-    @graph = RDF::Graph.new
+    @options[:query] ||= MANIFEST_QUERY
+    raise "Test Manifest must be specified with :manifest option" unless @options[:manifest] || @options[:json]
+    @files = files
     @prefixes = {}
+    if @options[:json]
+      @json_hash = ::JSON.parse(File.read(files.first))
+      return
+    end
+
+    # Load manifest, possibly with base URI
+    status "read #{@options[:manifest]}"
+    man_opts = {}
+    man_opts[:base_uri] = RDF::URI(@options[:base]) if @options[:base]
+    @graph = RDF::Graph.load(@options[:manifest], man_opts)
+    status "  loaded #{@graph.count} triples"
+
+    # Read test assertion files
     files.flatten.each do |file|
       status "read #{file}"
-      file_graph = case file
-      when /\.jsonld/
-        @json_hash = ::JSON.parse(File.read(file))
-        return
-      else RDF::Graph.load(file)
-      end
+      file_graph = RDF::Graph.load(file)
       status "  loaded #{file_graph.count} triples"
       @graph << file_graph
     end
@@ -96,7 +162,7 @@ class EarlReport
     # Load developers referenced from Test Subjects
     SPARQL.execute(TEST_SUBJECT_QUERY, @graph).each do |solution|
       # Load DOAP definitions
-      if solution[:developer] && !solution[:dev_name] # not loaded
+      if solution[:developer] && !solution[:devName] # not loaded
         status "read description for #{solution[:developer].inspect}"
         begin
           foaf_graph = RDF::Graph.load(solution[:developer])
@@ -116,37 +182,28 @@ class EarlReport
   #
   # @param [Hash{Symbol => Object}] options
   # @option options [Symbol] format (:html)
-  # @option options [String] :bibRef
-  #   ReSpec bibliography reference for specification being tested
-  # @option options [Array<String>] :source_files
-  #   Used for referencing the files used to generate this report
   # @option options[IO] :io
   #   Optional `IO` to output results
   # @return [String] serialized graph, if `io` is nil
   def generate(options = {})
-    options = {
-      format:       :html,
-      bibRef:       "[[TURTLE]]",
-      name:         "Turtle Test Results",
-    }.merge(options)
+    options = {:format => :html}.merge(options)
 
     io = options[:io]
 
     status("generate: #{options[:format]}")
     ##
     # Retrieve Hashed information in JSON-LD format
-    hash = json_hash(options)
     case options[:format]
     when :jsonld, :json
-      json = hash.to_json(JSON::LD::JSON_STATE)
+      json = json_hash.to_json(JSON::LD::JSON_STATE)
       io.write(json) if io
       json
     when :turtle, :ttl
       if io
-        earl_turtle(options.merge(:json_hash => hash))
+        earl_turtle(options)
       else
         io = StringIO.new
-        earl_turtle(:json_hash => hash, :io => io)
+        earl_turtle(options.merge(:io => io))
         io.rewind
         io.read
       end
@@ -155,8 +212,7 @@ class EarlReport
         File.read(File.expand_path('../earl_report/views/earl_report.html.haml', __FILE__))
 
       # Generate HTML report
-      html = Haml::Engine.new(template, :format => :xhtml)
-        .render(self, :tests => hash, :source_files => options.fetch(:source_files, []))
+      html = Haml::Engine.new(template, :format => :xhtml).render(self, :tests => json_hash)
       io.write(html) if io
       html
     else
@@ -173,39 +229,16 @@ class EarlReport
   ##
   # Return hashed EARL report in JSON-LD form
   # @return [Hash]
-  def json_hash(options)
+  def json_hash
     @json_hash ||= begin
       # Customized JSON-LD output
       {
-        "@context" => {
-          dc:           "http://purl.org/dc/terms/",
-          doap:         "http://usefulinc.com/ns/doap#",
-          earl:         "http://www.w3.org/ns/earl#",
-          mf:           "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#",
-          foaf:         "http://xmlns.com/foaf/0.1/",
-          rdfs:         "http://www.w3.org/2000/01/rdf-schema#",
-          assertedBy:   {"@id" => "earl:assertedBy", "@type" => "@id"},
-          bibRef:       {"@id" => "dc: bibliographicCitation"},
-          description:  {"@id" => "dc:description"},
-          developer:    {"@id" => "doap:developer", "@type" => "@id", "@container" => "@set"},
-          homepage:     {"@id" => "doap:homepage", "@type" => "@id"},
-          doap_desc:    {"@id" => "doap:description"},
-          language:     {"@id" => "doap:programming-language"},
-          testAction:   {"@id" => "mf:action", "@type" => "@id"},
-          testResult:   {"@id" => "mf:result", "@type" => "@id"},
-          label:        {"@id" => "rdfs:label"},
-          mode:         {"@id" => "earl:mode", "@type" => "@id"},
-          name:         {"@id" => "doap:name"},
-          outcome:      {"@id" => "earl:outcome", "@type" => "@id"},
-          result:       {"@id" => "earl:result"},
-          subject:      {"@id" => "earl:subject", "@type" => "@id"},
-          test:         {"@id" => "earl:test", "@type" => "@id"},
-          title:        {"@id" => "dc:title"}
-        },
+        "@context" => TEST_CONTEXT,
         "@id"          => "",
         "@type"        => %w(earl:Software doap:Project),
-        'name'         => options[:name],
-        'bibRef'       => options[:bibRef],
+        "assertions"   => @files,
+        'name'         => @options[:name],
+        'bibRef'       => @options[:bibRef],
         'testSubjects' => json_test_subject_info,
         'tests'        => json_result_info
       }
@@ -217,69 +250,87 @@ class EarlReport
   # @return [Array]
   def json_test_subject_info
     # Get the set of subjects
-    ts_info = {}
-    SPARQL.execute(TEST_SUBJECT_QUERY, @graph).each do |solution|
-      status "solution #{solution.to_hash.inspect}"
-      info = ts_info[solution[:uri].to_s] ||= {}
-      %w(name doap_desc homepage language).each do |prop|
-        info[prop] = solution[prop.to_sym].to_s if solution[prop.to_sym]
-      end
-      if solution[:dev_name]
-        dev_type = solution[:dev_type].to_s =~ /Organization/ ? "foaf:Organization" : "foaf:Person"
-        dev = {'@type' => dev_type}
-        dev['@id'] = solution[:developer].to_s if solution[:developer].uri?
-        dev['foaf:name'] = solution[:dev_name].to_s if solution[:dev_name]
-        (info['developer'] ||= []) << dev
+    @subject_info ||= begin
+      ts_info = {}
+      SPARQL.execute(TEST_SUBJECT_QUERY, @graph).each do |solution|
+        status "solution #{solution.to_hash.inspect}"
+        info = ts_info[solution[:uri].to_s] ||= {}
+        %w(name doapDesc homepage language).each do |prop|
+          info[prop] = solution[prop.to_sym].to_s if solution[prop.to_sym]
+        end
+        if solution[:devName]
+          dev_type = solution[:devType].to_s =~ /Organization/ ? "foaf:Organization" : "foaf:Person"
+          dev = {'@type' => dev_type}
+          dev['@id'] = solution[:developer].to_s if solution[:developer].uri?
+          dev['foaf:name'] = solution[:devName].to_s if solution[:devName]
+          dev['foaf:homepage'] = solution[:devHomepage].to_s if solution[:devHomepage]
+          (info['developer'] ||= []) << dev
+        end
+        info['developer'] = info['developer'].uniq
       end
-      info['developer'] = info['developer'].uniq
-    end
 
-    # Map ids and values to array entries
-    ts_info.keys.map do |id|
-      info = ts_info[id]
-      subject = Hash.ordered
-      subject["@id"] = id
-      subject["@type"] = %w(earl:TestSubject doap:Project)
-      %w(name developer doap_desc homepage language).each do |prop|
-        subject[prop] = info[prop] if info[prop]
+      # Map ids and values to array entries
+      ts_info.keys.sort.map do |id|
+        info = ts_info[id]
+        subject = Hash.ordered
+        subject["@id"] = id
+        subject["@type"] = %w(earl:TestSubject doap:Project)
+        %w(name developer doapDesc homepage language).each do |prop|
+          subject[prop] = info[prop] if info[prop]
+        end
+        subject
       end
-      subject
     end
   end
-  
+
   ##
-  # Return result information for each test
+  # Return result information for each test.
+  # This counts on hash maintaining insertion order
   #
   # @return [Array]
   def json_result_info
     test_cases = {}
+    subjects = json_test_subject_info.map {|s| s['@id']}
 
-    @graph.query(:predicate => MF['entries']) do |stmt|
-      # Iterate through the test manifest and write out a TestCase
-      # for each test
-      RDF::List.new(stmt.object, @graph).map do |tc|
-        tc_hash = {}
-        tc_hash['@id'] = tc.to_s
-        tc_hash['@type'] = %w(earl:TestCriterion earl:TestCase)
-
-        # Extract important properties
-        @graph.query(:subject => tc).each do |tc_stmt|
-          case tc_stmt.predicate.to_s
-          when MF['name'].to_s
-            tc_hash['title'] = tc_stmt.object.to_s
-          when RDF::RDFS.comment.to_s
-            tc_hash['description'] = tc_stmt.object.to_s
-          when MF.action.to_s
-            tc_hash['testAction'] = tc_stmt.object.to_s
-          when MF.result.to_s
-            tc_hash['testResult'] = tc_stmt.object.to_s
-          else
-            #STDERR.puts "TC soln: #{tc_stmt.inspect}"
-          end
-        end
+    # Hash test cases by URI
+    solutions = SPARQL.execute(@options[:query], @graph)
+      .to_a
+      .inject({}) {|memo, soln| memo[soln[:uri]] = soln; memo}
+
+    # If test cases are in a list, maintain order
+    solution_list = if first_soln = solutions.values.detect {|s| s[:lh]}
+      RDF::List.new(first_soln[:lh], @graph)
+    else
+      solutions.keys  # Any order will do
+    end
 
-        test_cases[tc.to_s] = tc_hash
+    # Collect each TestCase
+    solution_list.each do |uri|
+      solution = solutions[uri]
+      tc_hash = {
+        '@id' => uri.to_s,
+        '@type' => %w(earl:TestCriterion earl:TestCase),
+        'title' => solution[:title].to_s,
+        'testAction' => solution[:testAction].to_s,
+        'assertions' => []
+      }
+      tc_hash['description'] = solution[:description].to_s if solution[:description]
+      tc_hash['testResult'] = solution[:testResult].to_s if solution[:testResult]
+      
+      # Pre-initialize results for each subject to untested
+      subjects.each do |siri|
+        tc_hash['assertions'] << {
+          '@type' => 'earl:Assertion',
+          'test'    => uri.to_s,
+          'subject' => siri,
+          'result' => {
+            '@type' => 'earl:TestResult',
+            'outcome' => 'earl:untested'
+          }
+        }
       end
+
+      test_cases[uri.to_s] = tc_hash
     end
 
     raise "No test cases found" if test_cases.empty?
@@ -289,33 +340,23 @@ class EarlReport
     SPARQL.execute(ASSERTION_QUERY, @graph).each do |solution|
       tc = test_cases[solution[:test].to_s]
       STDERR.puts "No test case found for #{solution[:test]}: #{tc.inspect}" unless tc
-      STDERR.puts "Must have outcome earl:passed or earl:failed: #{solution[:outcome].inspect}" unless
-        [EARL.passed, EARL.failed].include?(solution[:outcome])
-      tc ||= {}
       subject = solution[:subject].to_s
-      ta_hash = {}
-      ta_hash['@type'] = 'earl:Assertion'
+      result_index = subjects.index(subject)
+      ta_hash = tc['assertions'][result_index]
       ta_hash['assertedBy'] = solution[:by].to_s
-      ta_hash['test'] = solution[:test].to_s
       ta_hash['mode'] = "earl:#{solution[:mode].to_s.split('#').last || 'automatic'}"
-      ta_hash['subject'] = subject
-      ta_hash['result'] = {
-        '@type' => 'earl:TestResult',
-        "outcome" => (solution[:outcome] == EARL.passed ? 'earl:passed' : 'earl:failed')
-      }
-      tc[subject] = ta_hash
+      ta_hash['result']['outcome'] = "earl:#{solution[:outcome].to_s.split('#').last}"
     end
 
     test_cases.values
   end
-  
+
   ##
   # Output consoloated EARL report as Turtle
   # @param [IO, StringIO] io
   # @return [String]
   def earl_turtle(options)
     io = options[:io]
-    json_hash = options[:json_hash]
     # Write preamble
     {
       :dc       => RDF::DC,
@@ -334,24 +375,22 @@ class EarlReport
     io.puts
 
     # Write earl:Software for the report
-    io.puts %(<#{json_hash['@id']}> a earl:Software, doap:Project;)
-    io.puts %(  doap:homepage <#{json_hash['homepage']}>;)
-    io.puts %(  doap:name "#{json_hash['name']}".)
+    io.puts %{<#{json_hash['@id']}> a earl:Software, doap:Project;}
+    io.puts %{  doap:homepage <#{json_hash['homepage']}>;}
+    io.puts %{  doap:name "#{json_hash['name']}";}
+    io.puts %{  dc:bibliographicCitation "#{json_hash['bibRef']}";}
+    io.puts %{  earl:assertions\n}
+    io.puts %{    } + json_hash['assertions'].map {|a| as_resource(a)}.join(",\n    ") + ';'
+    io.puts %{  earl:testSubjects (\n}
+    io.puts %{    } + json_hash['testSubjects'].map {|a| as_resource(a['@id'])}.join("\n    ") + ');'
+    io.puts %{  earl:tests (\n}
+    io.puts %{    } + json_hash['tests'].map {|a| as_resource(a['@id'])}.join("\n    ") + ') .'
 
     # Test Cases
     # also collect each assertion definition
     test_cases = {}
     assertions = []
 
-    # Tests
-    json_hash['tests'].each do |test_case|
-      tc_desc =  test_cases[test_case['test']] ||= test_case.dup
-      test_case.keys.select {|k| k =~ /^http:/}.each do |ts_uri|
-        tc_desc[ts_uri] = test_case[ts_uri]['@id']
-        assertions << test_case[ts_uri]
-      end
-    end
-    
     # Write out each earl:TestSubject
     io.puts %(#\n# Subject Definitions\n#)
     json_hash['testSubjects'].each do |ts_desc|
@@ -360,14 +399,8 @@ class EarlReport
     
     # Write out each earl:TestCase
     io.puts %(#\n# Test Case Definitions\n#)
-    test_cases.keys.sort.each do |num|
-      io.write(tc_turtle(test_cases[num]))
-    end
-    
-    # Write out each earl:Assertion
-    io.puts %(#\n# Assertions\n#)
-    assertions.sort_by {|a| a['@id']}.each do |as_desc|
-      io.write(as_turtle(as_desc))
+    json_hash['tests'].each do |test_case|
+      io.write(tc_turtle(test_case))
     end
   end
   
@@ -376,19 +409,24 @@ class EarlReport
   # @param [Hash] desc
   # @return [String]
   def test_subject_turtle(desc)
-    developer = desc['developer']
     res = %(<#{desc['@id']}> a #{desc['@type'].join(', ')};\n)
     res += %(  doap:name "#{desc['name']}";\n)
-    res += %(  doap:description """#{desc['doap_desc']}""";\n)     if desc['doap_desc']
+    res += %(  doap:description """#{desc['doapDesc']}""";\n)     if desc['doapDesc']
     res += %(  doap:programming-language "#{desc['language']}";\n) if desc['language']
-    if developer && developer['@id']
-      res += %(  doap:developer <#{developer['@id']}> .\n\n)
-      res += %(<#{developer['@id']}> a #{[developer['@type']].flatten.join(', ')};\n)
-      res += %(  foaf:name "#{developer['foaf:name']}" .\n)
-    elsif developer
-      res += %(  doap:developer [ a #{developer['@type'] || "foaf:Person"}; foaf:name "#{developer['foaf:name']}"] .\n)
-    else
-      res += %(  .\n)
+    res += %( .\n\n)
+
+    [desc['developer']].flatten.each do |developer|
+      if developer['@id']
+        res += %(<#{desc['@id']}> doap:developer <#{developer['@id']}> .\n\n)
+        res += %(<#{developer['@id']}> a #{[developer['@type']].flatten.join(', ')};\n)
+        res += %(  foaf:homepage <#{developer['foaf:homepage']}>;\n) if developer['foaf:homepage']
+        res += %(  foaf:name "#{developer['foaf:name']}" .\n\n)
+      else
+        res += %(<#{desc['@id']}> doap:developer\n)
+        res += %(   [ a #{developer['@type'] || "foaf:Person"};\n)
+        res += %(     foaf:homepage <#{developer['foaf:homepage']}>;\n) if developer['foaf:homepage']
+        res += %(     foaf:name "#{developer['foaf:name']}" ] .\n\n)
+      end
     end
     res + "\n"
   end
@@ -398,12 +436,16 @@ class EarlReport
   # @prarm[Hash] desc
   # @return [String]
   def tc_turtle(desc)
-    res = %(<#{desc['@id']}> a #{[desc['@type']].flatten.join(', ')};\n)
-    res += %(  dc:title "#{desc['title']}";\n)
-    res += %(  dc:description """#{desc['description']}""";\n)
-    res += %(  mf:action <#{desc['testAction']}>;\n)
-    res += %(  mf:result <#{desc['testResult']}>;\n)
-    res + "\n"
+    res = %{#{as_resource desc['@id']} a #{[desc['@type']].flatten.join(', ')};\n}
+    res += %{  dc:title "#{desc['title']}";\n}
+    res += %{  dc:description """#{desc['description']}""";\n} if desc.has_key?('description')
+    res += %{  mf:result #{as_resource desc['testResult']};\n} if desc.has_key?('testResult')
+    res += %{  mf:action #{as_resource desc['testAction']};\n}
+    res += %{  earl:assertions (\n}
+    desc['assertions'].each do |as_desc|
+      res += as_turtle(as_desc)
+    end
+    res += %{  ) .\n\n}
   end
 
   ##
@@ -411,16 +453,18 @@ class EarlReport
   # @prarm[Hash] desc
   # @return [String]
   def as_turtle(desc)
-    res =  %([ a earl:Assertion;\n)
-    res += %(  earl:assertedBy <#{desc['assertedBy']}>;\n)
-    res += %(  earl:test <#{desc['test']}>;\n)
-    res += %(  earl:subject <#{desc['subject']}>;\n)
-    res += %(  earl:mode #{desc['mode']};\n)
-    res += %(  earl:result [ a earl:TestResult; earl:outcome #{desc['result']['outcome']}] ] .\n)
-    res += %(\n)
-    res
+    res =  %(    [ a earl:Assertion;\n)
+    res += %(      earl:assertedBy #{as_resource desc['assertedBy']};\n) if desc['assertedBy']
+    res += %(      earl:test #{as_resource desc['test']};\n)
+    res += %(      earl:subject #{as_resource desc['subject']};\n)
+    res += %(      earl:mode #{desc['mode']};\n) if desc['mode']
+    res += %(      earl:result [ a earl:TestResult; earl:outcome #{desc['result']['outcome']} ]]\n)
   end
   
+  def as_resource(resource)
+    resource[0,2] == '_:' ? resource : "<#{resource}>"
+  end
+
   def status(message)
     puts message if @options[:verbose]
   end