RubyGems - json-ld - Versions diffs - 3.1.0 → 3.1.5 - Mend

json-ld 3.1.0 → 3.1.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (33) hide show

checksums.yaml +4 -4
data/README.md +66 -46
data/VERSION +1 -1
data/bin/jsonld +27 -30
data/lib/json/ld.rb +12 -8
data/lib/json/ld/api.rb +51 -43
data/lib/json/ld/compact.rb +82 -68
data/lib/json/ld/conneg.rb +1 -1
data/lib/json/ld/context.rb +650 -542
data/lib/json/ld/expand.rb +154 -87
data/lib/json/ld/flatten.rb +1 -1
data/lib/json/ld/format.rb +10 -6
data/lib/json/ld/frame.rb +1 -2
data/lib/json/ld/from_rdf.rb +7 -8
data/lib/json/ld/html/nokogiri.rb +2 -1
data/lib/json/ld/html/rexml.rb +2 -1
data/lib/json/ld/reader.rb +20 -11
data/lib/json/ld/streaming_reader.rb +578 -0
data/lib/json/ld/to_rdf.rb +9 -3
data/lib/json/ld/writer.rb +12 -5
data/spec/compact_spec.rb +1 -0
data/spec/context_spec.rb +63 -116
data/spec/expand_spec.rb +29 -9
data/spec/frame_spec.rb +44 -0
data/spec/matchers.rb +1 -1
data/spec/reader_spec.rb +33 -34
data/spec/streaming_reader_spec.rb +237 -0
data/spec/suite_expand_spec.rb +4 -2
data/spec/suite_frame_spec.rb +0 -1
data/spec/suite_helper.rb +23 -8
data/spec/suite_to_rdf_spec.rb +1 -1
data/spec/to_rdf_spec.rb +3 -3
metadata +11 -8

data/spec/expand_spec.rb CHANGED

@@ -2909,6 +2909,26 @@ describe JSON::LD::API do
           validate: true,
           exception: JSON::LD::JsonLdError::InvalidTermDefinition
         },
+        "Applies property scoped contexts which are aliases of @nest": {
+          input: %({
+            "@context": {
+              "@version": 1.1,
+              "@vocab": "http://example.org/",
+              "nest": {
+                "@id": "@nest",
+                "@context": {
+                  "@vocab": "http://example.org/nest/"
+                }
+              }
+            },
+            "nest": {
+              "property": "should be in /nest"
+            }
+          }),
+          output: %([{
+            "http://example.org/nest/property": [{"@value": "should be in /nest"}]
+          }])
+        }
       }.each do |title, params|
         it(title) {run_expand({processingMode: "json-ld-1.1"}.merge(params))}
       end
@@ -3366,7 +3386,7 @@ describe JSON::LD::API do
       %w(Nokogiri REXML).each do |impl|
         next unless Module.constants.map(&:to_s).include?(impl)
         context impl do
-          before(:all) {@library = impl.downcase.to_s.to_sym}
+          let(:library) {impl.downcase.to_s.to_sym}
           {
             "Expands embedded JSON-LD script element": {
@@ -3505,9 +3525,9 @@ describe JSON::LD::API do
               ]),
               extractAllScripts: true
             },
-            "Expands as empty with no script element": {
+            "Errors no script element": {
               input: %(<html><head></head></html>),
-              output: %([])
+              exception: JSON::LD::JsonLdError::LoadingDocumentFailed
             },
             "Expands as empty with no script element and extractAllScripts": {
               input: %(<html><head></head></html>),
@@ -3619,7 +3639,7 @@ describe JSON::LD::API do
                 </head>
               </html>),
               base: "http://example.org/doc#third",
-              exception: JSON::LD::JsonLdError::InvalidScriptElement
+              exception: JSON::LD::JsonLdError::LoadingDocumentFailed
             },
             "Errors if targeted element is not a script element": {
               input: %(
@@ -3636,7 +3656,7 @@ describe JSON::LD::API do
                 </head>
               </html>),
               base: "http://example.org/doc#first",
-              exception: JSON::LD::JsonLdError::InvalidScriptElement
+              exception: JSON::LD::JsonLdError::LoadingDocumentFailed
             },
             "Errors if targeted element does not have type application/ld+json": {
               input: %(
@@ -3653,7 +3673,7 @@ describe JSON::LD::API do
                 </head>
               </html>),
               base: "http://example.org/doc#first",
-              exception: JSON::LD::JsonLdError::InvalidScriptElement
+              exception: JSON::LD::JsonLdError::LoadingDocumentFailed
             },
             "Errors if uncommented script text contains comment": {
               input: %(
@@ -3722,10 +3742,10 @@ describe JSON::LD::API do
             },
           }.each do |title, params|
             it(title) do
-              skip "rexml" if params[:not] == @library
-              params[:input] = StringIO.new(params[:input])
+              skip "rexml" if params[:not] == library
+              params = params.merge(input: StringIO.new(params[:input]))
               params[:input].send(:define_singleton_method, :content_type) {"text/html"}
