json-ld 1.99.2 → 2.0.0.beta1

data/spec/reader_spec.rb

@@ -7,6 +7,9 @@ describe JSON::LD::Reader do
   let!(:doap) {File.expand_path("../../etc/doap.jsonld", __FILE__)}
   let!(:doap_nt) {File.expand_path("../../etc/doap.nt", __FILE__)}
   let!(:doap_count) {File.open(doap_nt).each_line.to_a.length}
+  let(:logger) {RDF::Spec.logger}
+
+  after(:each) {|example| puts logger.to_s if example.exception}
 
   it_behaves_like 'an RDF::Reader' do
     let(:reader_input) {File.read(doap)}
@@ -32,7 +35,7 @@ describe JSON::LD::Reader do
   context "when validating", pending: ("JRuby support for jsonlint" if RUBY_ENGINE == "jruby") do
     it "detects invalid JSON" do
       expect do |b|
-        described_class.new(StringIO.new(%({"a": "b", "a": "c"})), validate: true).each_statement(&b)
+        described_class.new(StringIO.new(%({"a": "b", "a": "c"})), validate: true, logger: false).each_statement(&b)
       end.to raise_error(RDF::ReaderError)
     end
   end

data/spec/spec_helper.rb

@@ -14,7 +14,6 @@ require 'rdf/spec/matchers'
 require 'yaml'
 require 'restclient/components'
 require 'rack/cache'
-require 'matchers'
 begin
   require 'simplecov'
   require 'coveralls'

data/spec/streaming_writer_spec.rb

@@ -5,6 +5,10 @@ require 'rdf/spec/writer'
 require 'json/ld/streaming_writer'
 
 describe JSON::LD::StreamingWriter do
+  let(:logger) {RDF::Spec.logger}
+
+  after(:each) {|example| puts logger.to_s if example.exception}
+
   it_behaves_like 'an RDF::Writer' do
     let(:writer) {JSON::LD::Writer.new(StringIO.new(""), stream: true)}
   end
@@ -13,11 +17,11 @@ describe JSON::LD::StreamingWriter do
     it "should use full URIs without base" do
       input = %(<http://a/b> <http://a/c> <http://a/d> .)
       obj = serialize(input)
-      expect(parse(obj.to_json, format: :jsonld)).to be_equivalent_graph(parse input)
+      expect(parse(obj.to_json, format: :jsonld)).to be_equivalent_graph(parse(input), logger: logger)
       expect(obj).to produce([{
         '@id'         => "http://a/b",
         "http://a/c"  => [{"@id" => "http://a/d"}]
-      }], @debug)
+      }], logger)
     end
 
     it "writes multiple kinds of statements" do
@@ -28,7 +32,7 @@ describe JSON::LD::StreamingWriter do
         <https://senet.org/gm> <https://senet.org/ns#urlkey> "rhythm-tengoku" .
       )
       obj = serialize(input)
