json-ld 2.2.1 → 3.0.0

data/lib/json/ld/from_rdf.rb

@@ -10,23 +10,23 @@ module JSON::LD
     # Generate a JSON-LD array representation from an array of `RDF::Statement`.
     # Representation is in expanded form
     #
-    # @param [Array<RDF::Statement>, RDF::Enumerable] input
+    # @param [Array<RDF::Statement>, RDF::Enumerable] dataset
     # @param [Boolean] useRdfType (false)
     #   If set to `true`, the JSON-LD processor will treat `rdf:type` like a normal property instead of using `@type`.
     # @param [Boolean] useNativeTypes (false) use native representations
     # @return [Array<Hash>] the JSON-LD document in normalized form
-    def from_statements(input, useRdfType: false, useNativeTypes: false)
+    def from_statements(dataset, useRdfType: false, useNativeTypes: false)
       default_graph = {}
       graph_map = {'@default' => default_graph}
-      node_usages_map = {}
+      referenced_once = {}
 
       value = nil
       ec = Context.new
 
       # Create a map for node to object representation
 
-      # For each triple in input
-      input.each do |statement|
+      # For each statement in dataset
+      dataset.each do |statement|
         #log_debug("statement") { statement.to_nquads.chomp}
 
         name = statement.graph_name ? ec.expand_iri(statement.graph_name).to_s : '@default'
@@ -53,16 +53,23 @@ module JSON::LD
 
         merge_value(node, statement.predicate.to_s, value)
 
-        # If object is a blank node identifier or IRI, it might represent the a list node:
-        if statement.object.resource?
+        # If object is a blank node identifier or rdf:nil, it might represent the a list node:
+        if statement.object == RDF.nil
           # Append a new JSON object consisting of three members, node, property, and value to the usages array. The node member is set to a reference to node, property to predicate, and value to a reference to value.
