json-ld 3.0.2 → 3.1.0

data/lib/json/ld/resource.rb

@@ -142,8 +142,8 @@ module JSON::LD
     #
     # @param [Hash] options
     # @return [String] serizlied JSON representation of resource
-    def to_json(options = nil)
-      deresolve.to_json(options)
+    def to_json(**options)
+      deresolve.to_json(**options)
     end
 
     ##

data/lib/json/ld/streaming_writer.rb

@@ -60,6 +60,8 @@ module JSON::LD
 
         pd << if statement.object.resource?
           {'@id' => statement.object.to_s}
+        elsif statement.object.datatype == RDF::URI(RDF.to_uri + "JSON")
+          {"@value" => MultiJson.load(statement.object.to_s), "@type" => "@json"}
         else
           lit = {"@value" => statement.object.to_s}
           lit["@type"] = statement.object.datatype.to_s if statement.object.has_datatype?
@@ -110,7 +112,7 @@ module JSON::LD
       @output.puts(",") if [:wrote_node, :wrote_graph].include?(@state)
       if @current_node_def
         node_def = if context
-          compacted = JSON::LD::API.compact(@current_node_def, context, rename_bnodes: false)
+          compacted = JSON::LD::API.compact(@current_node_def, context, rename_bnodes: false, **@options)
           compacted.delete('@context')
           compacted
         else

data/lib/json/ld/to_rdf.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 require 'rdf'
 require 'rdf/nquads'
+require 'json/canonicalization'
 
 module JSON::LD
   module ToRDF
@@ -18,6 +19,8 @@ module JSON::LD
       if value?(item)
         value, datatype = item.fetch('@value'), item.fetch('@type', nil)
 
+        datatype = RDF::URI(RDF.to_uri + "JSON") if datatype == '@json'
+
         case value
         when TrueClass, FalseClass
           # If value is true or false, then set value its canonical lexical form as defined in the section Data Round Tripping. If datatype is null, set it to xsd:boolean.
@@ -25,17 +28,48 @@ module JSON::LD
           datatype ||= RDF::XSD.boolean.to_s
         when Numeric
           # Otherwise, if value is a number, then set value to its canonical lexical form as defined in the section Data Round Tripping. If datatype is null, set it to either xsd:integer or xsd:double, depending on if the value contains a fractional and/or an exponential component.
-          lit = RDF::Literal.new(value, canonicalize: true)
-          value = lit.to_s
-          datatype ||= lit.datatype
+          value = if datatype == RDF::URI(RDF.to_uri + "JSON")
+            value.to_json_c14n
+          else
+            # Don't serialize as double if there are no fractional bits
+            as_double = value.ceil != value || value >= 1e21 || datatype == RDF::XSD.double
+            lit = if as_double
+              RDF::Literal::Double.new(value, canonicalize: true)
+            else
+              RDF::Literal.new(value.numerator, canonicalize: true)
+            end
+
+            datatype ||= lit.datatype
+            lit.to_s.sub("E+", "E")
+          end
+        when Array, Hash
+          # Only valid for rdf:JSON
+          value = value.to_json_c14n
         else
+          if item.has_key?('@direction') && @options[:rdfDirection]
+            # Either serialize using a datatype, or a compound-literal
+            case @options[:rdfDirection]
+            when 'i18n-datatype'
+              datatype = RDF::URI("https://www.w3.org/ns/i18n##{item.fetch('@language', '')}_#{item['@direction']}")
+            when 'compound-literal'
+              cl = RDF::Node.new
+              yield RDF::Statement(cl, RDF.value, item['@value'].to_s)
+              yield RDF::Statement(cl, RDF.to_uri + 'language', item['@language']) if item['@language']
+              yield RDF::Statement(cl, RDF.to_uri + 'direction', item['@direction'])
+              return cl
+            end
+          end
+
           # Otherwise, if datatype is null, set it to xsd:string or xsd:langString, depending on if item has a @language key.
           datatype ||= item.has_key?('@language') ? RDF.langString : RDF::XSD.string
+          if datatype == RDF::URI(RDF.to_uri + "JSON")
+            value = value.to_json_c14n
+          end
         end
         datatype = RDF::URI(datatype) if datatype && !datatype.is_a?(RDF::URI)
                   
         # Initialize literal as an RDF literal using value and datatype. If element has the key @language and datatype is xsd:string, then add the value associated with the @language key as the language of the object.
-        language = item.fetch('@language', nil)
+        language = item.fetch('@language', nil) if datatype == RDF.langString
         return RDF::Literal.new(value, datatype: datatype, language: language)
       elsif list?(item)
         # If item is a list object, initialize list_results as an empty array, and object to the result of the List Conversion algorithm, passing the value associated with the @list key from item and list_results.
@@ -65,21 +99,17 @@ module JSON::LD
             #log_debug("item_to_rdf")  {"@reverse predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
             # For each item in values
             vv.each do |v|
-              if list?(v)
-                #log_debug("item_to_rdf")  {"list: #{v.inspect}"}
-                object = item_to_rdf(v, graph_name: graph_name, &block)
-
-                # Append a triple composed of object, prediate, and object to results and add all triples from list_results to results.
-                yield RDF::Statement(object, predicate, subject, graph_name: graph_name)
-              else
-                # Otherwise, item is a value object or a node definition. Generate object as the result of the Object Converstion algorithm passing item.
-                object = item_to_rdf(v, graph_name: graph_name, &block)
-                #log_debug("item_to_rdf")  {"subject: #{object.to_ntriples rescue 'malformed rdf'}"}
-                # yield subject, prediate, and literal to results.
-                yield RDF::Statement(object, predicate, subject, graph_name: graph_name)
-              end
+              # Item is a node definition. Generate object as the result of the Object Converstion algorithm passing item.
+              object = item_to_rdf(v, graph_name: graph_name, &block)
+              #log_debug("item_to_rdf")  {"subject: #{object.to_ntriples rescue 'malformed rdf'}"}
+              # yield subject, prediate, and literal to results.
+              yield RDF::Statement(object, predicate, subject, graph_name: graph_name)
             end
           end
+        when '@included'
+          values.each do |v|
+            item_to_rdf(v, graph_name: graph_name, &block)
+          end
         when /^@/
           # Otherwise, if @type is any other keyword, skip to the next property-values pair
         else

data/lib/json/ld/utils.rb

@@ -49,7 +49,7 @@ module JSON::LD
     ##
     # Is value an expaned @graph?
     #