-      expect(parse(obj.to_json, format: :jsonld)).to be_equivalent_graph(parse input)
+      expect(parse(obj.to_json, format: :jsonld)).to be_equivalent_graph(parse(input), logger: logger)
       expect(obj).to eql JSON.parse(%{[{
         "@id": "https://senet.org/gm",
         "@type": ["http://vocab.org/frbr/core#Work"],
@@ -46,8 +50,8 @@ describe JSON::LD::StreamingWriter do
         <http://example.com/test-cases/0002> a :TestCase .
       )
       obj = serialize(input)
-      expect(parse(obj.to_json, format: :jsonld)).to be_equivalent_graph(parse input)
-      expect(obj).to eql JSON.parse(%{[
+      expect(parse(obj.to_json, format: :jsonld)).to be_equivalent_graph(parse(input), logger: logger)
+      expect(obj).to contain_exactly *JSON.parse(%{[
         {"@id": "http://example.com/test-cases/0001", "@type": ["http://www.w3.org/2006/03/test-description#TestCase"]},
         {"@id": "http://example.com/test-cases/0002", "@type": ["http://www.w3.org/2006/03/test-description#TestCase"]}
       ]})
@@ -88,7 +92,7 @@ describe JSON::LD::StreamingWriter do
       context title do
         subject {serialize(input)}
         it "matches expected json" do
-          expect(subject).to produce(JSON.parse(matches), @debug)
+          expect(subject).to contain_exactly *JSON.parse(matches)
         end
       end
     end
@@ -103,13 +107,15 @@ describe JSON::LD::StreamingWriter do
         describe m.name do
           m.entries.each do |t|
             next unless t.positiveTest? && !t.property('input').include?('0016')
-            t.debug = ["test: #{t.inspect}", "source: #{t.input}"]
+            t.logger = RDF::Spec.logger
+            t.logger.info "test: #{t.inspect}"
+            t.logger.info "source: #{t.input}"
             specify "#{t.property('input')}: #{t.name}" do
               repo = RDF::Repository.load(t.input_loc, format: :nquads)
-              jsonld = JSON::LD::Writer.buffer(stream: true, context: ctx, debug: t.debug) do |writer|
+              jsonld = JSON::LD::Writer.buffer(stream: true, context: ctx, logger: t.logger) do |writer|
                 writer << repo
               end
-              t.debug << "Generated: #{jsonld}"
+              t.logger.info "Generated: #{jsonld}"
 
               # And then, re-generate jsonld as RDF
               expect(parse(jsonld, format: :jsonld)).to be_equivalent_graph(repo, t)
@@ -129,8 +135,9 @@ describe JSON::LD::StreamingWriter do
   # Serialize ntstr to a string and compare against regexps
   def serialize(ntstr, options = {})
     g = ntstr.is_a?(String) ? parse(ntstr, options) : ntstr
-    @debug = [] << g.dump(:ttl)
-    result = JSON::LD::Writer.buffer(options.merge(debug: @debug, stream: true)) do |writer|
+    logger = RDF::Spec.logger
+    logger.info(g.dump(:ttl))
+    result = JSON::LD::Writer.buffer(options.merge(logger: logger, stream: true)) do |writer|
       writer << g
     end
     puts result if $verbose

data/spec/suite_helper.rb

@@ -32,7 +32,7 @@ module Fixtures
     end
 
     class Entry < JSON::LD::Resource
-      attr_accessor :debug
+      attr_accessor :logger
 
       # Base is expanded input file
       def base
@@ -79,14 +79,15 @@ module Fixtures
         property('@type').include?('jld:PositiveEvaluationTest')
       end
       
-      def trace; @debug.join("\n"); end
 
       # Execute the test
       def run(rspec_example = nil)
-        debug = @debug = ["test: #{inspect}", "source: #{input}"]
-        @debug << "context: #{context}" if context_loc
-        @debug << "options: #{options.inspect}" unless options.empty?
-        @debug << "frame: #{frame}" if frame_loc
+        logger = @logger = RDF::Spec.logger
+        logger.info "test: #{inspect}"
+        logger.info "source: #{input}"
+        logger.info "context: #{context}" if context_loc
+        logger.info "options: #{options.inspect}" unless options.empty?
+        logger.info "frame: #{frame}" if frame_loc
 
         options = if self.options[:useDocumentLoader]
           self.options.merge(documentLoader: Fixtures::SuiteTest.method(:documentLoader))
@@ -95,43 +96,41 @@ module Fixtures
         end
 
         if positiveTest?
-          @debug << "expected: #{expect rescue nil}" if expect_loc
+          logger.info "expected: #{expect rescue nil}" if expect_loc
           begin
             result = case testType
             when "jld:ExpandTest"
-              JSON::LD::API.expand(input_loc, options.merge(debug: debug))
+              JSON::LD::API.expand(input_loc, options.merge(logger: logger))
             when "jld:CompactTest"
-              JSON::LD::API.compact(input_loc, context_json['@context'], options.merge(debug: debug))
+              JSON::LD::API.compact(input_loc, context_json['@context'], options.merge(logger: logger))
             when "jld:FlattenTest"
-              JSON::LD::API.flatten(input_loc, context_loc, options.merge(debug: debug))
+              JSON::LD::API.flatten(input_loc, context_loc, options.merge(logger: logger))
             when "jld:FrameTest"
-              JSON::LD::API.frame(input_loc, frame_loc, options.merge(debug: debug))
+              JSON::LD::API.frame(input_loc, frame_loc, options.merge(logger: logger))
             when "jld:FromRDFTest"
               # Use an array, to preserve input order
               repo = RDF::NQuads::Reader.open(input_loc) do |reader|
                 reader.each_statement.to_a
               end.extend(RDF::Enumerable)
-              @debug << "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
-              JSON::LD::API.fromRdf(repo, options.merge(debug: debug))
+              logger.info "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
+              JSON::LD::API.fromRdf(repo, options.merge(logger: logger))
             when "jld:ToRDFTest"
-              repo = RDF::Repository.new
-              JSON::LD::API.toRdf(input_loc, options.merge(debug: debug)) do |statement|
-                repo << statement
+              JSON::LD::API.toRdf(input_loc, options.merge(logger: logger)).map do |statement|
+                to_quad(statement)
               end
-              repo
             else
               fail("Unknown test type: #{testType}")
             end
             if evaluationTest?
               if testType == "jld:ToRDFTest"
-                expected = RDF::Repository.new << RDF::NQuads::Reader.new(expect)
+                expected = expect
                 rspec_example.instance_eval {
-                  expect(result).to be_equivalent_graph(expected, debug)
+                  expect(result.sort.join("")).to produce(expected, logger)
                 }
               else
                 expected = JSON.load(expect)
                 rspec_example.instance_eval {
-                  expect(result).to produce(expected, debug)
+                  expect(result).to produce(expected, logger)
                 }
               end
             else
@@ -145,26 +144,28 @@ module Fixtures
             fail("Invalid Frame: #{e.message}")
           end
         else
-          debug << "expected: #{property('expect')}" if property('expect')
+          logger.info "expected: #{property('expect')}" if property('expect')
           t = self
           rspec_example.instance_eval do
             if t.evaluationTest?
               expect do
                 case t.testType
                 when "jld:ExpandTest"
-                  JSON::LD::API.expand(t.input_loc, options.merge(debug: debug))
+                  JSON::LD::API.expand(t.input_loc, options.merge(logger: logger))
                 when "jld:CompactTest"
-                  JSON::LD::API.compact(t.input_loc, t.context_json['@context'], options.merge(debug: debug))
+                  JSON::LD::API.compact(t.input_loc, t.context_json['@context'], options.merge(logger: logger))
                 when "jld:FlattenTest"
-                  JSON::LD::API.flatten(t.input_loc, t.context_loc, options.merge(debug: debug))
+                  JSON::LD::API.flatten(t.input_loc, t.context_loc, options.merge(logger: logger))
                 when "jld:FrameTest"
-                  JSON::LD::API.frame(t.input_loc, t.frame_loc, options.merge(debug: debug))
+                  JSON::LD::API.frame(t.input_loc, t.frame_loc, options.merge(logger: logger))
                 when "jld:FromRDFTest"
                   repo = RDF::Repository.load(t.input_loc)
-                  debug << "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
-                  JSON::LD::API.fromRdf(repo, options.merge(debug: debug))
+                  logger.info "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
+                  JSON::LD::API.fromRdf(repo, options.merge(logger: logger))
                 when "jld:ToRDFTest"
-                  JSON::LD::API.toRdf(t.input_loc, options.merge(debug: debug)) {}
+                  JSON::LD::API.toRdf(t.input_loc, options.merge(logger: logger)).map do |statement|
+                    t.to_quad(statement)
+                  end
                 else
                   success("Unknown test type: #{testType}")
                 end

data/spec/suite_to_rdf_spec.rb

@@ -9,8 +9,6 @@ describe JSON::LD do
     describe m.name do
       m.entries.each do |t|
         specify "#{t.property('input')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
-          skip "Native value fidelity" if %w(toRdf-0035-in.jsonld).include?(t.property('input'))
-          pending "Generalized RDF" if %w(toRdf-0118-in.jsonld).include?(t.property('input'))
           t.run self
         end
       end

data/spec/to_rdf_spec.rb

@@ -3,7 +3,7 @@ $:.unshift "."
 require 'spec_helper'
 
 describe JSON::LD::API do
-  before(:each) {@debug = []}
+  let(:logger) {RDF::Spec.logger}
 
   context ".toRdf" do
     it "should implement RDF::Enumerable" do
@@ -35,7 +35,7 @@ describe JSON::LD::API do
       }.each do |title, (js, ttl)|
         it title do
           ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-          expect(parse(js)).to be_equivalent_graph(ttl, trace: @debug, inputDocument: js)
+          expect(parse(js)).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
         end
       end
     end
@@ -52,7 +52,7 @@ describe JSON::LD::API do
       }.each do |title, (js, ttl)|
         it title do
           ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-          expect(parse(js)).to be_equivalent_graph(ttl, trace: @debug, inputDocument: js)
+          expect(parse(js)).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
         end
       end
       
@@ -82,7 +82,7 @@ describe JSON::LD::API do
         }.each do |title, (js, ttl)|
           it title do
             ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-            expect(parse(js, base: "http://example.org/")).to be_equivalent_graph(ttl, trace: @debug, inputDocument: js)
+            expect(parse(js, base: "http://example.org/")).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
           end
         end
       end
@@ -111,7 +111,7 @@ describe JSON::LD::API do
       }.each do |title, (js, ttl)|
         it title do
           ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-          expect(parse(js)).to be_equivalent_graph(ttl, trace: @debug, inputDocument: js)
+          expect(parse(js)).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
         end
       end
     end
@@ -145,7 +145,7 @@ describe JSON::LD::API do
       }.each do |title, (js, ttl)|
         it title do
           ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-          expect(parse(js)).to be_equivalent_graph(ttl, trace: @debug, inputDocument: js)
+          expect(parse(js)).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
         end
       end
     end
@@ -194,7 +194,7 @@ describe JSON::LD::API do
       }.each do |title, (js, ttl)|
         it title do
           ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-          expect(parse(js)).to be_equivalent_graph(ttl, trace: @debug, inputDocument: js)
