json-ld 3.1.3 → 3.1.8

data/spec/suite_flatten_spec.rb

@@ -7,6 +7,8 @@ describe JSON::LD do
     m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}flatten-manifest.jsonld")
     describe m.name do
       m.entries.each do |t|
+        t.options[:remap_bnodes] = %w(#t0045).include?(t.property('@id'))
+
         specify "#{t.property('@id')}: #{t.name} unordered#{' (negative test)' unless t.positiveTest?}" do
           t.options[:ordered] = false
           if %w(#t0005).include?(t.property('@id'))
@@ -16,6 +18,8 @@ describe JSON::LD do
           end
         end
 
+        # Skip ordered tests when remapping bnodes
+        next if t.options[:remap_bnodes]
         specify "#{t.property('@id')}: #{t.name} ordered#{' (negative test)' unless t.positiveTest?}" do
           t.options[:ordered] = true
           if %w(#t0005).include?(t.property('@id'))

data/spec/suite_frame_spec.rb

@@ -7,13 +7,20 @@ describe JSON::LD do
     m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::FRAME_SUITE}frame-manifest.jsonld")
     describe m.name do
       m.entries.each do |t|
+        t.options[:remap_bnodes] = %w(#t0021 #tp021).include?(t.property('@id'))
+
         specify "#{t.property('@id')}: #{t.name} unordered#{' (negative test)' unless t.positiveTest?}" do
           t.options[:ordered] = false
           expect {t.run self}.not_to write.to(:error)
         end
 
+        # Skip ordered tests when remapping bnodes
+        next if t.options[:remap_bnodes]
         specify "#{t.property('@id')}: #{t.name} ordered#{' (negative test)' unless t.positiveTest?}" do
           t.options[:ordered] = true
+          if %w(#tp021).include?(t.property('@id'))
+            pending("changes due to blank node reordering")
+          end
           expect {t.run self}.not_to write.to(:error)
         end
       end

data/spec/suite_helper.rb

@@ -6,6 +6,8 @@ module RDF::Util
     LOCAL_PATHS = {
       "https://w3c.github.io/json-ld-api/tests/" => ::File.expand_path("../json-ld-api/tests", __FILE__) + '/',
       "https://w3c.github.io/json-ld-framing/tests/" => ::File.expand_path("../json-ld-framing/tests", __FILE__) + '/',
+      "https://w3c.github.io/json-ld-streaming/tests/" => ::File.expand_path("../json-ld-streaming/tests", __FILE__) + '/',
+      "https://json-ld.github.io/json-ld-star/tests/" => ::File.expand_path("../json-ld-star/tests", __FILE__) + '/',
       "file:" => ""
     }
 
@@ -74,6 +76,8 @@ module Fixtures
   module SuiteTest
     SUITE = RDF::URI("https://w3c.github.io/json-ld-api/tests/")
     FRAME_SUITE = RDF::URI("https://w3c.github.io/json-ld-framing/tests/")
+    STREAM_SUITE = RDF::URI("https://w3c.github.io/json-ld-streaming/tests/")
+    STAR_SUITE = RDF::URI("https://json-ld.github.io/json-ld-star/tests/")
 
     class Manifest < JSON::LD::Resource
       attr_accessor :manifest_url
@@ -199,8 +203,8 @@ module Fixtures
         logger.info "frame: #{frame}" if frame_loc
 
         options = self.options
-        unless options[:specVersion] == "json-ld-1.1"
-          skip "not a 1.1 test" 
+        if options[:specVersion] == "json-ld-1.0"
+          skip "1.0 test" 
           return
         end
 
@@ -221,21 +225,21 @@ module Fixtures
               JSON::LD::API.frame(input_loc, frame_loc, logger: logger, **options)
             when "jld:FromRDFTest"
               # Use an array, to preserve input order
-              repo = RDF::NQuads::Reader.open(input_loc) do |reader|
+              repo = RDF::NQuads::Reader.open(input_loc, rdfstar: options[:rdfstar]) do |reader|
                 reader.each_statement.to_a
               end.to_a.uniq.extend(RDF::Enumerable)
               logger.info "repo: #{repo.dump(self.id == '#t0012' ? :nquads : :trig)}"
               JSON::LD::API.fromRdf(repo, logger: logger, **options)
             when "jld:ToRDFTest"
               repo = RDF::Repository.new
-              JSON::LD::API.toRdf(input_loc, logger: logger, **options) do |statement|
-                # To properly compare values of rdf:language and i18n datatypes, normalize to lower case
-                if statement.predicate == RDF.to_uri + 'language'
-                  statement.object = RDF::Literal(statement.object.to_s.downcase) if statement.object.literal?
-                elsif statement.object.literal? && statement.object.datatype.to_s.start_with?('https://www.w3.org/ns/i18n#')
-                  statement.object.datatype = RDF::URI(statement.object.datatype.to_s.downcase)
+              if manifest_url.to_s.include?('stream')
+                JSON::LD::Reader.open(input_loc, stream: true, logger: logger, **options) do |statement|
+                  repo << statement
+                end
+              else
+                JSON::LD::API.toRdf(input_loc, rename_bnodes: false, logger: logger, **options) do |statement|
+                  repo << statement
                 end
-                repo << statement
               end
               logger.info "nq: #{repo.map(&:to_nquads)}"
               repo
@@ -254,12 +258,16 @@ module Fixtures
             end
             if evaluationTest?
               if testType == "jld:ToRDFTest"
-                expected = RDF::Repository.new << RDF::NQuads::Reader.new(expect, logger: [])
+                expected = RDF::Repository.new << RDF::NQuads::Reader.new(expect, rdfstar: options[:rdfstar], logger: [])
                 rspec_example.instance_eval {
                   expect(result).to be_equivalent_graph(expected, logger)
                 }
               else
                 expected = JSON.load(expect)
+
+                # If called for, remap bnodes
+                result = remap_bnodes(result, expected) if options[:remap_bnodes]
+
                 if options[:ordered]
                   # Compare without transformation
                   rspec_example.instance_eval {
@@ -306,7 +314,7 @@ module Fixtures
                 when "jld:FrameTest"
                   JSON::LD::API.frame(t.input_loc, t.frame_loc, logger: logger, **options)
                 when "jld:FromRDFTest"
-                  repo = RDF::Repository.load(t.input_loc)
+                  repo = RDF::Repository.load(t.input_loc, rdfstar: options[:rdfstar])
                   logger.info "repo: #{repo.dump(t.id == '#t0012' ? :nquads : :trig)}"
                   JSON::LD::API.fromRdf(repo, logger: logger, **options)
                 when "jld:HttpTest"
@@ -320,7 +328,11 @@ module Fixtures
                     raise "Expected status #{t.property('expectErrorCode')}, not #{last_response.status}"
                   end
                 when "jld:ToRDFTest"
-                  JSON::LD::API.toRdf(t.input_loc, logger: logger, **options) {}
+                  if t.manifest_url.to_s.include?('stream')
+                    JSON::LD::Reader.open(t.input_loc, stream: true, logger: logger, **options).each_statement {}
+                  else
+                    JSON::LD::API.toRdf(t.input_loc, rename_bnodes: false, logger: logger, **options) {}
+                  end
                 else
                   success("Unknown test type: #{testType}")
                 end

data/spec/suite_to_rdf_spec.rb

@@ -9,6 +9,7 @@ describe JSON::LD do
       m.entries.each do |t|
         specify "#{t.property('@id')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
           pending "Generalized RDF" if t.options[:produceGeneralizedRdf]
+          pending "RDF*" if t.property('@id') == '#te122'
           if %w(#t0118).include?(t.property('@id'))
             expect {t.run self}.to write(/Statement .* is invalid/).to(:error)
           elsif %w(#te075).include?(t.property('@id'))

data/spec/to_rdf_spec.rb

@@ -1175,6 +1175,212 @@ describe JSON::LD::API do
       end
     end
 
+    context "JSON-LD*" do
+      {
+        "node with embedded subject without rdfstar option": {
+          input: %({
+            "@id": {
+              "@id": "ex:rei",
+              "ex:prop": "value"
+            },
+            "ex:prop": "value2"
+          }),
+          exception: JSON::LD::JsonLdError::InvalidIdValue
+        },
+      }.each do |title, params|
+        it(title) {run_to_rdf params}
+      end
+
+      {
+        "node with embedded subject having no @id": {
+          input: %({
+            "@id": {
+              "ex:prop": "value"
+            },
+            "ex:prop": "value2"
+          }),
+          expected: %(
+            <<_:b0 <ex:prop> "value">> <ex:prop> "value2" .
+          ),
+        },
+        "node with embedded subject having IRI @id": {
+          input: %({
+            "@id": {
+              "@id": "ex:rei",
+              "ex:prop": "value"
+            },
+            "ex:prop": "value2"
+          }),
+          expected: %(
+            <<<ex:rei> <ex:prop> "value">> <ex:prop> "value2" .
+          ),
+        },
+        "node with embedded subject having BNode @id": {
+          input: %({
+            "@id": {
+              "@id": "_:rei",
+              "ex:prop": "value"
+            },
+            "ex:prop": "value2"
+          }),
+          expected: %(
+           <<_:b0 <ex:prop> "value">> <ex:prop> "value2" .
+          ),
+        },
+        "node with embedded subject having a type": {
+          input: %({
+            "@id": {
+              "@id": "ex:rei",
+              "@type": "ex:Type"
+            },
+            "ex:prop": "value2"
+          }),
+          expected: %(
+            <<<ex:rei> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <ex:Type>>> <ex:prop> "value2" .
+          ),
+        },
+        "node with embedded subject having an IRI value": {
+          input: %({
+            "@id": {
+              "@id": "ex:rei",
+              "ex:prop": {"@id": "ex:value"}
+            },
+            "ex:prop": "value2"
+          }),
+          expected: %(
+            <<<ex:rei> <ex:prop> <ex:value>>> <ex:prop> "value2" .
+          ),
+        },
+        "node with embedded subject having an BNode value": {
+          input: %({
+            "@id": {
+              "@id": "ex:rei",
+              "ex:prop": {"@id": "_:value"}
+            },
+            "ex:prop": "value2"
+          }),
+          expected: %(
+            <<<ex:rei> <ex:prop> _:b0>> <ex:prop> "value2" .
+          ),
+        },
+        "node with recursive embedded subject": {
+          input: %({
+            "@id": {
+              "@id": {
+                "@id": "ex:rei",
+                "ex:prop": "value3"
+              },
+              "ex:prop": "value"
+            },
+            "ex:prop": "value2"
+          }),
+          expected: %(
+            <<<<<ex:rei> <ex:prop> "value3">> <ex:prop> "value">> <ex:prop> "value2" .
+          ),
+        },
+        "illegal node with subject having no property": {
+          input: %({
+            "@id": {
+              "@id": "ex:rei"
+            },
+            "ex:prop": "value3"
+          }),
+          exception: JSON::LD::JsonLdError::InvalidEmbeddedNode
+        },
+        "illegal node with subject having multiple properties": {
+          input: %({
+            "@id": {
+              "@id": "ex:rei",
+              "ex:prop": ["value1", "value2"]
+            },
+            "ex:prop": "value3"
+          }),
+          exception: JSON::LD::JsonLdError::InvalidEmbeddedNode
+        },
+        "illegal node with subject having multiple types": {
+          input: %({
+            "@id": {
+              "@id": "ex:rei",
+              "@type": ["ex:Type1", "ex:Type2"]
+            },
+            "ex:prop": "value3"
+          }),
+          exception: JSON::LD::JsonLdError::InvalidEmbeddedNode
+        },
+        "illegal node with subject having type and property": {
+          input: %({
+            "@id": {
+              "@id": "ex:rei",
+              "@type": "ex:Type",
+              "ex:prop": "value"
+            },
+            "ex:prop": "value2"
+          }),
+          exception: JSON::LD::JsonLdError::InvalidEmbeddedNode
+        },
+        "node with embedded object": {
+          input: %({
+            "@id": "ex:subj",
+            "ex:value": {
+              "@id": {
+                "@id": "ex:rei",
+                "ex:prop": "value"
+              }
+            }
+          }),
+          expected: %(
+            <ex:subj> <ex:value> <<<ex:rei> <ex:prop> "value">> .
+          ),
+        },
+        "node with embedded object having properties": {
+          input: %({
+            "@id": "ex:subj",
+            "ex:value": {
+              "@id": {
+                "@id": "ex:rei",
+                "ex:prop": "value"
+              },
+              "ex:prop": "value2"
+            }
+          }),
+          expected: %(
+            <ex:subj> <ex:value> <<<ex:rei> <ex:prop> "value">> .
+            <<<ex:rei> <ex:prop> "value">> <ex:prop> "value2" .
+          ),
+        },
+        "node with recursive embedded object": {
+          input: %({
+            "@id": "ex:subj",
+            "ex:value": {
+              "@id": {
+                "@id": {
+                  "@id": "ex:rei",
+                  "ex:prop": "value3"
+                },
+                "ex:prop": "value"
+              },
+              "ex:prop": "value2"
+            }
+          }),
+          expected: %(
+            <ex:subj> <ex:value> <<<<<ex:rei> <ex:prop> "value3">> <ex:prop> "value">> .
+            <<<<<ex:rei> <ex:prop> "value3">> <ex:prop> "value">> <ex:prop> "value2" .
+          ),
+        },
+      }.each do |title, params|
+        context(title) do
+          it "Generates statements" do
+            output_graph = RDF::Graph.new {|g| g << RDF::NTriples::Reader.new(params[:expected], rdfstar: true)}
+            run_to_rdf params.merge(rdfstar: true, output: output_graph)
+          end if params[:expected]
+
+          it "Exception" do
+            run_to_rdf params.merge(rdfstar: true)
+          end if params[:exception]
+        end
+      end
+    end
+
     context "exceptions" do
       {
         "Invalid subject" => {
@@ -1322,7 +1528,7 @@ describe JSON::LD::API do
   def parse(input, **options)
     graph = options[:graph] || RDF::Graph.new
     options = {logger: logger, validate: true, canonicalize: false}.merge(options)
-    JSON::LD::API.toRdf(StringIO.new(input), **options) {|st| graph << st}
+    JSON::LD::API.toRdf(StringIO.new(input), rename_bnodes: false, **options) {|st| graph << st}
     graph
   end
 
@@ -1335,9 +1541,9 @@ describe JSON::LD::API do
       expect {JSON::LD::API.toRdf(input, **params)}.to raise_error(params[:exception])
     else
       if params[:write]
-        expect{JSON::LD::API.toRdf(input, base: params[:base], logger: logger, **params) {|st| graph << st}}.to write(params[:write]).to(:error)
+        expect{JSON::LD::API.toRdf(input, base: params[:base], logger: logger, rename_bnodes: false, **params) {|st| graph << st}}.to write(params[:write]).to(:error)
       else
-        expect{JSON::LD::API.toRdf(input, base: params[:base], logger: logger, **params) {|st| graph << st}}.not_to write.to(:error)
+        expect{JSON::LD::API.toRdf(input, base: params[:base], logger: logger, rename_bnodes: false, **params) {|st| graph << st}}.not_to write.to(:error)
       end
       expect(graph).to be_equivalent_graph(output, logger: logger, inputDocument: input)
     end

data/spec/writer_spec.rb

@@ -189,6 +189,199 @@ describe JSON::LD::Writer do
     end
   end
 
+  context "RDF*" do
+    {
+      "subject-iii": {
+        input: RDF::Statement(
+          RDF::Statement(
+            RDF::URI('http://example/s1'),
+            RDF::URI('http://example/p1'),
+            RDF::URI('http://example/o1')),
+          RDF::URI('http://example/p'),
+          RDF::URI('http://example/o')),
+        output: %({
+         "@context": {"ex": "http://example/"},
+         "@id": {
+           "@id": "ex:s1",
+           "ex:p1": {"@id": "ex:o1"}
+         },
+         "ex:p": {"@id": "ex:o"}
+       })
+      },
+      "subject-iib": {
+        input: RDF::Statement(
+          RDF::Statement(
+            RDF::URI('http://example/s1'),
+            RDF::URI('http://example/p1'),
+            RDF::Node.new('o1')),
+          RDF::URI('http://example/p'),
+          RDF::URI('http://example/o')),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": {
+            "@id": "ex:s1",
+            "ex:p1": {"@id": "_:o1"}
+          },
+          "ex:p": {"@id": "ex:o"}
+        })
+      },
+      "subject-iil": {
+        input: RDF::Statement(
+          RDF::Statement(
+            RDF::URI('http://example/s1'),
+            RDF::URI('http://example/p1'),
+            RDF::Literal('o1')),
+          RDF::URI('http://example/p'),
+          RDF::URI('http://example/o')),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": {
+            "@id": "ex:s1",
+            "ex:p1": "o1"
+          },
+          "ex:p": {"@id": "ex:o"}
+        })
+      },
+      "subject-bii": {
+        input: RDF::Statement(
+          RDF::Statement(
+            RDF::Node('s1'),
+            RDF::URI('http://example/p1'),
+            RDF::URI('http://example/o1')),
+          RDF::URI('http://example/p'),
+          RDF::URI('http://example/o')),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": {
+            "@id": "_:s1",
+            "ex:p1": {"@id": "ex:o1"}
+          },
+          "ex:p": {"@id": "ex:o"}
+        })
+      },
+      "subject-bib": {
+        input: RDF::Statement(
+          RDF::Statement(
+            RDF::Node('s1'),
+            RDF::URI('http://example/p1'),
+            RDF::Node.new('o1')),
+          RDF::URI('http://example/p'), RDF::URI('http://example/o')),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": {
+            "@id": "_:s1",
+            "ex:p1": {"@id": "_:o1"}
+          },
+          "ex:p": {"@id": "ex:o"}
+        })
+      },
+      "subject-bil": {
+        input: RDF::Statement(
+          RDF::Statement(
+            RDF::Node('s1'),
+            RDF::URI('http://example/p1'),
+            RDF::Literal('o1')),
+          RDF::URI('http://example/p'),
+          RDF::URI('http://example/o')),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": {
+            "@id": "_:s1",
+            "ex:p1": "o1"
+          },
+          "ex:p": {"@id": "ex:o"}
+        })
+      },
+      "object-iii":  {
+        input: RDF::Statement(
+          RDF::URI('http://example/s'),
+          RDF::URI('http://example/p'),
+          RDF::Statement(
+            RDF::URI('http://example/s1'),
+            RDF::URI('http://example/p1'),
+            RDF::URI('http://example/o1'))),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": "ex:s",
+          "ex:p": {
+            "@id": {
+              "@id": "ex:s1",
+              "ex:p1": {"@id": "ex:o1"}
+            }
+          }
+        })
+      },
+      "object-iib":  {
+        input: RDF::Statement(
+          RDF::URI('http://example/s'),
+          RDF::URI('http://example/p'),
+          RDF::Statement(
+            RDF::URI('http://example/s1'),
+            RDF::URI('http://example/p1'),
+            RDF::Node.new('o1'))),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": "ex:s",
+          "ex:p": {
+            "@id": {
+              "@id": "ex:s1",
+              "ex:p1": {"@id": "_:o1"}
+            }
+          }
+        })
+      },
+      "object-iil":  {
+        input: RDF::Statement(
+          RDF::URI('http://example/s'),
+          RDF::URI('http://example/p'),
+          RDF::Statement(
+            RDF::URI('http://example/s1'),
+            RDF::URI('http://example/p1'),
+            RDF::Literal('o1'))),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": "ex:s",
+          "ex:p": {
+            "@id": {
+              "@id": "ex:s1",
+              "ex:p1": "o1"
+            }
+          }
+        })
+      },
+      "recursive-subject": {
+        input: RDF::Statement(
+          RDF::Statement(
+            RDF::Statement(
+              RDF::URI('http://example/s2'),
+              RDF::URI('http://example/p2'),
+              RDF::URI('http://example/o2')),
+            RDF::URI('http://example/p1'),
+            RDF::URI('http://example/o1')),
+          RDF::URI('http://example/p'),
+          RDF::URI('http://example/o')),
+        output: %({
+          "@context": {"ex": "http://example/"},
+          "@id": {
+            "@id": {
+              "@id": "ex:s2",
+              "ex:p2": {"@id": "ex:o2"}
+            },
+            "ex:p1": {"@id": "ex:o1"}
+          },
+          "ex:p": {"@id": "ex:o"}
+        })
+      },
+    }.each do |name, params|
+      it name do
+        graph = RDF::Graph.new {|g| g << params[:input]}
+        expect(
+          serialize(graph, rdfstar: true, prefixes: {ex: 'http://example/'})
+        ).to produce_jsonld(JSON.parse(params[:output]), logger)
+      end
+    end
+  end
+
   context "Writes fromRdf tests to isomorphic graph" do
     require 'suite_helper'
     m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}fromRdf-manifest.jsonld")