json-ld 3.2.3 → 3.2.5

data/spec/resource_spec.rb

@@ -1,76 +0,0 @@
-# coding: utf-8
-require_relative 'spec_helper'
-
-describe JSON::LD::Resource do
-  subject {JSON::LD::Resource.new({'@id' => '_:foo', "http://schema.org/name" => "foo"})}
-  describe "#initialize" do
-    specify {expect(subject).not_to be_nil}
-    specify {expect(subject).to be_a(JSON::LD::Resource)}
-    specify {expect(subject).not_to be_clean}
-    specify {expect(subject).to be_anonymous}
-    specify {expect(subject).to be_dirty}
-    specify {expect(subject).to be_new}
-    specify {expect(subject).not_to be_resolved}
-    specify {expect(subject).not_to be_stub}
-    context "schema:name property" do
-      specify {expect(subject.property("http://schema.org/name")).to eq "foo"}
-    end
-
-    describe "compacted with context" do
-      subject {JSON::LD::Resource.new({'@id' => '_:foo', "http://schema.org/name" => "foo"}, compact: true, context: {"@vocab" => "http://schema.org/"})}
-      specify {expect(subject).not_to be_nil}
-      specify {expect(subject).to be_a(JSON::LD::Resource)}
-      specify {expect(subject).not_to be_clean}
-      specify {expect(subject).to be_anonymous}
-      specify {expect(subject).to be_dirty}
-      specify {expect(subject).to be_new}
-      specify {expect(subject).not_to be_resolved}
-      specify {expect(subject).not_to be_stub}
-      its(:name) {should eq "foo"}
-    end
-  end
-
-  describe "#deresolve" do
-    it "FIXME"
-  end
-
-  describe "#resolve" do
-    it "FIXME"
-  end
-
-  describe "#hash" do
-    specify {expect(subject.hash).to be_a(Integer)}
-      
-    it "returns the hash of the attributes" do
-      expect(subject.hash).to eq subject.deresolve.hash
-    end
-  end
-
-  describe "#to_json" do
-    it "has JSON" do
-      expect(subject.to_json).to be_a(String)
-      expect(JSON.parse(subject.to_json)).to be_a(Hash)
-    end
-    it "has same ID" do
-      expect(JSON.parse(subject.to_json)['@id']).to eq subject.id
-    end
-  end
-
-  describe "#each" do
-    specify {expect {|b| subject.each(&b)}.to yield_with_args(subject.statements.first)}
-  end
-
-  describe RDF::Enumerable do
-    specify {expect(subject).to be_enumerable}
-
-    it "initializes a graph" do
-      g = RDF::Graph.new << subject
-      expect(g.count).to eq 1
-      expect(g.objects.first).to eq "foo"
-    end
-  end
-
-  describe "#save" do
-    specify {expect {subject.save}.to raise_error(NotImplementedError)}
-  end
-end

data/spec/spec_helper.rb