+          expect(parse(js)).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
         end
       end
     end
@@ -216,7 +216,7 @@ describe JSON::LD::API do
       }.each_pair do |title, (js, ttl)|
         it title do
           ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-          expect(parse(js)).to be_equivalent_graph(ttl, trace: @debug, inputDocument: js)
+          expect(parse(js)).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
         end
       end
     end
@@ -238,7 +238,7 @@ describe JSON::LD::API do
       }.each do |title, (js, ttl)|
         it title do
           ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-          expect(parse(js)).to be_equivalent_graph(ttl, trace: @debug, inputDocument: js)
+          expect(parse(js)).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
         end
       end
     end
@@ -277,7 +277,7 @@ describe JSON::LD::API do
       }.each do |title, (js, ttl)|
         it title do
           ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-          expect(parse(js)).to be_equivalent_graph(ttl, trace: @debug, inputDocument: js)
+          expect(parse(js)).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
         end
       end
     end
@@ -299,7 +299,7 @@ describe JSON::LD::API do
       }.each do |title, (js, ttl)|
         it title do
           ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-          expect(parse(js)).to be_equivalent_graph(ttl, trace: @debug, inputDocument: js)
+          expect(parse(js)).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
         end
       end
     end
@@ -360,7 +360,7 @@ describe JSON::LD::API do
       }.each do |title, (js, ttl)|
         it title do
           ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-          expect(parse(js)).to be_equivalent_graph(ttl, trace: @debug, inputDocument: js)