-          merge_value(node_map[statement.object.to_s], :usages, {
+          object = node_map[statement.object.to_s]
+          merge_value(object, :usages, {
             node:     node,
             property: statement.predicate.to_s,
             value:    value
           })
-
-          (node_usages_map[statement.object.to_s] ||= []) << node['@id']
+        elsif referenced_once.has_key?(statement.object.to_s)
+          referenced_once[statement.object.to_s] = false
+        elsif statement.object.node?
+          referenced_once[statement.object.to_s] = {
+            node:     node,
+            property: statement.predicate.to_s,
+            value:    value
+          }
         end
       end
 
@@ -78,30 +85,31 @@ module JSON::LD
           # If property equals rdf:rest, the value associated to the usages member of node has exactly 1 entry, node has a rdf:first and rdf:rest property, both of which have as value an array consisting of a single element, and node has no other members apart from an optional @type member whose value is an array with a single item equal to rdf:List, node represents a well-formed list node. Continue with the following steps:
           #log_debug("list element?") {node.to_json(JSON_STATE) rescue 'malformed json'}
           while property == RDF.rest.to_s &&
-              Array(node_usages_map[node['@id']]).uniq.length == 1 &&
               blank_node?(node) &&
+              referenced_once[node['@id']] &&
               node.keys.none? {|k| !["@id", '@type', :usages, RDF.first.to_s, RDF.rest.to_s].include?(k)} &&
-              Array(node[:usages]).length == 1 &&
               (f = node[RDF.first.to_s]).is_a?(Array) && f.length == 1 &&
               (r = node[RDF.rest.to_s]).is_a?(Array) && r.length == 1 &&
               ((t = node['@type']).nil? || t == [RDF.List.to_s])
             list << Array(node[RDF.first.to_s]).first
             list_nodes << node['@id']
-            node_usage = Array(node[:usages]).first
+
+            # get next node, moving backwards through list
+            node_usage = referenced_once[node['@id']]
             node, property, head = node_usage[:node], node_usage[:property], node_usage[:value]
           end
 
           # If property equals rdf:first, i.e., the detected list is nested inside another list
-          if property == RDF.first.to_s
-            # and the value of the @id of node equals rdf:nil, i.e., the detected list is empty, continue with the next usage item. The rdf:nil node cannot be converted to a list object as it would result in a list of lists, which isn't supported.
-            next if node['@id'] == RDF.nil.to_s
-
-            # Otherwise, the list consists of at least one item. We preserve the head node and transform the rest of the linked list to a list object
-            head_id = head['@id']
-            head = graph_object[head_id]
-            head = Array(head[RDF.rest.to_s]).first
-            list.pop; list_nodes.pop
-          end
+          #if property == RDF.first.to_s
+          #  # and the value of the @id of node equals rdf:nil, i.e., the detected list is empty, continue with the next usage item. The rdf:nil node cannot be converted to a list object as it would result in a list of lists, which isn't supported.
+          #  next if node['@id'] == RDF.nil.to_s
+          #
+          #  # Otherwise, the list consists of at least one item. We preserve the head node and transform the rest of the linked list to a list object
+          #  head_id = head['@id']
+          #  head = graph_object[head_id]
+          #  head = Array(head[RDF.rest.to_s]).first
+          #  list.pop; list_nodes.pop
+          #end
 
           head.delete('@id')
           head['@list'] = list.reverse

data/lib/json/ld/resource.rb

@@ -76,7 +76,7 @@ module JSON::LD
     # @option options [Boolean] :stub (false)
     #   This is a stand-in for another resource that has
     #   not yet been retrieved (or created) from Mongo
-    def initialize(node_definition, options = {})
+    def initialize(node_definition, **options)
       @context = options[:context]
       @clean = options.fetch(:clean, false)
       @new = options.fetch(:new, true)

data/lib/json/ld/to_rdf.rb

@@ -37,6 +37,9 @@ module JSON::LD
         # 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)
         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.
+        return parse_list(item['@list'], graph_name: graph_name, &block)
       end
 
       subject = item['@id'] ? as_resource(item['@id']) : node
@@ -64,8 +67,7 @@ module JSON::LD
             vv.each do |v|
               if list?(v)
                 #log_debug("item_to_rdf")  {"list: #{v.inspect}"}
-                # 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.
-                object = parse_list(v['@list'], graph_name: graph_name, &block)
+                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)

data/lib/json/ld/utils.rb

@@ -110,6 +110,14 @@ module JSON::LD
       end
     end
 
+    ##
+    # Represent as an array
+    # @param [Object] object
+    # @return [Array<Object>]
+    def as_array(object)
+      object.is_a?(Array) ? object : [object]
+    end
+
     ##
     # Compares two JSON-LD values for equality. Two JSON-LD values will be
     # considered equal if:
@@ -142,30 +150,33 @@ module JSON::LD
     # @param [Hash] subject the hash to add the value to.
     # @param [String] property the property that relates the value to the subject.
     # @param [Object] value the value to add.
-    # @param [Hash{Symbol => Object}] options
-    # @option options [Boolean] :property_is_array
-    #   true if the property is always (false)
-    #   an array, false if not.
-    # @option options [Boolean] :allow_duplicate (true)
+    # @param [Boolean] property_is_array (false)
+    #   true if the property is always an array, false if not.
+    # @param [Boolean] value_is_array (false)
+    #   true if the value to be added should be preserved as an array (lists)
+    # @param [Boolean] allow_duplicate (true)
     #   true to allow duplicates, false not to (uses
     #     a simple shallow comparison of subject ID or value).
-    def add_value(subject, property, value, options = {})
-      options = {property_is_array: false, allow_duplicate: true}.merge!(options)
-
-      if value.is_a?(Array)
-        subject[property] = [] if value.empty? && options[:property_is_array]
-        value.each {|v| add_value(subject, property, v, options)}
+    def add_value(subject, property, value, property_is_array: false, value_is_array: false, allow_duplicate: true)
+      if value_is_array
+        subject[property] = value
+      elsif value.is_a?(Array)
+        subject[property] = [] if value.empty? && property_is_array
+        value.each do |v|
+          add_value(subject, property, v,
+            property_is_array: property_is_array, allow_duplicate: allow_duplicate)
+        end
       elsif subject[property]
         # check if subject already has value if duplicates not allowed
-        _has_value = !options[:allow_duplicate] && has_value(subject, property, value)
+        _has_value = !allow_duplicate && has_value(subject, property, value)
 
         # make property an array if value not present or always an array
-        if !subject[property].is_a?(Array) && (!_has_value || options[:property_is_array])
+        if !subject[property].is_a?(Array) && (!_has_value || property_is_array)
           subject[property] = [subject[property]]
         end
         subject[property] << value unless _has_value
       else
-        subject[property] = options[:property_is_array] ? [value] : value
+        subject[property] = property_is_array ? [value] : value
       end
     end
 
@@ -219,27 +230,6 @@ module JSON::LD
         values << value
       end
     end
-
-    # Merge values into compacted results, creating arrays if necessary
-    def merge_compacted_value(hash, key, value)
-      return unless hash
-      case hash[key]
-      when nil then hash[key] = value
-      when Array
-        if value.is_a?(Array)
-          hash[key].concat(value)
-        else
-          hash[key] << value
-        end
-      else
-        hash[key] = [hash[key]]
-        if value.is_a?(Array)
-          hash[key].concat(value)
-        else
-          hash[key] << value
-        end
-      end
-    end
   end
 
   ##

data/lib/json/ld/writer.rb

@@ -90,12 +90,36 @@ module JSON::LD
           control: :url2,
           on: ["--context CONTEXT"],
           description: "Context to use when compacting.") {|arg| RDF::URI(arg)},