-    # Note: A value is a simple graph if all of these hold true:
+    # Note: A value is a graph if all of these hold true:
     # 1. It is an object.
     # 2. It has an `@graph` key.
     # 3. It may have '@context', '@id' or '@index'
@@ -59,8 +59,10 @@ module JSON::LD
     def graph?(value)
       value.is_a?(Hash) && (value.keys - UTIL_GRAPH_KEYS) == ['@graph']
     end
+
     ##
-    # Is value a simple @graph (lacking @id)?
+    # Is value a simple graph (lacking @id)?
+    #
     # @param [Object] value
     # @return [Boolean]
     def simple_graph?(value)

data/lib/json/ld/writer.rb

@@ -1,6 +1,8 @@
 # -*- encoding: utf-8 -*-
 # frozen_string_literal: true
 require 'json/ld/streaming_writer'
+require 'link_header'
+
 module JSON::LD
   ##
   # A JSON-LD parser in Ruby.
@@ -50,8 +52,8 @@ module JSON::LD
   #
   # Select the :expand option to output JSON-LD in expanded form
   #
-  # @see http://json-ld.org/spec/ED/20110507/
-  # @see http://json-ld.org/spec/ED/20110507/#the-normalization-algorithm
+  # @see https://www.w3.org/TR/json-ld11-api/
+  # @see https://www.w3.org/TR/json-ld11-api/#the-normalization-algorithm
   # @author [Gregg Kellogg](http://greggkellogg.net/)
   class Writer < RDF::Writer
     include StreamingWriter
@@ -94,17 +96,23 @@ module JSON::LD
           description: "Context to use when compacting.") {|arg| RDF::URI(arg)},
         RDF::CLI::Option.new(
           symbol: :embed,
-          datatype: %w(@always @last @never),
-          default: '@last',
+          datatype: %w(@always @once @never),
+          default: '@once',
           control: :select,
           on: ["--embed EMBED"],
-          description: "How to embed matched objects (@last).") {|arg| RDF::URI(arg)},
+          description: "How to embed matched objects (@once).") {|arg| RDF::URI(arg)},
         RDF::CLI::Option.new(
           symbol: :explicit,
           datatype: TrueClass,
           control: :checkbox,
           on: ["--[no-]explicit"],
           description: "Only include explicitly declared properties in output (false)") {|arg| arg},
+        RDF::CLI::Option.new(
+          symbol: :lowercaseLanguage,
+          datatype: TrueClass,
+          control: :checkbox,
+          on: ["--[no-]lowercase-language"],
+          description: "By default, language tags are left as is. To normalize to lowercase, set this option to `true`."),
         RDF::CLI::Option.new(
           symbol: :omitDefault,
           datatype: TrueClass,
@@ -123,6 +131,13 @@ module JSON::LD
           control: :radio,
           on: ["--processingMode MODE", %w(json-ld-1.0 json-ld-1.1)],
           description: "Set Processing Mode (json-ld-1.0 or json-ld-1.1)"),
+        RDF::CLI::Option.new(
+          symbol: :rdfDirection,
+          datatype: %w(i18n-datatype compound-literal),
+          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)},
         RDF::CLI::Option.new(
           symbol: :requireAll,
           datatype: TrueClass,
@@ -136,6 +151,12 @@ module JSON::LD
           control: :checkbox,
           on: ["--[no-]stream"],
           description: "Do not attempt to optimize graph presentation, suitable for streaming large graphs.") {|arg| arg},
+        RDF::CLI::Option.new(
+          symbol: :useNativeTypes,
+          datatype: TrueClass,
+          control: :checkbox,
+          on: ["--[no-]use-native-types"],
+          description: "Use native JSON values in value objects.") {|arg| arg},
         RDF::CLI::Option.new(
           symbol: :useRdfType,
           datatype: TrueClass,
@@ -145,6 +166,41 @@ module JSON::LD
       ]
     end
 
+    class << self
+      attr_reader :white_list
+      attr_reader :black_list
+
+      ##
+      # Use parameters from accept-params to determine if the parameters are acceptable to invoke this writer. The `accept_params` will subsequently be provided to the writer instance.
+      #
+      # @param [Hash{Symbol => String}] accept_params
+      # @yield [accept_params] if a block is given, returns the result of evaluating that block
+      # @yieldparam [Hash{Symbol => String}] accept_params
+      # @return [Boolean]
+      # @see    http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+      def accept?(accept_params)
+        # Profiles that aren't specific IANA relations represent the URL
+        # of a context or frame that may be subject to black- or white-listing
+        profile = accept_params[:profile].to_s.split(/\s+/)
+
+        if block_given?
+          yield(accept_params)
+        else
+          true
+        end
+      end
+
+      ##
+      # Returns default context used for compacted profile without an explicit context URL
+      # @return [String]
+      def default_context; @default_context || JSON::LD::DEFAULT_CONTEXT; end
+
+      ##
+      # Sets default context used for compacted profile without an explicit context URL
+      # @param [String] url
+      def default_context=(url); @default_context = url; end
+    end
+
     ##
     # Initializes the RDF-LD writer instance.
     #
@@ -237,13 +293,19 @@ module JSON::LD
       else
 
         log_debug("writer") { "serialize #{@repo.count} statements, #{@options.inspect}"}
-        result = API.fromRdf(@repo, @options)
+        result = API.fromRdf(@repo, **@options)
+
+        # Some options may be indicated from accept parameters
+        profile = @options.fetch(:accept_params, {}).fetch(:profile, "").split(' ')
+        links = LinkHeader.parse(@options[:link])
+        @options[:context] ||= links.find_link(['rel', JSON_LD_NS+"context"]).href rescue nil
+        @options[:context] ||= Writer.default_context if profile.include?(JSON_LD_NS+"compacted")
+        @options[:frame] ||= links.find_link(['rel', JSON_LD_NS+"frame"]).href rescue nil
 
         # If we were provided a context, or prefixes, use them to compact the output
-        context = RDF::Util::File.open_file(@options[:context]) if @options[:context].is_a?(String)
-        context ||= @options[:context]
+        context = @options[:context]
         context ||= if @options[:prefixes] || @options[:language] || @options[:standard_prefixes]
-          ctx = Context.new(@options)
+          ctx = Context.new(**@options)
           ctx.language = @options[:language] if @options[:language]
           @options[:prefixes].each do |prefix, iri|
             ctx.set_mapping(prefix, iri) if prefix && iri