+          expect(parse(js)).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
         end
       end
     end
@@ -483,7 +483,7 @@ describe JSON::LD::API do
       }.each do |title, (js, ttl)|
         it title do
           ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-          expect(parse(js)).to be_equivalent_graph(ttl, base: "http://example/", trace: @debug, inputDocument: js)
+          expect(parse(js)).to be_equivalent_graph(ttl, base: "http://example/", logger: logger, inputDocument: js)
         end
       end
       
@@ -536,7 +536,7 @@ describe JSON::LD::API do
           }.each do |title, (js, ttl)|
             it title do
               ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-              expect(parse(js)).to be_equivalent_graph(ttl, trace: @debug, inputDocument: js)
+              expect(parse(js)).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
             end
           end
         end
@@ -572,7 +572,7 @@ describe JSON::LD::API do
           }.each do |title, (js, ttl)|
             it title do
               ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-              expect(parse(js)).to be_equivalent_graph(ttl, trace: @debug, inputDocument: js)
+              expect(parse(js)).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
             end
           end
         end
@@ -654,16 +654,15 @@ describe JSON::LD::API do
       }.each do |title, (js, ttl)|
         it title do
           ttl = "@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . #{ttl}"
-          expect(parse(js)).to be_equivalent_graph(ttl, trace: @debug, inputDocument: js)
+          expect(parse(js)).to be_equivalent_graph(ttl, logger: logger, inputDocument: js)
         end
       end
     end
   end
 
   def parse(input, options = {})