+        RDF::CLI::Option.new(
+          symbol: :embed,
+          datatype: %w(@always @last @never),
+          control: :select,
+          on: ["--embed EMBED"],
+          description: "How to embed matched objects (@last).") {|arg| RDF::URI(arg)},
+        RDF::CLI::Option.new(
+          symbol: :explicit,
+          datatype: TrueClass,
+          control: :checkbox,
+          on: ["--explicit"],
+          description: "Only include explicitly declared properties in output (false)") {|arg| RDF::URI(arg)},
+        RDF::CLI::Option.new(
+          symbol: :omitDefault,
+          datatype: TrueClass,
+          control: :checkbox,
+          on: ["--omitDefault"],
+          description: "Omit missing properties from output (false)") {|arg| RDF::URI(arg)},
         RDF::CLI::Option.new(
           symbol: :processing_mode,
           datatype: %w(json-ld-1.0 json-ld-1.1),
           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: :requireAll,
+          datatype: TrueClass,
+          control: :checkbox,
+          on: ["--requireAll"],
+          description: "Require all properties to match (true)") {|arg| RDF::URI(arg)},
         RDF::CLI::Option.new(
           symbol: :stream,
           datatype: TrueClass,
@@ -139,7 +163,7 @@ module JSON::LD
     # @yieldreturn [void]
     # @yield  [writer]
     # @yieldparam [RDF::Writer] writer
-    def initialize(output = $stdout, options = {}, &block)
+    def initialize(output = $stdout, **options, &block)
       options[:base_uri] ||= options[:base] if options.has_key?(:base)
       options[:base] ||= options[:base_uri] if options.has_key?(:base_uri)
       super do

data/spec/api_spec.rb

@@ -3,6 +3,7 @@ require_relative 'spec_helper'
 
 describe JSON::LD::API do
   let(:logger) {RDF::Spec.logger}
+  before {JSON::LD::Context::PRELOADED.clear}
 
   describe "#initialize" do
     context "with string input" do

data/spec/compact_spec.rb

@@ -292,7 +292,47 @@ describe JSON::LD::API do
             },
             "http://example.org/vocab#contains": "this-is-not-an-IRI"
           })
