json-ld 3.1.1 → 3.1.6

data/lib/json/ld/to_rdf.rb

@@ -16,6 +16,8 @@ module JSON::LD
     # @return RDF::Resource the subject of this item
     def item_to_rdf(item, graph_name: nil, &block)
       # Just return value object as Term
+      return unless item
+
       if value?(item)
         value, datatype = item.fetch('@value'), item.fetch('@type', nil)
 
@@ -76,11 +78,13 @@ module JSON::LD
         return parse_list(item['@list'], graph_name: graph_name, &block)
       end
 
-      # Skip if '@id' is nil
-      subject = if item.has_key?('@id')
-        item['@id'].nil? ? nil : as_resource(item['@id'])
-      else
-        node
+      subject = case item['@id']
+      when nil then node
+      when String then as_resource(item['@id'])
+      when Object
+        # Embedded statement
+        # (No error checking, as this is done in expansion)
+        to_enum(:item_to_rdf, item['@id']).to_a.first
       end
 
       #log_debug("item_to_rdf")  {"subject: #{subject.to_ntriples rescue 'malformed rdf'}"}

data/lib/json/ld/writer.rb

@@ -93,7 +93,7 @@ module JSON::LD
           datatype: RDF::URI,
           control: :url2,
           on: ["--context CONTEXT"],
-          description: "Context to use when compacting.") {|arg| RDF::URI(arg)},
+          description: "Context to use when compacting.") {|arg| RDF::URI(arg).absolute? ? RDF::URI(arg) : StringIO.new(File.read(arg))},
         RDF::CLI::Option.new(
           symbol: :embed,
           datatype: %w(@always @once @never),
@@ -107,6 +107,13 @@ module JSON::LD
           control: :checkbox,
           on: ["--[no-]explicit"],
           description: "Only include explicitly declared properties in output (false)") {|arg| arg},
+        RDF::CLI::Option.new(
+          symbol: :frame,
+          datatype: RDF::URI,
+          control: :url2,
+          use: :required,
+          on: ["--frame FRAME"],
+          description: "Frame to use when serializing.") {|arg| RDF::URI(arg).absolute? ? RDF::URI(arg) : StringIO.new(File.read(arg))},
         RDF::CLI::Option.new(
           symbol: :lowercaseLanguage,
           datatype: TrueClass,
@@ -137,7 +144,7 @@ module JSON::LD
           default: 'null',
           control: :select,
           on: ["--rdf-direction DIR", %w(i18n-datatype compound-literal)],
-          description: "How to serialize literal direction (i18n-datatype compound-literal)") {|arg| RDF::URI(arg)},
+          description: "How to serialize literal direction (i18n-datatype compound-literal)") {|arg| arg},
         RDF::CLI::Option.new(
           symbol: :requireAll,
           datatype: TrueClass,
@@ -202,7 +209,7 @@ module JSON::LD
     end
 
     ##
-    # Initializes the RDF-LD writer instance.
+    # Initializes the JSON-LD writer instance.
     #
     # @param  [IO, File] output
     #   the output stream

data/spec/compact_spec.rb

@@ -564,6 +564,7 @@ describe JSON::LD::API do
           documentUrl: "http://example.com/context")
       end
       it "uses referenced context" do
+        JSON::LD::Context.instance_variable_set(:@cache, nil)
         input = ::JSON.parse %({
           "http://example.com/b": "c"
         })

data/spec/context_spec.rb

@@ -56,15 +56,8 @@ describe JSON::LD::Context do
   describe "#parse" do
     context "remote" do
 
-      it "retrieves and parses a remote context document" do
-        JSON::LD::Context::PRELOADED.clear
-        expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
-        ec = subject.parse("http://example.com/context")
-        expect(ec.provided_context).to produce("http://example.com/context", logger)
-      end
-
       it "fails given a missing remote @context" do