@@ -253,18 +315,17 @@ module JSON::LD
 
         # Rename BNodes to uniquify them, if necessary
         if options[:unique_bnodes]
-          result = API.flatten(result, context, @options)
+          result = API.flatten(result, context, **@options)
         end
 
-        frame = RDF::Util::File.open_file(@options[:frame]) if @options[:frame].is_a?(String)
-        if frame ||= @options[:frame]
+        if frame = @options[:frame]
           # Perform framing, if given a frame
           log_debug("writer") { "frame result"}
-          result = API.frame(result, frame, @options)
+          result = API.frame(result, frame, **@options)
         elsif context
           # Perform compaction, if we have a context
           log_debug("writer") { "compact result"}
-          result = API.compact(result, context,  @options)
+          result = API.compact(result, context,  **@options)
         end
 
         @output.write(result.to_json(JSON_STATE))

data/spec/api_spec.rb

@@ -1,3 +1,4 @@
+
 # coding: utf-8
 require_relative 'spec_helper'
 
@@ -8,54 +9,32 @@ describe JSON::LD::API do
   describe "#initialize" do
     context "with string input" do
       let(:context) do
-        JSON::LD::API::RemoteDocument.new("http://example.com/context", %q({
+        JSON::LD::API::RemoteDocument.new(%q({
           "@context": {
             "xsd": "http://www.w3.org/2001/XMLSchema#",
             "name": "http://xmlns.com/foaf/0.1/name",
             "homepage": {"@id": "http://xmlns.com/foaf/0.1/homepage", "@type": "@id"},
             "avatar": {"@id": "http://xmlns.com/foaf/0.1/avatar", "@type": "@id"}
           }
-        }))
+          }),
+          documentUrl: "http://example.com/context",
+          contentType: 'application/ld+json'
+        )
       end
       let(:remote_doc) do
-        JSON::LD::API::RemoteDocument.new("http://example.com/foo", %q({
-          "@id": "",
-          "name": "foo"
-        }), "http://example.com/context")
+        JSON::LD::API::RemoteDocument.new(%q({"@id": "", "name": "foo"}),
+          documentUrl: "http://example.com/foo",
+          contentType: 'application/ld+json',
+          contextUrl: "http://example.com/context"
+        )
       end
 
       it "loads document with loader and loads context" do
-        expect(described_class).to receive(:documentLoader).with("http://example.com/foo", anything).and_return(remote_doc)
+        expect(described_class).to receive(:documentLoader).with("http://example.com/foo", anything).and_yield(remote_doc)
         expect(described_class).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(context)
         described_class.new("http://example.com/foo", nil)
       end
     end
-
-    context "with RDF::Util::File::RemoteDoc input" do
-      let(:context) do
-        JSON::LD::API::RemoteDocument.new("http://example.com/context", %q({
-          "@context": {
-            "xsd": "http://www.w3.org/2001/XMLSchema#",
-            "name": "http://xmlns.com/foaf/0.1/name",
-            "homepage": {"@id": "http://xmlns.com/foaf/0.1/homepage", "@type": "@id"},
-            "avatar": {"@id": "http://xmlns.com/foaf/0.1/avatar", "@type": "@id"}
-          }
-        }))
-      end
-      let(:remote_doc) do
-        RDF::Util::File::RemoteDocument.new(%q({"@id": "", "name": "foo"}),
-          headers: {
-            content_type: 'application/json',
-            link: %(<http://example.com/context>; rel="http://www.w3.org/ns/json-ld#context"; type="application/ld+json")
-          }
-        )
-      end
-
-      it "processes document and retrieves linked context" do
-        expect(described_class).to receive(:documentLoader).with("http://example.com/context", anything).and_yield(context)
-        described_class.new(remote_doc, nil)
-      end
-    end
   end
 
   context "when validating", pending: ("JRuby support for jsonlint" if RUBY_ENGINE == "jruby") do
@@ -80,7 +59,7 @@ describe JSON::LD::API do
             it "expands" do
               options = {logger: logger, adapter: adapter}
               options[:expandContext] = File.open(context) if context
-              jld = described_class.expand(File.open(filename), options)
+              jld = described_class.expand(File.open(filename), **options)
               expect(jld).to produce_jsonld(JSON.load(File.open(expanded)), logger)
             end if File.exist?(expanded)
         

data/spec/compact_spec.rb

@@ -125,6 +125,18 @@ describe JSON::LD::API do
           "b": ["c"]
         })
       },
+      "@set coercion on @type" => {
+        input: %({
+          "@type": "http://www.w3.org/2000/01/rdf-schema#Resource",
+          "http://example.org/foo": {"@value": "bar", "@type": "http://example.com/type"}
+        }),
+        context: %({"@version": 1.1, "@type": {"@container": "@set"}}),
+        output: %({
+          "@context": {"@version": 1.1, "@type": {"@container": "@set"}},
+          "@type": ["http://www.w3.org/2000/01/rdf-schema#Resource"],
+          "http://example.org/foo": {"@value": "bar", "@type": "http://example.com/type"}
+        })
+      },
       "empty @set coercion" => {
         input: %({
           "http://example.com/b": []
@@ -176,6 +188,25 @@ describe JSON::LD::API do
           "term5": [ "v5", "plain literal" ]
         })
       },
+      "default direction" => {
+        input: %({
+          "http://example.com/term": [
+            "v5",
+            {"@value": "plain literal"}
+          ]
+        }),
+        context: %({
+          "term5": {"@id": "http://example.com/term", "@direction": null},
+          "@direction": "ltr"
+        }),
+        output: %({
+          "@context": {
+            "term5": {"@id": "http://example.com/term", "@direction": null},
+            "@direction": "ltr"
+          },
+          "term5": [ "v5", "plain literal" ]
+        })
+      },
     }.each_pair do |title, params|
       it(title) {run_compact(params)}
     end
@@ -206,6 +237,19 @@ describe JSON::LD::API do
             "http://example.org/foo": {"@value": "bar", "type": "http://example.com/type"}
           })
         },