-        }
+        },
+        "Language map term with language value" => {
+          input: %([{"http://example/t": {"@value": "foo", "@language": "en"}}]),
+          context: %({"t": {"@id": "http://example/t", "@container": "@language"}}),
+          output: %({
+            "@context": {
+              "t": {"@id": "http://example/t", "@container": "@language"}
+            },
+            "t": {"en": "foo"}
+          })
+        },
+        "Datatyped term with datatyped value" => {
+          input: %([{"http://example/t": {"@value": "foo", "@type": "http:/example/type"}}]),
+          context: %({"t": {"@id": "http://example/t", "@type": "http:/example/type"}}),
+          output: %({
+            "@context": {
+              "t": {"@id": "http://example/t", "@type": "http:/example/type"}
+            },
+            "t": "foo"
+          })
+        },
+        "Datatyped term with simple value" => {
+          input: %([{"http://example/t": {"@value": "foo"}}]),
+          context: %({"t": {"@id": "http://example/t", "@type": "http:/example/type"}}),
+          output: %({
+            "@context": {
+              "t": {"@id": "http://example/t", "@type": "http:/example/type"}
+            },
+            "http://example/t": "foo"
+          })
+        },
+        "Datatyped term with object value" => {
+          input: %([{"http://example/t": {"@id": "http://example/id"}}]),
+          context: %({"t": {"@id": "http://example/t", "@type": "http:/example/type"}}),
+          output: %({
+            "@context": {
+              "t": {"@id": "http://example/t", "@type": "http:/example/type"}
+            },
+            "http://example/t": {"@id": "http://example/id"}
+          })
+        },
       }.each_pair do |title, params|
         it(title) {run_compact(params)}
       end
@@ -487,6 +527,72 @@ describe JSON::LD::API do
             "foo_de": ["de"]
           })
         },
+        "coerced @list containing an empty list" => {
+          input: %([{
+            "http://example.com/foo": [{"@list": [{"@list": []}]}]
+          }]),
+          context: %({
+            "foo": {"@id": "http://example.com/foo", "@container": "@list"}
+          }),
+          output: %({
+            "@context": {"foo": {"@id": "http://example.com/foo", "@container": "@list"}},
+            "foo": [[]]
+          }),
+        },
+        "coerced @list containing a list" => {
+          input: %([{
+            "http://example.com/foo": [{"@list": [{"@list": [{"@value": "baz"}]}]}]
+          }]),
+          context: %({
+            "foo": {"@id": "http://example.com/foo", "@container": "@list"}
+          }),
+          output: %({
+            "@context": {"foo": {"@id": "http://example.com/foo", "@container": "@list"}},
+            "foo": [["baz"]]
+          }),
+        },
+        "coerced @list containing an deep list" => {
+          input: %([{
+            "http://example.com/foo": [{"@list": [{"@list": [{"@list": [{"@value": "baz"}]}]}]}]
+          }]),
+          context: %({
+            "foo": {"@id": "http://example.com/foo", "@container": "@list"}
+          }),
+          output: %({
+            "@context": {"foo": {"@id": "http://example.com/foo", "@container": "@list"}},
+            "foo": [[["baz"]]]
+          }),
+        },
+        "coerced @list containing multiple lists" => {
+          input: %([{
+            "http://example.com/foo": [{"@list": [
+              {"@list": [{"@value": "a"}]},
+              {"@list": [{"@value": "b"}]}
+            ]}]
+          }]),
+          context: %({
+            "foo": {"@id": "http://example.com/foo", "@container": "@list"}
+          }),
+          output: %({
+            "@context": {"foo": {"@id": "http://example.com/foo", "@container": "@list"}},
+            "foo": [["a"], ["b"]]
+          }),
+        },
+        "coerced @list containing mixed list values" => {
+          input: %([{
+            "http://example.com/foo": [{"@list": [
+              {"@list": [{"@value": "a"}]},
+              {"@value": "b"}
+            ]}]
+          }]),
+          context: %({
+            "foo": {"@id": "http://example.com/foo", "@container": "@list"}
+          }),
+          output: %({
+            "@context": {"foo": {"@id": "http://example.com/foo", "@container": "@list"}},
+            "foo": [["a"], "b"]
+          }),
+        },
       }.each_pair do |title, params|
         it(title) {run_compact(params)}
       end
@@ -526,6 +632,96 @@ describe JSON::LD::API do
             }
           })
         },