-        JSON::LD::Context::PRELOADED.clear
+        JSON::LD::Context.instance_variable_set(:@cache, nil)
         expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_raise(IOError)
         expect {subject.parse("http://example.com/context")}.to raise_error(JSON::LD::JsonLdError::LoadingRemoteContextFailed, %r{http://example.com/context})
       end
@@ -116,7 +109,7 @@ describe JSON::LD::Context do
             documentUrl: "http://example.com/context",
             contentType: "text/html")
 
-        JSON::LD::Context::PRELOADED.clear
+        JSON::LD::Context.instance_variable_set(:@cache, nil)
         expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
         ec = subject.parse("http://example.com/context")
         expect(ec.send(:mappings)).to produce({
@@ -154,7 +147,7 @@ describe JSON::LD::Context do
             ),
             documentUrl: "http://example.com/context",
             contentType: "text/html")
-          JSON::LD::Context::PRELOADED.clear
+          JSON::LD::Context.instance_variable_set(:@cache, nil)
         expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
         ec = subject.parse("http://example.com/context")
         expect(ec.send(:mappings)).to produce({
@@ -170,7 +163,7 @@ describe JSON::LD::Context do
       end
 
       it "parses a referenced context at a relative URI" do
-        JSON::LD::Context::PRELOADED.clear
+        JSON::LD::Context.instance_variable_set(:@cache, nil)
         rd1 = JSON::LD::API::RemoteDocument.new(%({"@context": "context"}), base_uri: "http://example.com/c1")
         expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/c1", anything).and_yield(rd1)
         expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
@@ -185,17 +178,11 @@ describe JSON::LD::Context do
 
       context "remote with local mappings" do
         let(:ctx) {["http://example.com/context", {"integer" => "xsd:integer"}]}
-        before {JSON::LD::Context::PRELOADED.clear}
+        before {JSON::LD::Context.instance_variable_set(:@cache, nil)}
         it "retrieves and parses a remote context document" do
           expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
           subject.parse(ctx)
         end
-
-        it "does not use passed context as provided_context" do
-          expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
-          ec = subject.parse(ctx)
-          expect(ec.provided_context).to produce(ctx, logger)
-        end
       end
 
       context "pre-loaded remote" do
@@ -206,7 +193,7 @@ describe JSON::LD::Context do
           )
           JSON::LD::Context.alias_preloaded("https://example.com/preloaded", "http://example.com/preloaded")
         }
-        after(:all) {JSON::LD::Context::PRELOADED.clear}
+        after(:all) {JSON::LD::Context.instance_variable_set(:@cache, nil)}
 
         it "does not load referenced context" do
           expect(JSON::LD::API).not_to receive(:documentLoader).with(ctx, anything)
@@ -249,6 +236,7 @@ describe JSON::LD::Context do
       end
 
       it "merges definitions from remote contexts" do
+        JSON::LD::Context.instance_variable_set(:@cache, nil)
         expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
         rd2 = JSON::LD::API::RemoteDocument.new(%q({
           "@context": {
@@ -476,7 +464,7 @@ describe JSON::LD::Context do
       end
 
       context "@import" do
-        before(:each) {JSON::LD::Context::PRELOADED.clear}
+        before(:each) {JSON::LD::Context.instance_variable_set(:@cache, nil)}
         it "generates an InvalidImportValue error if not a string" do
           expect {subject.parse({'@version' => 1.1, '@import' => true})}.to raise_error(JSON::LD::JsonLdError::InvalidImportValue)
         end
@@ -503,7 +491,7 @@ describe JSON::LD::Context do
         "@type as object" => {"foo" => {"@type" => {}}},
         "@type as array" => {"foo" => {"@type" => []}},
         "@type as @list" => {"foo" => {"@type" => "@list"}},
-        "@type as @none" => {"@version": 1.1, "foo" => {"@type" => "@none"}},
+        "@type as @none" => {"@version" => 1.1, "foo" => {"@type" => "@none"}},
         "@type as @set" => {"foo" => {"@type" => "@set"}},
         "@container as object" => {"foo" => {"@container" => {}}},
         "@container as empty array" => {"foo" => {"@container" => []}},
@@ -642,26 +630,8 @@ describe JSON::LD::Context do
     end
   end
 
-  describe "#merge!" do
-    it "updates context with components from new" do
-      c2 = JSON::LD::Context.parse({'foo' => "http://example.com/"})
-      cm = context.merge!(c2)
-      expect(cm).to equal context
-      expect(cm).not_to equal c2
-      expect(cm.term_definitions).to eq c2.term_definitions
-    end
-  end
-
   describe "#serialize" do
-    before {JSON::LD::Context::PRELOADED.clear}
-    it "context document" do
-      expect(JSON::LD::API).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(remote_doc)
-      ec = subject.parse("http://example.com/context")
-      expect(ec.serialize).to produce({
-        "@context" => "http://example.com/context"
-      }, logger)
-    end
-
+    before {JSON::LD::Context.instance_variable_set(:@cache, nil)}
     it "context hash" do
       ctx = {"foo" => "http://example.com/"}
 
@@ -693,7 +663,7 @@ describe JSON::LD::Context do
 
     it "term mappings" do
       c = subject.
-        parse({'foo' => "http://example.com/"}).send(:clear_provided_context)
+        parse({'foo' => "http://example.com/"})
       expect(c.serialize).to produce({
         "@context" => {
           "foo" => "http://example.com/"
@@ -705,7 +675,7 @@ describe JSON::LD::Context do
     it "@context" do
       expect(subject.parse({
         "foo" => {"@id" => "http://example.com/", "@context" => {"bar" => "http://example.com/baz"}}
-      }).send(:clear_provided_context).
+      }).
       serialize).to produce({
         "@context" => {
           "foo" => {
@@ -721,7 +691,6 @@ describe JSON::LD::Context do
         'xsd' => "http://www.w3.org/2001/XMLSchema#",
         'homepage' => {'@id' => RDF::Vocab::FOAF.homepage.to_s, '@type' => '@id'}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "xsd" => RDF::XSD.to_uri.to_s,
@@ -734,7 +703,6 @@ describe JSON::LD::Context do
       expect(subject.parse({
         'knows' => {'@id' => RDF::Vocab::FOAF.knows.to_s, '@container' => '@list'}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "knows" => {"@id" => RDF::Vocab::FOAF.knows.to_s, "@container" => "@list"}
@@ -746,7 +714,6 @@ describe JSON::LD::Context do
       expect(subject.parse({
         "knows" => {"@id" => RDF::Vocab::FOAF.knows.to_s, "@container" => "@set"}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "knows" => {"@id" => RDF::Vocab::FOAF.knows.to_s, "@container" => "@set"}
@@ -758,7 +725,6 @@ describe JSON::LD::Context do
       expect(subject.parse({
         "name" => {"@id" => RDF::Vocab::FOAF.name.to_s, "@language" => "en"}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "name" => {"@id" => RDF::Vocab::FOAF.name.to_s, "@language" => "en"}
@@ -771,7 +737,6 @@ describe JSON::LD::Context do
         "@language" => 'en',
         "name" => {"@id" => RDF::Vocab::FOAF.name.to_s, "@language" => 'en'}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "@language" => 'en',
@@ -785,7 +750,6 @@ describe JSON::LD::Context do
         "@language" => 'en',
         "name" => {"@id" => RDF::Vocab::FOAF.name.to_s, "@language" => "de"}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "@language" => 'en',
@@ -799,7 +763,6 @@ describe JSON::LD::Context do
         "@language" => 'en',
         "name" => {"@id" => RDF::Vocab::FOAF.name.to_s, "@language" => nil}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "@language" => 'en',
@@ -812,7 +775,6 @@ describe JSON::LD::Context do
       expect(subject.parse({
         "knows" => {"@id" => RDF::Vocab::FOAF.knows.to_s, "@type" => "@id", "@container" => "@list"}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "knows" => {"@id" => RDF::Vocab::FOAF.knows.to_s, "@type" => "@id", "@container" => "@list"}
@@ -824,7 +786,6 @@ describe JSON::LD::Context do
       expect(subject.parse({
         "knows" => {"@id" => RDF::Vocab::FOAF.knows.to_s, "@type" => "@id", "@container" => "@set"}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "knows" => {"@id" => RDF::Vocab::FOAF.knows.to_s, "@type" => "@id", "@container" => "@set"}
@@ -836,7 +797,6 @@ describe JSON::LD::Context do
       expect(subject.parse({
         "knows" => {"@id" => RDF::Vocab::FOAF.knows.to_s, "@type" => "@json"}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "knows" => {"@id" => RDF::Vocab::FOAF.knows.to_s, "@type" => "@json"}
@@ -851,7 +811,6 @@ describe JSON::LD::Context do
           "@container" => "@list"
         }
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "foaf" => RDF::Vocab::FOAF.to_uri.to_s,
@@ -867,7 +826,6 @@ describe JSON::LD::Context do
         "id" => "@id",
         "knows" => {"@id" => RDF::Vocab::FOAF.knows.to_s, "@container" => "@list"}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "id" => "@id",
@@ -884,7 +842,6 @@ describe JSON::LD::Context do
           "@type" => "@id"
         }
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "foaf" => RDF::Vocab::FOAF.to_uri.to_s,
@@ -902,7 +859,6 @@ describe JSON::LD::Context do
         "type" => "@type",
         "foaf:homepage" => {"@type" => "@id"}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "foaf" => RDF::Vocab::FOAF.to_uri.to_s,
@@ -917,7 +873,6 @@ describe JSON::LD::Context do
         "container" => "@container",
         "knows" => {"@id" => RDF::Vocab::FOAF.knows.to_s, "@container" => "@list"}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "container" => "@container",
@@ -931,7 +886,6 @@ describe JSON::LD::Context do
         "ex" => 'http://example.org/',
         "term" => {"@id" => "ex:term", "@type" => "ex:datatype"}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "ex" => 'http://example.org/',
@@ -945,7 +899,6 @@ describe JSON::LD::Context do
         "@vocab" => 'http://example.org/',
         "term" => {"@id" => "http://example.org/term", "@type" => "datatype"}
       }).
-      send(:clear_provided_context).
       serialize).to produce({
         "@context" => {
           "@vocab" => 'http://example.org/',
@@ -954,11 +907,13 @@ describe JSON::LD::Context do
       }, logger)
     end
 
-    context "extra keys or values" do
+    context "invalid term definitions" do
       {
-        "extra key" => {
-          input: {"foo" => {"@id" => "http://example.com/foo", "@baz" => "foobar"}},
-          result: {"@context" => {"foo" => {"@id" => "http://example.com/foo", "@baz" => "foobar"}}}
+        "empty term": {
+          input: {"" => "http://blank-term/"}
+        },
+        "extra key": {
+          input: {"foo" => {"@id" => "http://example.com/foo", "@baz" => "foobar"}}
         }
       }.each do |title, params|
         it title do
@@ -975,7 +930,6 @@ describe JSON::LD::Context do
         '@base' => 'http://base/',
         '@vocab' => 'http://vocab/',
         'ex' => 'http://example.org/',
-        '' => 'http://empty/',
         '_' => 'http://underscore/'
       })
     }
@@ -1039,7 +993,6 @@ describe JSON::LD::Context do
         '@base' => 'http://base/base',
         '@vocab' => 'http://vocab/',
         'ex' => 'http://example.org/',
-        '' => 'http://empty/',
         '_' => 'http://underscore/'
       })
     }
@@ -1119,7 +1072,6 @@ describe JSON::LD::Context do
           "unmapped" =>      ["foo",                 RDF::URI("http://vocab/foo")],
           "relative" =>      ["foo/bar",             RDF::URI("http://vocab/foo/bar")],
           "dotseg" =>        ["../foo/bar",          RDF::URI("http://vocab/../foo/bar")],
-          "empty term" =>    ["",                    RDF::URI("http://empty/")],
           "another abs IRI"=>["ex://foo",            RDF::URI("ex://foo")],
           "absolute IRI looking like a compact IRI" =>
                              ["foo:bar",             RDF::URI("foo:bar")],
@@ -1138,7 +1090,6 @@ describe JSON::LD::Context do
               '@base' => 'http://base/base',
               '@vocab' => '',
               'ex' => 'http://example.org/',
-              '' => 'http://empty/',
               '_' => 'http://underscore/'
             })
           }
@@ -1153,7 +1104,6 @@ describe JSON::LD::Context do
             "unmapped" =>      ["foo",                 RDF::URI("http://base/basefoo")],
             "relative" =>      ["foo/bar",             RDF::URI("http://base/basefoo/bar")],
             "dotseg" =>        ["../foo/bar",          RDF::URI("http://base/base../foo/bar")],
-            "empty term" =>    ["",                    RDF::URI("http://empty/")],
             "another abs IRI"=>["ex://foo",            RDF::URI("ex://foo")],
             "absolute IRI looking like a compact IRI" =>
                                ["foo:bar",             RDF::URI("foo:bar")],
@@ -1183,7 +1133,6 @@ describe JSON::LD::Context do
         '@base'   => 'http://base/',
         "xsd"     => "http://www.w3.org/2001/XMLSchema#",
         'ex'      => 'http://example.org/',
-        ''        => 'http://empty/',
         '_'       => 'http://underscore/',
         'rex'     => {'@reverse' => "ex"},
         'lex'     => {'@id' => 'ex', '@language' => 'en'},
@@ -1258,7 +1207,7 @@ describe JSON::LD::Context do
       it "does not use @vocab if it would collide with a term" do
         subject.set_mapping("name", "http://xmlns.com/foaf/0.1/name")
         subject.set_mapping("ex", nil)
-        expect(subject.compact_iri("http://example.org/name", position: :predicate)).
+        expect(subject.compact_iri("http://example.org/name", vocab: true)).
           not_to produce("name", logger)
       end
 
@@ -1390,7 +1339,6 @@ describe JSON::LD::Context do
         "absolute IRI"  => ["http://example.com/", "http://example.com/"],
         "prefix:suffix" => ["ex:suffix",           "http://example.org/suffix"],
         "keyword"       => ["@type",               "@type"],
-        "empty"         => [":suffix",             "http://empty/suffix"],
         "unmapped"      => ["foo",                 "foo"],
         "bnode"         => [JSON::LD::JsonLdError:: IRIConfusedWithPrefix, RDF::Node("a")],
         "relative"      => ["foo/bar",             "http://base/foo/bar"],
@@ -1412,7 +1360,6 @@ describe JSON::LD::Context do
           "absolute IRI"  => ["http://example.com/", "http://example.com/"],
           "prefix:suffix" => ["suffix",              "http://example.org/suffix"],
           "keyword"       => ["@type",               "@type"],
-          "empty"         => [":suffix",             "http://empty/suffix"],
           "unmapped"      => ["foo",                 "foo"],
           "bnode"         => [JSON::LD::JsonLdError:: IRIConfusedWithPrefix, RDF::Node("a")],
           "relative"      => ["http://base/foo/bar", "http://base/foo/bar"],
@@ -1543,7 +1490,7 @@ describe JSON::LD::Context do
         })
       end
       it "Compact @id that is a property IRI when @container is @list" do
-        expect(ctx.compact_iri("http://example.org/ns#property", position: :subject)).
+        expect(ctx.compact_iri("http://example.org/ns#property", vocab: false)).
           to produce("ex:property", logger)
       end
     end

data/spec/expand_spec.rb

@@ -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
@@ -3356,6 +3376,254 @@ 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_expand params}
+      end
+
+      {
+        "node with embedded subject having no @id": {
+          input: %({
+            "@id": {
+              "ex:prop": "value"
+            },
+            "ex:prop": "value2"
+          }),
+          output: %([{
+            "@id": {
+              "ex:prop": [{"@value": "value"}]
+            },
+            "ex:prop": [{"@value": "value2"}]
+          }])
+        },
+        "node with embedded subject having IRI @id": {
+          input: %({
+            "@id": {
+              "@id": "ex:rei",
+              "ex:prop": "value"
+            },
+            "ex:prop": "value2"
+          }),
+          output: %([{
+            "@id": {
+              "@id": "ex:rei",
+              "ex:prop": [{"@value": "value"}]
+            },
+            "ex:prop": [{"@value": "value2"}]
+          }])
+        },
+        "node with embedded subject having BNode @id": {
+          input: %({
+            "@id": {
+              "@id": "_:rei",
+              "ex:prop": "value"
+            },
+            "ex:prop": "value2"
+          }),
+          output: %([{
+            "@id": {
+              "@id": "_:rei",
+              "ex:prop": [{"@value": "value"}]
+            },
+            "ex:prop": [{"@value": "value2"}]
+          }])
+        },
+        "node with embedded subject having a type": {
+          input: %({
+            "@id": {
+              "@id": "ex:rei",
+              "@type": "ex:Type"
+            },
+            "ex:prop": "value2"
+          }),
+          output: %([{
+            "@id": {
+              "@id": "ex:rei",
+              "@type": ["ex:Type"]
+            },
+            "ex:prop": [{"@value": "value2"}]
+          }])
+        },
+        "node with embedded subject having an IRI value": {
+          input: %({
+            "@id": {
+              "@id": "ex:rei",
+              "ex:prop": {"@id": "ex:value"}
+            },
+            "ex:prop": "value2"
+          }),
+          output: %([{
+            "@id": {
+              "@id": "ex:rei",
+              "ex:prop": [{"@id": "ex:value"}]
+            },
+            "ex:prop": [{"@value": "value2"}]
+          }])
+        },
+        "node with embedded subject having an BNode value": {
+          input: %({
+            "@id": {
+              "@id": "ex:rei",
+              "ex:prop": {"@id": "_:value"}
+            },
+            "ex:prop": "value2"
+          }),
+          output: %([{
+            "@id": {
+              "@id": "ex:rei",
+              "ex:prop": [{"@id": "_:value"}]
+            },
+            "ex:prop": [{"@value": "value2"}]
+          }])
+        },
+        "node with recursive embedded subject": {
+          input: %({
+            "@id": {
+              "@id": {
+                "@id": "ex:rei",
+                "ex:prop": "value3"
+              },
+              "ex:prop": "value"
+            },
+            "ex:prop": "value2"
+          }),
+          output: %([{
+            "@id": {
+              "@id": {
+                "@id": "ex:rei",
+                "ex:prop": [{"@value": "value3"}]
+              },
+              "ex:prop": [{"@value": "value"}]
+            },
+            "ex:prop": [{"@value": "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"
+              }
+            }
+          }),
+          output: %([{
+            "@id": "ex:subj",
+            "ex:value": [{
+              "@id": {
+                "@id": "ex:rei",
+                "ex:prop": [{"@value": "value"}]
+              }
+            }]
+          }])
+        },
+        "illegal node with embedded object having properties": {
+          input: %({
+            "@id": "ex:subj",
+            "ex:value": {
+              "@id": {
+                "@id": "ex:rei",
+                "ex:prop": "value"
+              },
+              "ex:prop": "value2"
+            }
+          }),
+          output: %([{
+            "@id": "ex:subj",
+            "ex:value": [{
+              "@id": {
+                "@id": "ex:rei",
+                "ex:prop": [{"@value": "value"}]
+              },
+              "ex:prop": [{"@value": "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"
+            }
+          }),
+          output: %([{
+            "@id": "ex:subj",
+            "ex:value": [{
+              "@id": {
+                "@id": {
+                  "@id": "ex:rei",
+                  "ex:prop": [{"@value": "value3"}]
+                },
+                "ex:prop":[{"@value": "value"}]
+              },
+              "ex:prop": [{"@value": "value2"}]
+            }]
+          }])
+        },
+      }.each do |title, params|
+        it(title) {run_expand params.merge(rdfstar: true)}
+      end
+    end
+
     begin
       require 'nokogiri'
     rescue LoadError
@@ -3366,7 +3634,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 +3773,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 +3887,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 +3904,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 +3921,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 +3990,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