+        "@type with @container: @set": {
+          input: %({
+            "@type": "http://www.w3.org/2000/01/rdf-schema#Resource",
+            "http://example.org/foo": {"@value": "bar", "@type": "http://example.com/type"}
+          }),
+          context: %({"type": {"@id": "@type", "@container": "@set"}}),
+          output: %({
+            "@context": {"type": {"@id": "@type", "@container": "@set"}},
+            "type": ["http://www.w3.org/2000/01/rdf-schema#Resource"],
+            "http://example.org/foo": {"@value": "bar", "type": "http://example.com/type"}
+          }),
+          processingMode: 'json-ld-1.1'
+        },
         "@language" => {
           input: %({
             "http://example.org/foo": {"@value": "bar", "@language": "baz"}
@@ -216,6 +260,16 @@ describe JSON::LD::API do
             "http://example.org/foo": {"@value": "bar", "language": "baz"}
           })
         },
+        "@direction" => {
+          input: %({
+            "http://example.org/foo": {"@value": "bar", "@direction": "ltr"}
+          }),
+          context: %({"direction": "@direction"}),
+          output: %({
+            "@context": {"direction": "@direction"},
+            "http://example.org/foo": {"@value": "bar", "direction": "ltr"}
+          })
+        },
         "@value" => {
           input: %({
             "http://example.org/foo": {"@value": "bar", "@language": "baz"}
@@ -259,6 +313,22 @@ describe JSON::LD::API do
             "term5": "v1"
           })
         },