+        "simple map with @none node definition" => {
+          input: %([{
+             "@id": "http://example.com/article",
+             "http://example.com/vocab/author": [{
+                "@id": "http://example.org/person/1",
+                "@index": "regular"
+             }, {
+                "@id": "http://example.org/guest/cd24f329aa"
+             }]
+          }]),
+          context: %({
+            "author": {"@id": "http://example.com/vocab/author", "@container": "@index" }
+          }),
+          output: %({
+            "@context": {
+              "author": {
+                "@id": "http://example.com/vocab/author",
+                "@container": "@index"
+              }
+            },
+            "@id": "http://example.com/article",
+            "author": {
+              "regular": {
+                "@id": "http://example.org/person/1"
+              },
+              "@none": {
+                "@id": "http://example.org/guest/cd24f329aa"
+              }
+            }
+          }),
+          processingMode: 'json-ld-1.1'
+        },
+        "simple map with @none value" => {
+          input: %([{
+             "@id": "http://example.com/article",
+             "http://example.com/vocab/author": [{
+                "@value": "Gregg",
+                "@index": "regular"
+             }, {
+                "@value": "Manu"
+             }]
+          }]),
+          context: %({
+            "author": {"@id": "http://example.com/vocab/author", "@container": "@index" }
+          }),
+          output: %({
+            "@context": {
+              "author": {
+                "@id": "http://example.com/vocab/author",
+                "@container": "@index"
+              }
+            },
+            "@id": "http://example.com/article",
+            "author": {
+              "regular": "Gregg",
+              "@none": "Manu"
+            }
+          }),
+          processingMode: 'json-ld-1.1'
+        },
+        "simple map with @none value using alias of @none" => {
+          input: %([{
+             "@id": "http://example.com/article",
+             "http://example.com/vocab/author": [{
+                "@value": "Gregg",
+                "@index": "regular"
+             }, {
+                "@value": "Manu"
+             }]
+          }]),
+          context: %({
+            "author": {"@id": "http://example.com/vocab/author", "@container": "@index" },
+            "none": "@none"
+          }),
+          output: %({
+            "@context": {
+              "author": {
+                "@id": "http://example.com/vocab/author",
+                "@container": "@index"
+              },
+              "none": "@none"
+            },
+            "@id": "http://example.com/article",
+            "author": {
+              "regular": "Gregg",
+              "none": "Manu"
+            }
+          }),
+          processingMode: 'json-ld-1.1'
+        },
       }.each_pair do |title, params|
         it(title) {run_compact(params)}
       end
@@ -560,6 +756,66 @@ describe JSON::LD::API do
             }
           })
         },
+        "with no @language" => {
+          input: %([
+            {
+              "@id": "http://example.com/queen",
+              "http://example.com/vocab/label": [
+                {"@value": "The Queen", "@language": "en"},
+                {"@value": "Die Königin", "@language": "de"},
+                {"@value": "Ihre Majestät"}
+              ]
+            }
+          ]),
+          context: %({
+            "vocab": "http://example.com/vocab/",
+            "label": {"@id": "vocab:label", "@container": "@language"}
+          }),
+          output: %({
+            "@context": {
+              "vocab": "http://example.com/vocab/",
+              "label": {"@id": "vocab:label", "@container": "@language"}
+            },
+            "@id": "http://example.com/queen",
+            "label": {
+              "en": "The Queen",
+              "de": "Die Königin",
+              "@none": "Ihre Majestät"
+            }
+          }),
+          processingMode: "json-ld-1.1"
+        },
+        "with no @language using alias of @none" => {
+          input: %([
+            {
+              "@id": "http://example.com/queen",
+              "http://example.com/vocab/label": [
+                {"@value": "The Queen", "@language": "en"},
+                {"@value": "Die Königin", "@language": "de"},
+                {"@value": "Ihre Majestät"}
+              ]
+            }
+          ]),
+          context: %({
+            "vocab": "http://example.com/vocab/",
+            "label": {"@id": "vocab:label", "@container": "@language"},
+            "none": "@none"
+          }),
+          output: %({
+            "@context": {
+              "vocab": "http://example.com/vocab/",
+              "label": {"@id": "vocab:label", "@container": "@language"},
+              "none": "@none"
+            },
+            "@id": "http://example.com/queen",
+            "label": {
+              "en": "The Queen",
+              "de": "Die Königin",
+              "none": "Ihre Majestät"
+            }
+          }),
+          processingMode: "json-ld-1.1"
+        },
       }.each_pair do |title, params|
         it(title) {run_compact(params)}
       end
