Minor cleanup.

Author: gkellogg

lib/json/ld/expand.rb

@@ -132,13 +132,13 @@ def expand(input, active_property, context,
           unless (keys - KEYS_VALUE_LANGUAGE_TYPE_INDEX_DIRECTION).empty?
             # The result must not contain any keys other than @direction, @value, @language, @type, and @index. It must not contain both the @language key and the @type key. Otherwise, an invalid value object error has been detected and processing is aborted.
             raise JsonLdError::InvalidValueObject,
-            "value object has unknown keys: #{output_object.inspect}"
+              "value object has unknown keys: #{output_object.inspect}"
           end
 
           if keys.include?('@type') && !(keys & %w(@language @direction)).empty?
             # @type is inconsistent with either @language or @direction
             raise JsonLdError::InvalidValueObject,
-            "value object must not include @type with either @language or @direction: #{output_object.inspect}"
+              "value object must not include @type with either @language or @direction: #{output_object.inspect}"
           end
 
           output_object.delete('@language') if output_object.key?('@language') && Array(output_object['@language']).empty?

script/tc

@@ -99,13 +99,23 @@ def run_tc(man, tc, options)
       compare_results(tc, output, expected)
     when 'jld:FromRDFTest'
       repo = RDF::Repository.load(tc.input_loc, format: :nquads)
-      output = JSON::LD::API.fromRdf(repo, validate: true, **tc.options)
+      output = if options[:stream]
+        JSON.parse(JSON::LD::Writer.buffer(stream: true, validate: true, **tc.options) {|w| w << repo})
+      else
+        JSON::LD::API.fromRdf(repo, validate: true, **tc.options)
+      end
       expected = JSON.load(tc.expect) if tc.evaluationTest? && tc.positiveTest?
       compare_results(tc, output, expected)
     when 'jld:ToRDFTest'
       output = RDF::Repository.new.extend(RDF::Isomorphic)
-      JSON::LD::API.toRdf(tc.input_loc, **tc.options).map do |statement|
-        output << statement
+      if options[:stream]
+        JSON::LD::Reader.open(tc.input_loc, stream: true, **tc.options.merge(logger: false)) do |statement|
+          output << statement
+        end
+      else
+        JSON::LD::API.toRdf(tc.input_loc, **tc.options).map do |statement|
+          output << statement
+        end
       end
 
       if tc.evaluationTest? && tc.positiveTest?
@@ -122,7 +132,7 @@ def run_tc(man, tc, options)
             expected = RDF::Repository.new << RDF::NQuads::Reader.new(tc.expect, validate: false, logger: [])
             output.isomorphic?(expected) ? 'passed' : 'failed'
           end
-        rescue RDF::ReaderError
+        rescue RDF::ReaderError, JSON::LD::JsonLdError
           quads = JSON::LD::API.toRdf(tc.input_loc, tc.options.merge(validate: false)).map do |statement|
             # Not really RDF, try different test method
             tc.to_quad(statement)
@@ -131,14 +141,13 @@ def run_tc(man, tc, options)
           # FIXME: toRDF is outputing duplicate quads
           output = quads.sort.uniq.join("")
           output == tc.expect ? 'passed' : 'failed'
-        ensure
-          output = output.dump(:nquads, validate: false) rescue output.to_s unless output.is_a?(String)
         end
       else
         output.count > 0 ? 'passed' : 'failed'
       end
     end || "untested"
 
+    output = output.dump(:nquads, validate: false) rescue output.to_s if output.is_a?(RDF::Enumerable)
     puts "\nOutput:\n" + (tc.testType == 'jld:ToRDFTest' ? output : output.to_json(JSON::LD::JSON_STATE)) if !tc.syntaxTest? && options[:verbose]
 
     result = result ? 'failed' : 'passed' unless tc.positiveTest?
@@ -206,6 +215,7 @@ opts = GetoptLong.new(
   ["--earl", GetoptLong::NO_ARGUMENT],
   ["--quiet", "-q", GetoptLong::NO_ARGUMENT],
   ["--output", "-o", GetoptLong::REQUIRED_ARGUMENT],
+  ["--stream",   GetoptLong::NO_ARGUMENT],
   ["--validate", GetoptLong::NO_ARGUMENT],
   ["--verbose", "-v", GetoptLong::NO_ARGUMENT]
 )
@@ -217,6 +227,7 @@ def help(options)
   puts "      --earl:               Generate EARL report"
   puts "      --quiet:              Minimal output"
   puts "      --output:             Output to specified file"
+  puts "      --stream:             Use streaming RDF reader/writer"
   puts "      --validate:           Validate input"
   puts "      --verbose:            Verbose processing"
   puts "      --help,-?:            This message"
@@ -234,21 +245,25 @@ opts.each do |opt, arg|
   when '--quiet'
     options[:quiet] = true
     logger.level = Logger::FATAL
+  when '--stream'           then options[:stream] = true
   when '--validate'         then options[:validate] = true
   when '--verbose'          then options[:verbose] = true
   end
 end
 
 manifests = %w(expand compact flatten fromRdf html remote-doc toRdf).map do |man|
   "#{Fixtures::SuiteTest::SUITE}#{man}-manifest.jsonld"
-end + ["#{Fixtures::SuiteTest::FRAME_SUITE}frame-manifest.jsonld"]
+end +
+  ["#{Fixtures::SuiteTest::FRAME_SUITE}frame-manifest.jsonld"] +
+  ["#{Fixtures::SuiteTest::STREAM_SUITE}stream-toRdf-manifest.jsonld"]
 
 earl_preamble(options) if options[:earl]
 
 manifests.each do |man|
   Fixtures::SuiteTest::Manifest.open(man) do |m|
     m.entries.each do |tc|
       next unless ARGV.empty? || ARGV.any? {|n| tc.property('@id').match(/#{n}/) || tc.property('input').match(/#{n}/)}
+      options = {stream: true}.merge(options) if man.include?('stream')
       run_tc(man.sub(".jsonld", ""), tc, options)
     end
   end

spec/.gitignore

@@ -2,3 +2,4 @@
 /uri-cache/
 /json-ld-api
 /json-ld-framing
+/json-ld-streaming

spec/reader_spec.rb

@@ -43,40 +43,39 @@
     {
       plain: %q({
         "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
-         "@id": "_:bnode1",
-         "@type": "foaf:Person",
-         "foaf:homepage": "http://example.com/bob/",
-         "foaf:name": "Bob"
-       }),
-       leading_comment: %q(
-         // A comment before content
-         {
-           "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
-            "@id": "_:bnode1",
-            "@type": "foaf:Person",
-            "foaf:homepage": "http://example.com/bob/",
-            "foaf:name": "Bob"
-          }
-         ),
-       script: %q(<script type="application/ld+json">
-         {
-           "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
-            "@id": "_:bnode1",
-            "@type": "foaf:Person",
-            "foaf:homepage": "http://example.com/bob/",
-            "foaf:name": "Bob"
-          }
-         </script>),
-       script_comments: %q(<script type="application/ld+json">
-         // A comment before content
-         {
-           "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
-            "@id": "_:bnode1",
-            "@type": "foaf:Person",
-            "foaf:homepage": "http://example.com/bob/",
-            "foaf:name": "Bob"
-          }
-         </script>),
+        "@id": "_:bnode1",
+        "@type": "foaf:Person",
+        "foaf:homepage": "http://example.com/bob/",
+        "foaf:name": "Bob"
+      }),
+      leading_comment: %q(
+      // A comment before content
+      {
+        "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
+        "@id": "_:bnode1",
+        "@type": "foaf:Person",
+        "foaf:homepage": "http://example.com/bob/",
+        "foaf:name": "Bob"
+      }),
+      script: %q(<script type="application/ld+json">
+      {
+        "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
+        "@id": "_:bnode1",
+        "@type": "foaf:Person",
+        "foaf:homepage": "http://example.com/bob/",
+        "foaf:name": "Bob"
+      }
+      </script>),
+      script_comments: %q(<script type="application/ld+json">
+      // A comment before content
+      {
+        "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
+        "@id": "_:bnode1",
+        "@type": "foaf:Person",
+        "foaf:homepage": "http://example.com/bob/",
+        "foaf:name": "Bob"
+       }
+      </script>),
     }.each do |variant, src|
       context variant do
         subject {src}