-    @debug = []
     graph = options[:graph] || RDF::Graph.new
-    options = {debug: @debug, validate: true, canonicalize: false}.merge(options)
+    options = {logger: logger, validate: true, canonicalize: false}.merge(options)
     JSON::LD::API.toRdf(StringIO.new(input), options) {|st| graph << st}
     graph
   end

data/spec/writer_spec.rb

@@ -4,6 +4,10 @@ require 'spec_helper'
 require 'rdf/spec/writer'
 
 describe JSON::LD::Writer do
+  let(:logger) {RDF::Spec.logger}
+
+  after(:each) {|example| puts logger.to_s if example.exception}
+
   it_behaves_like 'an RDF::Writer' do
     let(:writer) {JSON::LD::Writer.new(StringIO.new(""))}
   end
@@ -29,7 +33,7 @@ describe JSON::LD::Writer do
       expect(serialize(input)).to produce([{
         '@id'         => "http://a/b",
         "http://a/c"  => [{"@id" => "http://a/d"}]
-      }], @debug)
+      }], logger)
     end
 
     it "should use qname URIs with standard prefix" do
@@ -40,7 +44,7 @@ describe JSON::LD::Writer do
         },
         '@id'     => "foaf:b",
         "foaf:c"  => {"@id" => "foaf:d"}
-      }, @debug)
+      }, logger)
     end
 
     it "should use qname URIs with parsed prefix" do
@@ -65,7 +69,7 @@ describe JSON::LD::Writer do
         "dc:title" => {"@value" => "Rhythm Paradise","@language" => "en"},
         "senet:unofficialTitle" => {"@value" => "Rhythm Tengoku","@language" => "en"},
         "senet:urlkey" => "rhythm-tengoku"
-      }, @debug)
+      }, logger)
     end
 
     it "should use CURIEs with empty prefix" do
@@ -78,10 +82,10 @@ describe JSON::LD::Writer do
           },
           '@id' => ":b",
           ":c"    => {"@id" => ":d"}
-        }, @debug)
+        }, logger)
       rescue JSON::LD::JsonLdError, JSON::LD::JsonLdError, TypeError => e
         fail("#{e.class}: #{e.message}\n" +
-          "#{@debug.join("\n")}\n" +
+          "#{logger}\n" +
           "Backtrace:\n#{e.backtrace.join("\n")}")
       end
     end
@@ -93,7 +97,7 @@ describe JSON::LD::Writer do
         "@context" => {"foaf" => "http://xmlns.com/foaf/0.1/"},
         '@id'   => "foaf",
         "foaf"   => {"@id" => "foaf"}
-      }, @debug)
+      }, logger)
     end
     
     it "should not use CURIE with illegal local part" do
@@ -113,7 +117,7 @@ describe JSON::LD::Writer do
         },
         '@id'   => "db:Michael_Jackson",
         "dbo:artistOf" => {"@id" => "db:%28I_Can%27t_Make_It%29_Another_Day"}
-      }, @debug)
+      }, logger)
     end
 
     it "should not use provided node identifiers if :unique_bnodes set" do
@@ -139,7 +143,7 @@ describe JSON::LD::Writer do
           {'@id'  => "http://example.com/test-cases/0001", '@type' => ":TestCase"},
           {'@id'  => "http://example.com/test-cases/0002", '@type' => ":TestCase"}
         ]
-      }, @debug)
+      }, logger)
     end
 
     it "serializes Wikia OWL example" do
@@ -182,7 +186,7 @@ describe JSON::LD::Writer do
             "rdfs:subClassOf" => {"@id" => "_:a"}
           }
         ]
-      }, @debug)
+      }, logger)
     end
   end
 
@@ -217,8 +221,8 @@ describe JSON::LD::Writer do
   # Serialize ntstr to a string and compare against regexps
   def serialize(ntstr, options = {})
     g = ntstr.is_a?(String) ? parse(ntstr, options) : ntstr
-    @debug = [] << g.dump(:ttl)
-    result = JSON::LD::Writer.buffer(options.merge(debug: @debug)) do |writer|
+    logger.info g.dump(:ttl)
+    result = JSON::LD::Writer.buffer(options.merge(logger: logger)) do |writer|
       writer << g
     end
     if $verbose