@@ -1,281 +0,0 @@
-$:.unshift(File.join("../../lib", __FILE__))
-$:.unshift File.dirname(__FILE__)
-
-require "bundler/setup"
-require 'rspec'
-require 'rdf'
-require 'rdf/isomorphic'
-require 'rdf/nquads'
-require 'rdf/turtle'
-require 'rdf/trig'
-require 'rdf/vocab'
-require 'rdf/spec'
-require 'rdf/spec/matchers'
-require_relative 'matchers'
-require 'yaml'
-begin
-  require 'simplecov'
-  require 'simplecov-lcov'
-  SimpleCov::Formatter::LcovFormatter.config do |config|
-    #Coveralls is coverage by default/lcov. Send info results
-    config.report_with_single_file = true
-    config.single_report_path = 'coverage/lcov.info'
-  end
-
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
-    SimpleCov::Formatter::HTMLFormatter,
-    SimpleCov::Formatter::LcovFormatter
-  ])
-  SimpleCov.start do
-    add_filter "/spec/"
-  end
-rescue LoadError
-end
-
-require 'json/ld'
-
-JSON_STATE = JSON::State.new(
-  indent:       "  ",
-  space:        " ",
-  space_before: "",
-  object_nl:    "\n",
-  array_nl:     "\n"
-)
-
-require 'webmock'
-WebMock.disable_net_connect!
-
-# Create and maintain a cache of downloaded URIs
-URI_CACHE = File.expand_path(File.join(File.dirname(__FILE__), "uri-cache"))
-Dir.mkdir(URI_CACHE) unless File.directory?(URI_CACHE)
-# Cache client requests
-
-::RSpec.configure do |c|
-  c.filter_run focus: true
-  c.run_all_when_everything_filtered = true
-  c.include(RDF::Spec::Matchers)
-end
-
-# Heuristically detect the input stream
-def detect_format(stream)
-  # Got to look into the file to see
-  if stream.respond_to?(:rewind) && stream.respond_to?(:read)
-    stream.rewind
-    string = stream.read(1000)
-    stream.rewind
-  else
-    string = stream.to_s
-  end
-  case string
-  when /<html/i           then RDF::RDFa::Reader
-  when /\{\s*\"@\"/i      then JSON::LD::Reader
-  else                         RDF::Turtle::Reader
-  end
-end
-
-# Creates a bijection between the two objects and replaces nodes in actual from expected.
-def remap_bnodes(actual, expected)
-  # Transform each to RDF and perform a blank node bijection.
-  # Replace the blank nodes in action with the mapping from bijection.
-  ds_actual = RDF::Repository.new << JSON::LD::API.toRdf(actual, rdfstar: true, rename_bnodes: false)
-  ds_expected = RDF::Repository.new << JSON::LD::API.toRdf(expected, rdfstar: true, rename_bnodes: false)
-  if bijection = ds_actual.bijection_to(ds_expected)
-    bijection = bijection.inject({}) {|memo, (k, v)| memo.merge(k.to_s => v.to_s)}
-
-    # Recursively replace blank nodes in actual with the bijection
-    replace_nodes(actual, bijection)
-  else
-    actual
-  end
-end
-
-def replace_nodes(object, bijection)
-  case object
-  when Array
-    object.map {|o| replace_nodes(o, bijection)}
-  when Hash
-    object.inject({}) do |memo, (k, v)|
-      memo.merge(bijection.fetch(k, k) => replace_nodes(v, bijection))
-    end
-  when String
-    bijection.fetch(object, object)
-  else
-    object
-  end
-end
-
-
-LIBRARY_INPUT = JSON.parse(%([
-  {
-    "@id": "http://example.org/library",
-    "@type": "http://example.org/vocab#Library",
-    "http://example.org/vocab#contains": {"@id": "http://example.org/library/the-republic"}
-  }, {
-    "@id": "http://example.org/library/the-republic",
-    "@type": "http://example.org/vocab#Book",
-    "http://purl.org/dc/elements/1.1/creator": "Plato",
-    "http://purl.org/dc/elements/1.1/title": "The Republic",
-    "http://example.org/vocab#contains": {
-      "@id": "http://example.org/library/the-republic#introduction",
-      "@type": "http://example.org/vocab#Chapter",
-      "http://purl.org/dc/elements/1.1/description": "An introductory chapter on The Republic.",
-      "http://purl.org/dc/elements/1.1/title": "The Introduction"
-    }
-  }
-]))
-
-LIBRARY_EXPANDED = JSON.parse(%([
-  {
-    "@id": "http://example.org/library",
-    "@type": ["http://example.org/vocab#Library"],
-    "http://example.org/vocab#contains": [{"@id": "http://example.org/library/the-republic"}]
-  }, {
-    "@id": "http://example.org/library/the-republic",
-    "@type": ["http://example.org/vocab#Book"],
-    "http://purl.org/dc/elements/1.1/creator": [{"@value": "Plato"}],
-    "http://purl.org/dc/elements/1.1/title": [{"@value": "The Republic"}],
-    "http://example.org/vocab#contains": [{
-      "@id": "http://example.org/library/the-republic#introduction",
-      "@type": ["http://example.org/vocab#Chapter"],
-      "http://purl.org/dc/elements/1.1/description": [{"@value": "An introductory chapter on The Republic."}],
-      "http://purl.org/dc/elements/1.1/title": [{"@value": "The Introduction"}]
-    }]
-  }
-]))
-
-LIBRARY_COMPACTED_DEFAULT = JSON.parse(%({
-  "@context": "http://schema.org",
-  "@graph": [
-    {
-      "id": "http://example.org/library",
-      "type": "http://example.org/vocab#Library",
-      "http://example.org/vocab#contains": {"id": "http://example.org/library/the-republic"}
-    }, {
-      "id": "http://example.org/library/the-republic",
-      "type": "http://example.org/vocab#Book",
-      "http://purl.org/dc/elements/1.1/creator": "Plato",
-      "http://purl.org/dc/elements/1.1/title": "The Republic",
-      "http://example.org/vocab#contains": {
-        "id": "http://example.org/library/the-republic#introduction",
-        "type": "http://example.org/vocab#Chapter",
-        "http://purl.org/dc/elements/1.1/description": "An introductory chapter on The Republic.",
-        "http://purl.org/dc/elements/1.1/title": "The Introduction"
-      }
-    }
-  ]
-}))
-
-LIBRARY_COMPACTED = JSON.parse(%({
-  "@context": "http://conneg.example.com/context",
-  "@graph": [
-    {
-      "@id": "http://example.org/library",
-      "@type": "ex:Library",
-      "ex:contains": {
-        "@id": "http://example.org/library/the-republic"
-      }
-    },
-    {
-      "@id": "http://example.org/library/the-republic",
-      "@type": "ex:Book",
-      "dc:creator": "Plato",
-      "dc:title": "The Republic",
-      "ex:contains": {
-        "@id": "http://example.org/library/the-republic#introduction",
-        "@type": "ex:Chapter",
-        "dc:description": "An introductory chapter on The Republic.",
-        "dc:title": "The Introduction"
-      }
-    }
-  ]
-}))
-
-LIBRARY_FLATTENED_EXPANDED = JSON.parse(%([
-  {
-    "@id": "http://example.org/library",
-    "@type": ["http://example.org/vocab#Library"],
-    "http://example.org/vocab#contains": [{"@id": "http://example.org/library/the-republic"}]
-  },
-  {
-    "@id": "http://example.org/library/the-republic",
-    "@type": ["http://example.org/vocab#Book"],
-    "http://purl.org/dc/elements/1.1/creator": [{"@value": "Plato"}],
-    "http://purl.org/dc/elements/1.1/title": [{"@value": "The Republic"}],
-    "http://example.org/vocab#contains": [{"@id": "http://example.org/library/the-republic#introduction"}]
-  },
-  {
-    "@id": "http://example.org/library/the-republic#introduction",
-    "@type": ["http://example.org/vocab#Chapter"],
-    "http://purl.org/dc/elements/1.1/description": [{"@value": "An introductory chapter on The Republic."}],
-    "http://purl.org/dc/elements/1.1/title": [{"@value": "The Introduction"}]
-  }
-]))
-
-LIBRARY_FLATTENED_COMPACTED_DEFAULT = JSON.parse(%({
-  "@context": "http://schema.org",
-  "@graph": [
-    {
-      "id": "http://example.org/library",
-      "type": "http://example.org/vocab#Library",
-      "http://example.org/vocab#contains": {"id": "http://example.org/library/the-republic"}
-    },
-    {
-      "id": "http://example.org/library/the-republic",
-      "type": "http://example.org/vocab#Book",
-      "http://purl.org/dc/elements/1.1/creator": "Plato",
-      "http://purl.org/dc/elements/1.1/title": "The Republic",
-      "http://example.org/vocab#contains": {"id": "http://example.org/library/the-republic#introduction"}
-    },
-    {
-      "id": "http://example.org/library/the-republic#introduction",
-      "type": "http://example.org/vocab#Chapter",
-      "http://purl.org/dc/elements/1.1/description": "An introductory chapter on The Republic.",
-      "http://purl.org/dc/elements/1.1/title": "The Introduction"
-    }
-  ]
-}))
-
-LIBRARY_FLATTENED_COMPACTED = JSON.parse(%({
-  "@context": "http://conneg.example.com/context",
-  "@graph": [
-    {
-      "@id": "http://example.org/library",
-      "@type": "ex:Library",
-      "ex:contains": {"@id": "http://example.org/library/the-republic"}
-    },
-    {
-      "@id": "http://example.org/library/the-republic",
-      "@type": "ex:Book",
-      "dc:creator": "Plato",
-      "dc:title": "The Republic",
-      "ex:contains": {"@id": "http://example.org/library/the-republic#introduction"}
-    },
-    {
-      "@id": "http://example.org/library/the-republic#introduction",
-      "@type": "ex:Chapter",
-      "dc:description": "An introductory chapter on The Republic.",
-      "dc:title": "The Introduction"
-    }
-  ]
-}))
-
-LIBRARY_FRAMED = JSON.parse(%({
-  "@context": {
-    "dc": "http://purl.org/dc/elements/1.1/",
-    "ex": "http://example.org/vocab#"
-  },
-  "@id": "http://example.org/library",
-  "@type": "ex:Library",
-  "ex:contains": {
-    "@id": "http://example.org/library/the-republic",
-    "@type": "ex:Book",
-    "dc:creator": "Plato",
-    "dc:title": "The Republic",
-    "ex:contains": {
-      "@id": "http://example.org/library/the-republic#introduction",
-      "@type": "ex:Chapter",
-      "dc:description": "An introductory chapter on The Republic.",
-      "dc:title": "The Introduction"
-    }
-  }
-}))

data/spec/streaming_reader_spec.rb

@@ -1,237 +0,0 @@
-# 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