+        "Uses term with null direction when two terms conflict on direction" => {
+          input: %([{
+            "http://example.com/term": {"@value": "v1"}
+          }]),
+          context: %({
+            "term5": {"@id": "http://example.com/term","@direction": null},
+            "@direction": "ltr"
+          }),
+          output: %({
+            "@context": {
+              "term5": {"@id": "http://example.com/term","@direction": null},
+              "@direction": "ltr"
+            },
+            "term5": "v1"
+          })
+        },
         "Uses subject alias" => {
           input: %([{
             "@id": "http://example.com/id1",
@@ -489,7 +559,9 @@ describe JSON::LD::API do
 
     context "context as reference" do
       let(:remote_doc) do
-        JSON::LD::API::RemoteDocument.new("http://example.com/context", %q({"@context": {"b": "http://example.com/b"}}))
+        JSON::LD::API::RemoteDocument.new(
+          %q({"@context": {"b": "http://example.com/b"}}),
+          documentUrl: "http://example.com/context")
       end
       it "uses referenced context" do
         input = ::JSON.parse %({
@@ -527,6 +599,26 @@ describe JSON::LD::API do
             "foo_de": ["de"]
           })
         },
+        "1 term 2 lists 2 directions" => {
+          input: %([{
+            "http://example.com/foo": [
+              {"@list": [{"@value": "en", "@direction": "ltr"}]},
+              {"@list": [{"@value": "ar", "@direction": "rtl"}]}
+            ]
+          }]),
+          context: %({
+            "foo_ltr": {"@id": "http://example.com/foo", "@container": "@list", "@direction": "ltr"},
+            "foo_rtl": {"@id": "http://example.com/foo", "@container": "@list", "@direction": "rtl"}
+          }),
+          output: %({
+            "@context": {
+              "foo_ltr": {"@id": "http://example.com/foo", "@container": "@list", "@direction": "ltr"},
+              "foo_rtl": {"@id": "http://example.com/foo", "@container": "@list", "@direction": "rtl"}
+            },
+            "foo_ltr": ["en"],
+            "foo_rtl": ["ar"]
+          })
+        },
         "coerced @list containing an empty list" => {
           input: %([{
             "http://example.com/foo": [{"@list": [{"@list": []}]}]
@@ -598,6 +690,145 @@ describe JSON::LD::API do
       end
     end
 
+    context "with @type: @json" do
+      {
+        "true": {
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "e": {"@id": "http://example.org/vocab#bool", "@type": "@json"}
+            },
+            "e": true
+          }),
+          input:%( [{
+            "http://example.org/vocab#bool": [{"@value": true, "@type": "@json"}]
+          }]),
+        },
+        "false": {
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "e": {"@id": "http://example.org/vocab#bool", "@type": "@json"}
+            },
+            "e": false
+          }),
+          input: %([{
+            "http://example.org/vocab#bool": [{"@value": false, "@type": "@json"}]
+          }]),
+        },
+        "double": {
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "e": {"@id": "http://example.org/vocab#double", "@type": "@json"}
+            },
+            "e": 1.23
+          }),
+          input: %([{
+            "http://example.org/vocab#double": [{"@value": 1.23, "@type": "@json"}]
+          }]),
+        },
+        "double-zero": {
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "e": {"@id": "http://example.org/vocab#double", "@type": "@json"}
+            },
+            "e": 0.0e0
+          }),
+          input: %([{
+            "http://example.org/vocab#double": [{"@value": 0.0e0, "@type": "@json"}]
+          }]),
+        },
+        "integer": {
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "e": {"@id": "http://example.org/vocab#integer", "@type": "@json"}
+            },
+            "e": 123
+          }),
+          input: %([{
+            "http://example.org/vocab#integer": [{"@value": 123, "@type": "@json"}]
+          }]),
+        },
+        "string": {
+          input: %([{
+            "http://example.org/vocab#string": [{
+              "@value": "string",
+              "@type": "@json"
+            }]
+          }]),
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "e": {"@id": "http://example.org/vocab#string", "@type": "@json"}
+            },
+            "e": "string"
+          })
+        },
+        "null": {
+          input: %([{
+            "http://example.org/vocab#null": [{
+              "@value": null,
+              "@type": "@json"
+            }]
+          }]),
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "e": {"@id": "http://example.org/vocab#null", "@type": "@json"}
+            },
+            "e": null
+          })
+        },
+        "object": {
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "e": {"@id": "http://example.org/vocab#object", "@type": "@json"}
+            },
+            "e": {"foo": "bar"}
+          }),
+          input: %([{
+            "http://example.org/vocab#object": [{"@value": {"foo": "bar"}, "@type": "@json"}]
+          }]),
+        },
+        "array": {
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "e": {"@id": "http://example.org/vocab#array", "@type": "@json", "@container": "@set"}
+            },
+            "e": [{"foo": "bar"}]
+          }),
+          input: %([{
+            "http://example.org/vocab#array": [{"@value": [{"foo": "bar"}], "@type": "@json"}]
+          }]),
+        },
+        "Already expanded object": {
+          output: %({
+            "@context": {"@version": 1.1},
+            "http://example.org/vocab#object": {"@value": {"foo": "bar"}, "@type": "@json"}
+          }),
+          input: %([{
+            "http://example.org/vocab#object": [{"@value": {"foo": "bar"}, "@type": "@json"}]
+          }]),
+        },
+        "Already expanded object with aliased keys": {
+          output: %({
+            "@context": {"@version": 1.1, "value": "@value", "type": "@type", "json": "@json"},
+            "http://example.org/vocab#object": {"value": {"foo": "bar"}, "type": "json"}
+          }),
+          input: %([{
+            "http://example.org/vocab#object": [{"@value": {"foo": "bar"}, "@type": "@json"}]
+          }])
+        },
+      }.each do |title, params|
+        it(title) {run_compact(processingMode: 'json-ld-1.1', **params)}
+      end
+    end
+
     context "@container: @index" do
       {
         "compact-0029" => {
@@ -725,6 +956,164 @@ describe JSON::LD::API do
       }.each_pair do |title, params|
         it(title) {run_compact(params)}
       end
+
+      context "@index: property" do
+        {
+          "property-valued index indexes property value, instead of property (value)": {
+            output: %({
+              "@context": {
+                "@version": 1.1,
+                "@base": "http://example.com/",
+                "@vocab": "http://example.com/",
+                "author": {"@type": "@id", "@container": "@index", "@index": "prop"}
+              },
+              "@id": "article",
+              "author": {
+                "regular": {"@id": "person/1"},
+                "guest": [{"@id": "person/2"}, {"@id": "person/3"}]
+              }
+            }),
+            input: %([{
+              "@id": "http://example.com/article",
+              "http://example.com/author": [
+                {"@id": "http://example.com/person/1", "http://example.com/prop": [{"@value": "regular"}]},
+                {"@id": "http://example.com/person/2", "http://example.com/prop": [{"@value": "guest"}]},
+                {"@id": "http://example.com/person/3", "http://example.com/prop": [{"@value": "guest"}]}
+              ]
+            }])
+          },
+          "property-valued index indexes property value, instead of @index (multiple values)": {
+            output: %({
+              "@context": {
+                "@version": 1.1,
+                "@base": "http://example.com/",
+                "@vocab": "http://example.com/",
+                "author": {"@type": "@id", "@container": "@index", "@index": "prop"}
+              },
+              "@id": "article",
+              "author": {
+                "regular": {"@id": "person/1", "prop": "foo"},
+                "guest": [
+                  {"@id": "person/2", "prop": "foo"},
+                  {"@id": "person/3", "prop": "foo"}
+                ]
+              }
+            }),
+            input: %([{
+              "@id": "http://example.com/article",
+              "http://example.com/author": [
+                {"@id": "http://example.com/person/1", "http://example.com/prop": [{"@value": "regular"}, {"@value": "foo"}]},
+                {"@id": "http://example.com/person/2", "http://example.com/prop": [{"@value": "guest"}, {"@value": "foo"}]},
+                {"@id": "http://example.com/person/3", "http://example.com/prop": [{"@value": "guest"}, {"@value": "foo"}]}
+              ]
+            }])
+          },
+          "property-valued index extracts property value, instead of @index (node)": {
+            output: %({
+              "@context": {
+                "@version": 1.1,
+                "@base": "http://example.com/",
+                "@vocab": "http://example.com/",
+                "author": {"@type": "@vocab", "@container": "@index", "@index": "prop"},
+                "prop": {"@type": "@id"}
+              },
+              "@id": "article",
+              "author": {
+                "regular": {"@id": "person/1"},
+                "guest": [
+                  {"@id": "person/2"},
+                  {"@id": "person/3"}
+                ]
+              }
+            }),
+            input: %([{
+              "@id": "http://example.com/article",
+              "http://example.com/author": [
+                {"@id": "http://example.com/person/1", "http://example.com/prop": [{"@id": "http://example.com/regular"}]},
+                {"@id": "http://example.com/person/2", "http://example.com/prop": [{"@id": "http://example.com/guest"}]},
+                {"@id": "http://example.com/person/3", "http://example.com/prop": [{"@id": "http://example.com/guest"}]}
+              ]
+            }])
+          },
+          "property-valued index indexes property value, instead of property (multimple nodes)": {
+            output: %({
+              "@context": {
+                "@version": 1.1,
+                "@base": "http://example.com/",
+                "@vocab": "http://example.com/",
+                "author": {"@type": "@vocab", "@container": "@index", "@index": "prop"},
+                "prop": {"@type": "@id"}
+              },
+              "@id": "article",
+              "author": {
+                "regular": {"@id": "person/1", "prop": "foo"},
+                "guest": [
+                  {"@id": "person/2", "prop": "foo"},
+                  {"@id": "person/3", "prop": "foo"}
+                ]
+              }
+            }),
+            input: %([{
+              "@id": "http://example.com/article",
+              "http://example.com/author": [
+                {"@id": "http://example.com/person/1", "http://example.com/prop": [{"@id": "http://example.com/regular"}, {"@id": "http://example.com/foo"}]},
+                {"@id": "http://example.com/person/2", "http://example.com/prop": [{"@id": "http://example.com/guest"}, {"@id": "http://example.com/foo"}]},
+                {"@id": "http://example.com/person/3", "http://example.com/prop": [{"@id": "http://example.com/guest"}, {"@id": "http://example.com/foo"}]}
+              ]
+            }])
+          },
+          "property-valued index indexes using @none if no property value exists": {
+            output: %({
+              "@context": {
+                "@version": 1.1,
+                "@base": "http://example.com/",
+                "@vocab": "http://example.com/",
+                "author": {"@type": "@id", "@container": "@index", "@index": "prop"}
+              },
+              "@id": "article",
+              "author": {
+                "@none": ["person/1", "person/2", "person/3"]
+              }
+            }),
+            input: %([{
+              "@id": "http://example.com/article",
+              "http://example.com/author": [
+                {"@id": "http://example.com/person/1"},
+                {"@id": "http://example.com/person/2"},
+                {"@id": "http://example.com/person/3"}
+              ]
+            }])
+          },
+          "property-valued index indexes using @none if no property value does not compact to string": {
+            output: %({
+              "@context": {
+                "@version": 1.1,
+                "@base": "http://example.com/",
+                "@vocab": "http://example.com/",
+                "author": {"@type": "@id", "@container": "@index", "@index": "prop"}
+              },
+              "@id": "article",
+              "author": {
+                "@none": [
+                  {"@id": "person/1", "prop": {"@id": "regular"}},
+                  {"@id": "person/2", "prop": {"@id": "guest"}},
+                  {"@id": "person/3", "prop": {"@id": "guest"}}
+                ]
+              }
+            }),
+            input: %([{
+              "@id": "http://example.com/article",
+              "http://example.com/author": [
+                {"@id": "http://example.com/person/1", "http://example.com/prop": [{"@id": "http://example.com/regular"}]},
+                {"@id": "http://example.com/person/2", "http://example.com/prop": [{"@id": "http://example.com/guest"}]},
+                {"@id": "http://example.com/person/3", "http://example.com/prop": [{"@id": "http://example.com/guest"}]}
+              ]
+            }])
+          }
+        }.each do |title, params|
+          it(title) {run_compact(**params)}
+        end
+      end
     end
 
     context "@container: @language" do
@@ -816,6 +1205,173 @@ describe JSON::LD::API do
           }),
           processingMode: "json-ld-1.1"
         },