@@ -633,6 +889,52 @@ describe JSON::LD::API do
             }
           })
         },
+        "Indexes using @none" => {
+          input: %([{
+            "http://example/idmap": [
+              {"http://example/label": [{"@value": "Object with no @id"}]}
+            ]
+          }]),
+          context: %({
+            "@vocab": "http://example/",
+            "ex": "http://example.org/",
+            "idmap": {"@container": "@id"}
+          }),
+          output: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "ex": "http://example.org/",
+              "idmap": {"@container": "@id"}
+            },
+            "idmap": {
+              "@none": {"label": "Object with no @id"}
+            }
+          })
+        },
+        "Indexes using @none with alias" => {
+          input: %([{
+            "http://example/idmap": [
+              {"http://example/label": [{"@value": "Object with no @id"}]}
+            ]
+          }]),
+          context: %({
+            "@vocab": "http://example/",
+            "ex": "http://example.org/",
+            "idmap": {"@container": "@id"},
+            "none": "@none"
+          }),
+          output: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "ex": "http://example.org/",
+              "idmap": {"@container": "@id"},
+              "none": "@none"
+            },
+            "idmap": {
+              "none": {"label": "Object with no @id"}
+            }
+          })
+        },
       }.each_pair do |title, params|
         it(title) {run_compact({processingMode: "json-ld-1.1"}.merge(params))}
       end
@@ -738,6 +1040,52 @@ describe JSON::LD::API do
             }
           })
         },
+        "Indexes using @none" => {
+          input: %([{
+            "http://example/typemap": [
+              {"http://example/label": [{"@value": "Object with no @type"}]}
+            ]
+          }]),
+          context: %({
+            "@vocab": "http://example/",
+            "ex": "http://example.org/",
+            "typemap": {"@container": "@type"}
+          }),
+          output: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "ex": "http://example.org/",
+              "typemap": {"@container": "@type"}
+            },
+            "typemap": {
+              "@none": {"label": "Object with no @type"}
+            }
+          })
+        },
+        "Indexes using @none with alias" => {
+          input: %([{
+            "http://example/typemap": [
+              {"http://example/label": [{"@value": "Object with no @id"}]}
+            ]
+          }]),
+          context: %({
+            "@vocab": "http://example/",
+            "ex": "http://example.org/",
+            "typemap": {"@container": "@type"},
+            "none": "@none"
+          }),
+          output: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "ex": "http://example.org/",
+              "typemap": {"@container": "@type"},
+              "none": "@none"
+            },
+            "typemap": {
+              "none": {"label": "Object with no @id"}
+            }
+          })
+        },
       }.each_pair do |title, params|
         it(title) {run_compact({processingMode: "json-ld-1.1"}.merge(params))}
       end
@@ -832,10 +1180,57 @@ describe JSON::LD::API do
             },
             "input": {
               "@id": "http://example.org/id",
-              "@graph": [{"value": "x"}]
+              "@graph": {"value": "x"}
             }
           })
         },