-              run_expand params.merge(validate: true, library: @library)
+              run_expand params.merge(validate: true, library: library)
             end
           end
         end

data/spec/frame_spec.rb CHANGED

@@ -2305,6 +2305,50 @@ describe JSON::LD::API do
           }
         }),
         processingMode: "json-ld-1.1"
+      },
+      "missing types": {
+        input: %({
+            "@context": {
+              "ex": "http://example.com#",
+              "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+            },
+            "@graph": [{
+              "@id": "ex:graph1",
+              "@graph": [{
+                "@id": "ex:entity1",
+                "@type": ["ex:Type1","ex:Type2"],
+                "ex:title": "some title",
+                "ex:multipleValues": "ex:One"
+            }]
+          }, {
+            "@id": "ex:graph2",
+            "@graph": [{
+              "@id": "ex:entity1",
+              "@type": "ex:Type3",
+              "ex:tags": "tag1 tag2",
+              "ex:multipleValues": ["ex:Two","ex:Three"]
+            }]
+          }]
+        }),
+        output: %({
+          "@context": {
+            "ex": "http://example.com#",
+            "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+          },
+          "@id": "ex:entity1",
+          "@type": ["ex:Type1", "ex:Type2", "ex:Type3"],
+          "ex:multipleValues": ["ex:One", "ex:Two","ex:Three"],
+          "ex:tags": "tag1 tag2",
+          "ex:title": "some title"
+        }),
+        frame: %({
+          "@context": {
+            "ex": "http://example.com#",
+            "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+          },
+          "@id": "ex:entity1"
+        }),
+        processingMode: "json-ld-1.1"
       }
     }.each do |title, params|
       it title do

data/spec/matchers.rb CHANGED

@@ -1,4 +1,4 @@
-require 'rspec/matchers' # @see http://rubygems.org/gems/rspec
+require 'rspec/matchers' # @see https://rubygems.org/gems/rspec
 require_relative 'support/extensions'
 RSpec::Matchers.define :produce_jsonld do |expected, logger|

data/spec/reader_spec.rb CHANGED

@@ -43,40 +43,39 @@ describe JSON::LD::Reader do
     {
       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}

data/spec/streaming_reader_spec.rb ADDED

@@ -0,0 +1,237 @@
+# coding: utf-8
+require_relative 'spec_helper'
+require 'rdf/spec/reader'
+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)}
+    let(:reader) {JSON::LD::Reader.new(reader_input, stream: true)}
+    let(:reader_count) {doap_count}
+  end
+  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, logger: false).each_statement(&b)
+      end.to raise_error(RDF::ReaderError)
+    end
+  end
+  context :interface do
+    {
+      plain: %q({
+        "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
+        "@type": "foaf:Person",
+        "@id": "_:bnode1",
+        "foaf:homepage": "http://example.com/bob/",
+        "foaf:name": "Bob"
+      }),
+      leading_comment: %q(
+      // A comment before content
+      {
+        "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
+        "@type": "foaf:Person",
+        "@id": "_:bnode1",
+        "foaf:homepage": "http://example.com/bob/",
+        "foaf:name": "Bob"
+      }),
+      script: %q(<script type="application/ld+json">
+      {
+        "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
+        "@type": "foaf:Person",
+        "@id": "_:bnode1",
+        "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/"},
+        "@type": "foaf:Person",
+        "@id": "_:bnode1",
+        "foaf:homepage": "http://example.com/bob/",
+        "foaf:name": "Bob"
+       }
+      </script>),
+    }.each do |variant, src|
+      context variant do
+        subject {src}
+        describe "#initialize" do
+          it "yields reader given string" do
+            inner = double("inner")
+            expect(inner).to receive(:called).with(JSON::LD::Reader)
+            JSON::LD::Reader.new(subject, stream: true) do |reader|
+              inner.called(reader.class)
+            end
+          end
+          it "yields reader given IO" do
+            inner = double("inner")
+            expect(inner).to receive(:called).with(JSON::LD::Reader)
+            JSON::LD::Reader.new(StringIO.new(subject), stream: true) do |reader|
+              inner.called(reader.class)
+            end
+          end
+          it "returns reader" do
+            expect(JSON::LD::Reader.new(subject, stream: true)).to be_a(JSON::LD::Reader)
+          end
+        end
+        describe "#each_statement" do
+          it "yields statements" do
+            inner = double("inner")
+            expect(inner).to receive(:called).with(RDF::Statement).exactly(3)
+            JSON::LD::Reader.new(subject, stream: true).each_statement do |statement|
+              inner.called(statement.class)
+            end
+          end
+        end
+        describe "#each_triple" do
+          it "yields statements" do
+            inner = double("inner")
+            expect(inner).to receive(:called).exactly(3)
+            JSON::LD::Reader.new(subject, stream: true).each_triple do |subject, predicate, object|
+              inner.called(subject.class, predicate.class, object.class)
+            end
+          end
+        end
+      end
+    end
+  end
+  context "Selected toRdf tests" do
+    {
+      "e004": {
+        input: %({
+          "@context": {
+            "mylist1": {"@id": "http://example.com/mylist1", "@container": "@list"}
+          },
+          "@id": "http://example.org/id",
+          "mylist1": { "@list": [ ] },
+          "http://example.org/list1": { "@list": [ null ] },
+          "http://example.org/list2": { "@list": [ {"@value": null} ] }
+        }),
+        expect: %(
+        <http://example.org/id> <http://example.com/mylist1> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+        <http://example.org/id> <http://example.org/list1> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+        <http://example.org/id> <http://example.org/list2> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+        )
+      },
+      "e015": {
+        input: %({
+          "@context": {
+            "myset2": {"@id": "http://example.com/myset2", "@container": "@set" }
+          },
+          "@id": "http://example.org/id",
+          "myset2": [ [], { "@set": [ null ] }, [ null ] ]
+        }),
+        expect: %(
+        )
+      },
+      "in06": {
+        input: %({
+          "@context": {
+            "@version": 1.1,
+            "@vocab": "http://example.org/vocab#",
+            "@base": "http://example.org/base/",
+            "id": "@id",
+            "type": "@type",
+            "data": "@nest",
+            "links": "@nest",
+            "relationships": "@nest",
+            "self": {"@type": "@id"},
+            "related": {"@type": "@id"}
+          },
+          "data": [{
+            "type": "articles",
+            "id": "1",
+            "author": {
+              "data": { "type": "people", "id": "9" }
+            }
+          }]
+        }),
+        expect: %(
+        <http://example.org/base/1> <http://example.org/vocab#author> <http://example.org/base/9> .
+        <http://example.org/base/1> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/vocab#articles> .
+        <http://example.org/base/9> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/vocab#people> .
+        ),
+        pending: "@nest defining @id"
+      }
+    }.each do |name, params|
+      it name do
+        run_to_rdf params
+      end
+    end
+  end
+  describe "test suite" do
+    require_relative 'suite_helper'
+    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::STREAM_SUITE}stream-toRdf-manifest.jsonld")
+    describe m.name 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 "@nest defining @id" if %w(#tin06).include?(t.property('@id'))
+          pending "double @reverse" if %w(#te043).include?(t.property('@id'))
+          pending "graph map containing named graph" if %w(#te084 #te087 #te098 #te101 #te105 #te106).include?(t.property('@id'))
+          pending "named graphs" if %w(#t0029 #te021).include?(t.property('@id'))
+          if %w(#t0118).include?(t.property('@id'))
+            expect {t.run self}.to write(/Statement .* is invalid/).to(:error)
+          elsif %w(#twf07).include?(t.property('@id'))
+            expect {t.run self}.to write(/skipping graph statement within invalid graph name/).to(:error)
+          elsif %w(#te075).include?(t.property('@id'))
+            expect {t.run self}.to write(/is invalid/).to(:error)
+          elsif %w(#te005 #tpr34 #tpr35 #tpr36 #tpr37 #tpr38 #tpr39 #te119 #te120).include?(t.property('@id'))
+            expect {t.run self}.to write("beginning with '@' are reserved for future use").to(:error)
+          elsif %w(#te068).include?(t.property('@id'))
+            expect {t.run self}.to write("[DEPRECATION]").to(:error)
+          elsif %w(#twf05).include?(t.property('@id'))
+            expect {t.run self}.to write("@language must be valid BCP47").to(:error)
+          else
+            expect {t.run self}.not_to write.to(:error)
+          end
+        end
+      end
+    end
+  end unless ENV['CI']
+  def run_to_rdf(params)
+    input = params[:input]
+    logger.info("input: #{input}")
+    output = RDF::Repository.new
+    if params[:expect]
+      RDF::NQuads::Reader.new(params[:expect], validate: false) {|r| output << r}
+      logger.info("expect (quads): #{output.dump(:nquads, validate: false)}")
+    else
+      logger.info("expect: #{Regexp.new params[:exception]}")
+    end
+    graph = params[:graph] || RDF::Repository.new
+    pending params.fetch(:pending, "test implementation") if !input || params[:pending]
+    if params[:exception]
+      expect do |b|
+        JSON::LD::Reader.new(input, stream: true, validate: true, logger: false, **params).each_statement(&b)
+      end.to raise_error {|er| expect(er.message).to include params[:exception]}
+    else
+      if params[:write]
+        expect{JSON::LD::Reader.new(input, stream: true, logger: logger, **params) {|st| graph << st}}.to write(params[:write]).to(:error)
+      else
+        expect{JSON::LD::Reader.new(input, stream: true, logger: logger, **params) {|st| graph << st}}.not_to write.to(:error)
+      end
+      logger.info("results (quads): #{graph.dump(:nquads, validate: false)}")
+      expect(graph).to be_equivalent_graph(output, logger: logger, inputDocument: input)
+    end
+  end
+end