+        "simple map with term direction": {
+          input: %([
+            {
+              "@id": "http://example.com/queen",
+              "http://example.com/vocab/label": [
+                {"@value": "Die Königin", "@language": "de", "@direction": "ltr"},
+                {"@value": "Ihre Majestät", "@language": "de", "@direction": "ltr"},
+                {"@value": "The Queen", "@language": "en", "@direction": "ltr"}
+              ]
+            }
+          ]),
+          context: %({
+            "@context": {
+              "@version": 1.1,
+              "vocab": "http://example.com/vocab/",
+              "label": {
+                "@id": "vocab:label",
+                "@direction": "ltr",
+                "@container": "@language"
+              }
+            }
+          }),
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "vocab": "http://example.com/vocab/",
+              "label": {
+                "@id": "vocab:label",
+                "@direction": "ltr",
+                "@container": "@language"
+              }
+            },
+            "@id": "http://example.com/queen",
+            "label": {
+              "en": "The Queen",
+              "de": [ "Die Königin", "Ihre Majestät" ]
+            }
+          }),
+          processingMode: "json-ld-1.1"
+        },
+        "simple map with overriding term direction": {
+          input: %([
+            {
+              "@id": "http://example.com/queen",
+              "http://example.com/vocab/label": [
+                {"@value": "Die Königin", "@language": "de", "@direction": "ltr"},
+                {"@value": "Ihre Majestät", "@language": "de", "@direction": "ltr"},
+                {"@value": "The Queen", "@language": "en", "@direction": "ltr"}
+              ]
+            }
+          ]),
+          context: %({
+            "@context": {
+              "@version": 1.1,
+              "@direction": "rtl",
+              "vocab": "http://example.com/vocab/",
+              "label": {
+                "@id": "vocab:label",
+                "@direction": "ltr",
+                "@container": "@language"
+              }
+            }
+          }),
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "@direction": "rtl",
+              "vocab": "http://example.com/vocab/",
+              "label": {
+                "@id": "vocab:label",
+                "@direction": "ltr",
+                "@container": "@language"
+              }
+            },
+            "@id": "http://example.com/queen",
+            "label": {
+              "en": "The Queen",
+              "de": [ "Die Königin", "Ihre Majestät" ]
+            }
+          }),
+          processingMode: "json-ld-1.1"
+        },
+        "simple map with overriding null direction": {
+          input: %([
+            {
+              "@id": "http://example.com/queen",
+              "http://example.com/vocab/label": [
+                {"@value": "Die Königin", "@language": "de"},
+                {"@value": "Ihre Majestät", "@language": "de"},
+                {"@value": "The Queen", "@language": "en"}
+              ]
+            }
+          ]),
+          context: %({
+            "@context": {
+              "@version": 1.1,
+              "@direction": "rtl",
+              "vocab": "http://example.com/vocab/",
+              "label": {
+                "@id": "vocab:label",
+                "@direction": null,
+                "@container": "@language"
+              }
+            }
+          }),
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "@direction": "rtl",
+              "vocab": "http://example.com/vocab/",
+              "label": {
+                "@id": "vocab:label",
+                "@direction": null,
+                "@container": "@language"
+              }
+            },
+            "@id": "http://example.com/queen",
+            "label": {
+              "en": "The Queen",
+              "de": [ "Die Königin", "Ihre Majestät" ]
+            }
+          }),
+          processingMode: "json-ld-1.1"
+        },
+        "simple map with mismatching term direction": {
+          input: %([
+            {
+              "@id": "http://example.com/queen",
+              "http://example.com/vocab/label": [
+                {"@value": "Die Königin", "@language": "de"},
+                {"@value": "Ihre Majestät", "@language": "de", "@direction": "ltr"},
+                {"@value": "The Queen", "@language": "en", "@direction": "rtl"}
+              ]
+            }
+          ]),
+          context: %({
+            "@context": {
+              "@version": 1.1,
+              "vocab": "http://example.com/vocab/",
+              "label": {
+                "@id": "vocab:label",
+                "@direction": "rtl",
+                "@container": "@language"
+              }
+            }
+          }),
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "vocab": "http://example.com/vocab/",
+              "label": {
+                "@id": "vocab:label",
+                "@direction": "rtl",
+                "@container": "@language"
+              }
+            },
+            "@id": "http://example.com/queen",
+            "label": {
+              "en": "The Queen"
+            },
+            "vocab:label": [
+              {"@value": "Die Königin", "@language": "de"},
+              {"@value": "Ihre Majestät", "@language": "de", "@direction": "ltr"}
+            ]
+          }),
+          processingMode: "json-ld-1.1"
+        },
       }.each_pair do |title, params|
         it(title) {run_compact(params)}
       end
@@ -1160,6 +1716,35 @@ describe JSON::LD::API do
             }
           })
         },