+        "Odd framing test" => {
+          input: %([
+            {
+              "http://example.org/claim": [
+                {
+                  "@graph": [
+                    {
+                      "@id": "http://example.org/1",
+                      "https://example.com#test": [
+                        {
+                          "@value": "foo"
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+          ),
+          context: %( {
+            "@version": 1.1,
+            "@vocab": "https://example.com#",
+            "ex": "http://example.org/",
+            "claim": {
+              "@id": "ex:claim",
+              "@container": "@graph"
+            },
+            "id": "@id"
+          }),
+          output: %({
+            "@context": {
+              "@version": 1.1,
+              "@vocab": "https://example.com#",
+              "ex": "http://example.org/",
+              "claim": {
+                "@id": "ex:claim",
+                "@container": "@graph"
+              },
+              "id": "@id"
+            },
+            "claim": {
+              "id": "ex:1",
+              "test": "foo"
+            }
+          })
+        }
       }.each_pair do |title, params|
         it(title) {run_compact({processingMode: "json-ld-1.1"}.merge(params))}
       end
@@ -888,6 +1283,28 @@ describe JSON::LD::API do
               }
             })
           },
+          "Compacts simple graph with no @index" => {
+            input: %([{
+              "http://example.org/input": [{
+                "@graph": [{
+                  "http://example.org/value": [{"@value": "x"}]
+                }]
+              }]
+            }]),
+            context: %({
+              "@vocab": "http://example.org/",
+              "input": {"@container": ["@graph", "@index", "@set"]}
+            }),
+            output: %({
+              "@context": {
+                "@vocab": "http://example.org/",
+                "input": {"@container": ["@graph", "@index", "@set"]}
+              },
+              "input": {
+                "@none": [{"value": "x"}]
+              }
+            })
+          },
           "Does not compact graph with @id" => {
             input: %([{
               "http://example.org/input": [{
@@ -910,7 +1327,7 @@ describe JSON::LD::API do
               "input": {
                 "@id": "http://example.org/id",
                 "@index": "g1",
-                "@graph": [{"value": "x"}]
+                "@graph": {"value": "x"}
               }
             })
           },
@@ -939,7 +1356,7 @@ describe JSON::LD::API do
                 "input": {"@container": ["@graph", "@id"]}
               },
               "input": {
-                "_:b0": {"value": "x"}
+                "@none": {"value": "x"}
               }
             })
           },
@@ -960,7 +1377,7 @@ describe JSON::LD::API do
                 "@vocab": "http://example.org/",
                 "input": {"@container": ["@graph", "@id", "@set"]}
               },
-              "input": {"_:b0": [{"value": "x"}]}
+              "input": {"@none": [{"value": "x"}]}
             })
           },
           "Compacts simple graph with @index" => {
@@ -982,7 +1399,7 @@ describe JSON::LD::API do
                 "input": {"@container": ["@graph", "@id"]}
               },
               "input": {
-                "_:b0": {"value": "x"}
+                "@none": {"value": "x"}
               }
             })
           },
@@ -1032,6 +1449,52 @@ describe JSON::LD::API do
               }
             })
           },
+          "Compacts graph without @id" => {
+            input: %([{
+              "http://example.org/input": [{
+                "@graph": [{
+                  "http://example.org/value": [{"@value": "x"}]
+                }]
+              }]
+            }]),
+            context: %({
+              "@vocab": "http://example.org/",
+              "input": {"@container": ["@graph", "@id"]}
+            }),
+            output: %({
+              "@context": {
+                "@vocab": "http://example.org/",
+                "input": {"@container": ["@graph", "@id"]}
+              },
+              "input": {
+                "@none" : {"value": "x"}
+              }
+            })
+          },
+          "Compacts graph without @id using alias of @none" => {
+            input: %([{
+              "http://example.org/input": [{
+                "@graph": [{
+                  "http://example.org/value": [{"@value": "x"}]
+                }]
+              }]
+            }]),
+            context: %({
+              "@vocab": "http://example.org/",
+              "input": {"@container": ["@graph", "@id"]},
+              "none": "@none"
+            }),
+            output: %({
+              "@context": {
+                "@vocab": "http://example.org/",
+                "input": {"@container": ["@graph", "@id"]},
+                 "none": "@none"
+              },
+              "input": {
+                "none" : {"value": "x"}
+              }
+            })
+          },
         }.each_pair do |title, params|
           it(title) {run_compact({processingMode: "json-ld-1.1"}.merge(params))}
         end