+        "Compacts simple graph with @index and multiple nodes" => {
+          input: %([{
+            "http://example.org/input": [{
+              "@graph": [{
+                "http://example.org/value": [{"@value": "x"}]
+              }, {
+                "http://example.org/value": [{"@value": "y"}]
+              }],
+              "@index": "ndx"
+            }]
+          }]),
+          context: %({
+            "@vocab": "http://example.org/",
+            "input": {"@container": "@graph"}
+          }),
+          output: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "input": {"@container": "@graph"}
+            },
+            "input": {
+              "@included": [{
+                "value": "x"
+              }, {
+                "value": "y"
+              }]
+            }
+          })
+        },
         "Does not compact graph with @id" => {
           input: %([{
             "http://example.org/input": [{
@@ -1501,6 +2086,116 @@ describe JSON::LD::API do
       end
     end
 
+    context "@included" do
+      {
+        "Basic Included array": {
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "@vocab": "http://example.org/",
+              "included": {"@id": "@included", "@container": "@set"}
+            },
+            "prop": "value",
+            "included": [{
+              "prop": "value2"
+            }]
+          }),
+          input: %([{
+            "http://example.org/prop": [{"@value": "value"}],
+            "@included": [{
+              "http://example.org/prop": [{"@value": "value2"}]
+            }]
+          }])
+        },
+        "Basic Included object": {
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "@vocab": "http://example.org/"
+            },
+            "prop": "value",
+            "@included": {
+              "prop": "value2"
+            }
+          }),
+          input: %([{
+            "http://example.org/prop": [{"@value": "value"}],
+            "@included": [{
+              "http://example.org/prop": [{"@value": "value2"}]
+            }]
+          }])
+        },
+        "Multiple properties mapping to @included are folded together": {
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "@vocab": "http://example.org/",
+              "included1": "@included",
+              "included2": "@included"
+            },
+            "included1": [
+              {"prop": "value1"},
+              {"prop": "value2"}
+            ]
+          }),
+          input: %([{
+            "@included": [
+              {"http://example.org/prop": [{"@value": "value1"}]},
+              {"http://example.org/prop": [{"@value": "value2"}]}
+            ]
+          }])
+        },
+        "Included containing @included": {
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "@vocab": "http://example.org/"
+            },
+            "prop": "value",
+            "@included": {
+              "prop": "value2",
+              "@included": {
+                "prop": "value3"
+              }
+            }
+          }),
+          input: %([{
+            "http://example.org/prop": [{"@value": "value"}],
+            "@included": [{
+              "http://example.org/prop": [{"@value": "value2"}],
+              "@included": [{
+                "http://example.org/prop": [{"@value": "value3"}]
+              }]
+            }]
+          }])
+        },
+        "Property value with @included": {
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "@vocab": "http://example.org/"
+            },
+            "prop": {
+              "@type": "Foo",
+              "@included": {
+                "@type": "Bar"
+              }
+            }
+          }),
+          input: %([{
+            "http://example.org/prop": [{
+              "@type": ["http://example.org/Foo"],
+              "@included": [{
+                "@type": ["http://example.org/Bar"]
+              }]
+            }]
+          }])
+        },
+      }.each do |title, params|
+        it(title) {run_compact(params)}
+      end
+    end
+
     context "@nest" do
       {
         "Indexes to @nest for property with @nest" => {
@@ -1895,7 +2590,7 @@ describe JSON::LD::API do
             "c": "C in example"
           }),
         },
-        "Raises InvalidTermDefinition if processingMode is not specified" => {
+        "Raises InvalidTermDefinition if processingMode is 1.0" => {
           input: %([{
             "http://example/foo": [{"http://example.org/bar": [{"@value": "baz"}]}]
           }]),
@@ -1903,10 +2598,59 @@ describe JSON::LD::API do
             "@vocab": "http://example/",
             "foo": {"@context": {"bar": "http://example.org/bar"}}
           }),
-          processingMode: nil,
+          processingMode: 'json-ld-1.0',
           validate: true,
           exception: JSON::LD::JsonLdError::InvalidTermDefinition
         },
+        "Scoped on id map": {
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "schema": "http://schema.org/",
+              "name": "schema:name",
+              "body": "schema:articleBody",
+              "words": "schema:wordCount",
+              "post": {
+                "@id": "schema:blogPost",
+                "@container": "@id",
+                "@context": {
+                  "@base": "http://example.com/posts/"
+                }
+              }
+            },
+            "@id": "http://example.com/",
+            "@type": "schema:Blog",
+            "name": "World Financial News",
+            "post": {
+              "1/en": {
+                "body": "World commodities were up today with heavy trading of crude oil...",
+                "words": 1539
+              },
+              "1/de": {
+                "body": "Die Werte an Warenbörsen stiegen im Sog eines starken Handels von Rohöl...",
+                "words": 1204
+              }
+            }
+          }),
+          input: %([{
+            "@id": "http://example.com/",
+            "@type": ["http://schema.org/Blog"],
+            "http://schema.org/name": [{"@value": "World Financial News"}],
+            "http://schema.org/blogPost": [{
+              "@id": "http://example.com/posts/1/en",
+              "http://schema.org/articleBody": [
+                {"@value": "World commodities were up today with heavy trading of crude oil..."}
+              ],
+              "http://schema.org/wordCount": [{"@value": 1539}]
+            }, {
+              "@id": "http://example.com/posts/1/de",
+              "http://schema.org/articleBody": [
+                {"@value": "Die Werte an Warenbörsen stiegen im Sog eines starken Handels von Rohöl..."}
+              ],
+              "http://schema.org/wordCount": [{"@value": 1204}]
+            }]
+          }])
+        },
       }.each_pair do |title, params|
         it(title) {run_compact({processingMode: "json-ld-1.1"}.merge(params))}
       end
@@ -1981,7 +2725,7 @@ describe JSON::LD::API do
             "a": {"type": "Foo", "bar": "baz"}
           }),
         },
-        "deep @context affects nested nodes" => {
+        "deep @context does not affect nested nodes" => {
           input: %([
             {
               "@type": ["http://example/Foo"],
@@ -2000,7 +2744,7 @@ describe JSON::LD::API do
               "Foo": {"@context": {"baz": {"@type": "@vocab"}}}
             },
             "@type": "Foo",
-            "bar": {"baz": "buzz"}
+            "bar": {"baz": {"@id": "http://example/buzz"}}
           }),
         },
         "scoped context layers on intemediate contexts" => {
@@ -2073,7 +2817,7 @@ describe JSON::LD::API do
             }
           })
         },
-        "Raises InvalidTermDefinition if processingMode is not specified" => {
+        "Raises InvalidTermDefinition if processingMode is 1.0" => {
           input: %([
             {
               "http://example/a": [{
@@ -2086,7 +2830,7 @@ describe JSON::LD::API do
             "@vocab": "http://example/",
             "Foo": {"@context": {"bar": "http://example.org/bar"}}
           }),
-          processingMode: nil,
+          processingMode: 'json-ld-1.0',
           validate: true,
           exception: JSON::LD::JsonLdError::InvalidTermDefinition
         },
@@ -2227,16 +2971,231 @@ describe JSON::LD::API do
     end
   end
 
+  context "html" do
+    {
+      "Compacts embedded JSON-LD script element": {
+        input: %(
+        <html>
+          <head>
+            <script type="application/ld+json">
+            {
+              "@context": {
+                "foo": {"@id": "http://example.com/foo", "@container": "@list"}
+              },
+              "foo": [{"@value": "bar"}]
+            }
+            </script>
+          </head>
+        </html>),
+        context: %({"foo": {"@id": "http://example.com/foo", "@container": "@list"}}),
+        output: %({
+          "@context": {
+            "foo": {"@id": "http://example.com/foo", "@container": "@list"}
+          },
+          "foo": ["bar"]
+        })
+      },
+      "Compacts first script element": {
+        input: %(
+        <html>
+          <head>
+            <script type="application/ld+json">
+            {
+              "@context": {
+                "foo": {"@id": "http://example.com/foo", "@container": "@list"}
+              },
+              "foo": [{"@value": "bar"}]
+            }
+            </script>
+            <script type="application/ld+json">
+            {
+              "@context": {"ex": "http://example.com/"},
+              "@graph": [
+                {"ex:foo": {"@value": "foo"}},
+                {"ex:bar": {"@value": "bar"}}
+              ]
+            }
+            </script>
+          </head>
+        </html>),
+        context: %({"foo": {"@id": "http://example.com/foo", "@container": "@list"}}),
+        output: %({
+          "@context": {
+            "foo": {"@id": "http://example.com/foo", "@container": "@list"}
+          },
+          "foo": ["bar"]
+        })
+      },
+      "Compacts targeted script element": {
+        input: %(
+        <html>
+          <head>
+            <script id="first" type="application/ld+json">
+            {
+              "@context": {
+                "foo": {"@id": "http://example.com/foo", "@container": "@list"}
+              },
+              "foo": [{"@value": "bar"}]
+            }
+            </script>
+            <script id="second" type="application/ld+json">
+            {
+              "@context": {"ex": "http://example.com/"},
+              "@graph": [
+                {"ex:foo": {"@value": "foo"}},
+                {"ex:bar": {"@value": "bar"}}
+              ]
+            }
+            </script>
+          </head>
+        </html>),
+        context: %({"ex": "http://example.com/"}),
+        output: %({
+          "@context": {"ex": "http://example.com/"},
+          "@graph": [
+            {"ex:foo": "foo"},
+            {"ex:bar": "bar"}
+          ]
+        }),
+        base: "http://example.org/doc#second"
+      },
+      "Compacts all script elements with extractAllScripts option": {
+        input: %(
+        <html>
+          <head>
+            <script type="application/ld+json">
+            {
+              "@context": {
+                "foo": {"@id": "http://example.com/foo", "@container": "@list"}
+              },
+              "foo": [{"@value": "bar"}]
+            }
+            </script>
+            <script type="application/ld+json">
+            {
+              "@context": {"ex": "http://example.com/"},
+              "@graph": [
+                {"ex:foo": {"@value": "foo"}},
+                {"ex:bar": {"@value": "bar"}}
+              ]
+            }
+            </script>
+          </head>
+        </html>),
+        context: %({
+          "ex": "http://example.com/",
+          "foo": {"@id": "http://example.com/foo", "@container": "@list"}
+        }),
+        output: %({
+          "@context": {
+            "ex": "http://example.com/",
+            "foo": {"@id": "http://example.com/foo", "@container": "@list"}
+          },
+          "@graph": [
+            {"foo": ["bar"]},
+            {
+              "@graph": [
+                {"ex:foo": "foo"},
+                {"ex:bar": "bar"}
+              ]
+            }
+          ]
+        }),
+        extractAllScripts: true
+      },
+    }.each do |title, params|
+      it(title) do
+        params[:input] = StringIO.new(params[:input])
+        params[:input].send(:define_singleton_method, :content_type) {"text/html"}
+        run_compact params.merge(validate: true)
+      end
+    end
+  end
+
+
+  context "problem cases" do
+    {
+      "issue json-ld-framing#64": {
+        input: %({
+          "@context": {
+            "@version": 1.1,
+            "@vocab": "http://example.org/vocab#"
+          },
+          "@id": "http://example.org/1",
+          "@type": "HumanMadeObject",
+          "produced_by": {
+            "@type": "Production",
+            "_label": "Top Production",
+            "part": {
+              "@type": "Production",
+              "_label": "Test Part"
+            }
+          }
+        }),
+        context: %({
+          "@version": 1.1,
+          "@vocab": "http://example.org/vocab#",
+          "Production": {
+            "@context": {
+              "part": {
+                "@type": "@id", 
+                "@container": "@set"
+              }
+            }
+          }
+        }),
+        output: %({
+          "@context": {
+            "@version": 1.1,
+            "@vocab": "http://example.org/vocab#",
+            "Production": {
+              "@context": {
+                "part": {
+                  "@type": "@id", 
+                  "@container": "@set"
+                }
+              }
+            }
+          },
+          "@id": "http://example.org/1",
+          "@type": "HumanMadeObject",
+          "produced_by": {
+            "@type": "Production",
+            "part": [{
+              "@type": "Production",
+              "_label": "Test Part"
+            }],
+            "_label": "Top Production"
+          }
+        }),
+        processingMode: "json-ld-1.1"
+      }
+    }.each do |title, params|
+      it title do
+        run_compact(params)
+      end
+    end
+  end
+
   def run_compact(params)
     input, output, context = params[:input], params[:output], params[:context]
+    params[:base] ||= nil
+    context ||= output  # Since it will have the context
     input = ::JSON.parse(input) if input.is_a?(String)
     output = ::JSON.parse(output) if output.is_a?(String)
     context = ::JSON.parse(context) if context.is_a?(String)
+    context = context['@context'] if context.has_key?('@context')
     pending params.fetch(:pending, "test implementation") unless input
     if params[:exception]
-      expect {JSON::LD::API.compact(input, context, params.merge(logger: logger))}.to raise_error(params[:exception])
+      expect {JSON::LD::API.compact(input, context, logger: logger, **params)}.to raise_error(params[:exception])
     else
-      jld = JSON::LD::API.compact(input, context, params.merge(logger: logger))
+      jld = nil
+      if params[:write]
+        expect{jld = JSON::LD::API.compact(input, context, logger: logger, **params)}.to write(params[:write]).to(:error)
+      else
+        expect{jld = JSON::LD::API.compact(input, context, logger: logger, **params)}.not_to write.to(:error)
+      end
+
       expect(jld).to produce_jsonld(output, logger)
 
       # Compare expanded jld/output too to make sure list values remain ordered