@@ -1040,7 +1503,7 @@ describe JSON::LD::API do
 
     context "@nest" do
       {
-        "Indexes to @nest for property with @container: @nest" => {
+        "Indexes to @nest for property with @nest" => {
           input: %([{
             "http://example.org/p1": [{"@value": "v1"}],
             "http://example.org/p2": [{"@value": "v2"}]
@@ -1060,7 +1523,7 @@ describe JSON::LD::API do
             }
           })
         },
-        "Indexes to @nest for all properties with @container: @nest" => {
+        "Indexes to @nest for all properties with @nest" => {
           input: %([{
             "http://example.org/p1": [{"@value": "v1"}],
             "http://example.org/p2": [{"@value": "v2"}]
@@ -1566,6 +2029,28 @@ describe JSON::LD::API do
             "c": "C in example"
           }),
         },
+        "orders lexicographically" => {
+          input: %([{
+            "@type": ["http://example/t2", "http://example/t1"],
+            "http://example.org/foo": [
+              {"@id": "urn:bar"}
+            ]
+          }]),
+          context: %({
+            "@vocab": "http://example/",
+            "t1": {"@context": {"foo": {"@id": "http://example.com/foo"}}},
+            "t2": {"@context": {"foo": {"@id": "http://example.org/foo", "@type": "@id"}}}
+          }),
+          output: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "t1": {"@context": {"foo": {"@id": "http://example.com/foo"}}},
+              "t2": {"@context": {"foo": {"@id": "http://example.org/foo", "@type": "@id"}}}
+            },
+            "@type": ["t2", "t1"],
+            "foo": "urn:bar"
+          }),
+        },
         "with @container: @type" => {
           input: %([{
             "http://example/typemap": [
@@ -1605,41 +2090,53 @@ describe JSON::LD::API do
           validate: true,
           exception: JSON::LD::JsonLdError::InvalidTermDefinition
         },
-      }.each_pair do |title, params|
-        it(title) {run_compact({processingMode: "json-ld-1.1"}.merge(params))}
-      end
-    end
-
-    context "exceptions" do
-      {
-        "@list containing @list" => {
-          input: %({
-            "http://example.org/foo": {"@list": [{"@list": ["baz"]}]}
+        "applies context for all values" => {
+          input: %([
+            {
+              "@id": "http://example.org/id",
+              "@type": ["http://example/type"],
+              "http://example/a": [{
+                "@id": "http://example.org/Foo",
+                "@type": ["http://example/Foo"],
+                "http://example/bar": [{"@id": "http://example.org/baz"}]
+              }]
+            }
+          ]),
+          context: %({
+            "@vocab": "http://example/",
+            "id": "@id",
+            "type": "@type",
+            "Foo": {"@context": {"id": null, "type": null}}
           }),
-          context: {},
-          exception: JSON::LD::JsonLdError::ListOfLists
-        },
-        "@list containing @list (with coercion)" => {
-          input: %({
-            "@context": {"http://example.org/foo": {"@container": "@list"}},
-            "http://example.org/foo": [{"@list": ["baz"]}]
+          output: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "id": "@id",
+              "type": "@type",
+              "Foo": {"@context": {"id": null, "type": null}}
+            },
+            "id": "http://example.org/id",
+            "type": "http://example/type",
+            "a": {
+              "@id": "http://example.org/Foo",
+              "@type": "Foo",
+              "bar": {"@id": "http://example.org/baz"}
+            }
           }),
-          context: {},
-          exception: JSON::LD::JsonLdError::ListOfLists
         },
-      }.each do |title, params|
-        it(title) {run_compact(params)}
+      }.each_pair do |title, params|
+        it(title) {run_compact({processingMode: "json-ld-1.1"}.merge(params))}
       end
     end
 
     context "compact IRI selection" do
       {
-        "compacts using expanded term in 1.0" => {
+        "does not compact using expanded term in 1.0" => {
           input: %({"http://example.org/foo": "term"}),
           context: %({"ex": {"@id": "http://example.org/"}}),
           output: %({
             "@context": {"ex": {"@id": "http://example.org/"}},
-            "ex:foo": "term"
+            "http://example.org/foo": "term"
           }),
           processingMode: "json-ld-1.0"
         },
@@ -1716,6 +2213,14 @@ describe JSON::LD::API do
             "ex:bar": "term"
           })
         },
+        "compacts using base if @vocab: relative" => {
+          input: %({"http://example.org/foo/bar": "term"}),
+          context: %({"@base": "http://example.org/foo/", "@vocab": ""}),
+          output: %({
+            "@context": {"@base": "http://example.org/foo/", "@vocab": ""},
+            "bar": "term"
+          })
+        },
       }.each do |title, params|
         it(title) {run_compact(params)}
       end