For @id and @container maps, ensure that keys are expanded appropriately during expansion, and compacted appropriately during compaction. Add tests verifying this behavior

Author: gkellogg

lib/json/ld/compact.rb

@@ -175,6 +175,7 @@ def compact(element, property: nil)
               when '@id'
                 id_prop = context.compact_iri('@id', vocab: true, quiet: true)
                 map_key = compacted_item[id_prop]
+                map_key = context.compact_iri(map_key, quiet: true)
                 compacted_item.delete(id_prop)
                 compacted_item
               when '@index'
@@ -186,6 +187,7 @@ def compact(element, property: nil)
               when '@type'
                 type_prop = context.compact_iri('@type', vocab: true, quiet: true)
                 map_key, *types = Array(compacted_item[type_prop])
+                map_key = context.compact_iri(map_key, vocab: true, quiet: true)
                 case types.length
                 when 0 then compacted_item.delete(type_prop)
                 when 1 then compacted_item[type_prop] = types.first

lib/json/ld/expand.rb

@@ -137,7 +137,7 @@ def expand_object(input, active_property, context, output_object, ordered: false
       keys.each do |key|
         # For each key and value in element, ordered lexicographically by key:
         value = input[key]
-        expanded_property = context.expand_iri(key, vocab: true, log_depth: @options[:log_depth])
+        expanded_property = context.expand_iri(key, vocab: true, quiet: true)
 
         # If expanded property is null or it neither contains a colon (:) nor it is a keyword, drop key by continuing to the next key.
         next if expanded_property.is_a?(RDF::URI) && expanded_property.relative?
@@ -164,16 +164,16 @@ def expand_object(input, active_property, context, output_object, ordered: false
             # If expanded property is @id and value is not a string, an invalid @id value error has been detected and processing is aborted
             e_id = case value
             when String
-              context.expand_iri(value, documentRelative: true, log_depth: @options[:log_depth]).to_s
+              context.expand_iri(value, documentRelative: true, quiet: true).to_s
             when Array
               # Framing allows an array of IRIs, and always puts values in an array
               raise JsonLdError::InvalidIdValue,
                     "value of @id must be a string, array of string or hash if framing: #{value.inspect}" unless framing
-              context.expand_iri(value, documentRelative: true, log_depth: @options[:log_depth]).to_s
+              context.expand_iri(value, documentRelative: true, quiet: true).to_s
               value.map do |v|
                 raise JsonLdError::InvalidTypeValue,
                       "@id value must be a string or array of strings for framing: #{v.inspect}" unless v.is_a?(String)
-                context.expand_iri(v, documentRelative: true, quiet: true, log_depth: @options[:log_depth]).to_s
+                context.expand_iri(v, documentRelative: true, quiet: true,).to_s
               end
             when Hash
               raise JsonLdError::InvalidIdValue,
@@ -201,10 +201,10 @@ def expand_object(input, active_property, context, output_object, ordered: false
               value.map do |v|
                 raise JsonLdError::InvalidTypeValue,
                       "@type value must be a string or array of strings: #{v.inspect}" unless v.is_a?(String)
-                context.expand_iri(v, vocab: true, documentRelative: true, quiet: true, log_depth: @options[:log_depth]).to_s
+                context.expand_iri(v, vocab: true, documentRelative: true, quiet: true).to_s
               end
             when String
-              context.expand_iri(value, vocab: true, documentRelative: true, quiet: true, log_depth: @options[:log_depth]).to_s
+              context.expand_iri(value, vocab: true, documentRelative: true, quiet: true).to_s
             when Hash
               # For framing
               raise JsonLdError::InvalidTypeValue,
@@ -379,11 +379,18 @@ def expand_object(input, active_property, context, output_object, ordered: false
           keys.each do |k|
             # Initialize index value to the result of using this algorithm recursively, passing active context, key as active property, and index value as element.
             index_value = expand([value[k]].flatten, key, active_context, ordered: ordered)
+            #require 'byebug'; byebug
             index_value.each do |item|
               case container
-              when '@id', '@index' then item[container] ||= k
-                # If container is @type add the key-value pair (@type-[index]) to item, appending any existing values in item
-              when '@type'  then item[container] = [k].concat(Array(item[container]))
+              when '@index' then item[container] ||= k
+              when '@id'
+                # Expand k document relative
+                expanded_k = active_context.expand_iri(k, documentRelative: true, quiet: true).to_s
+                item[container] ||= expanded_k
+              when '@type'
+                # Expand k vocabulary relative
+                expanded_k = active_context.expand_iri(k, vocab: true, documentRelative: true, quiet: true).to_s
+                item[container] = [expanded_k].concat(Array(item[container]))
               end
 
               # Append item to expanded value.

spec/compact_spec.rb

@@ -549,6 +549,28 @@
             }
           }),
         },
+        "Indexes to object using compact IRI @id" => {
+          input: %([{
+            "http://example/idmap": [
+              {"http://example/label": [{"@value": "Object with @id <foo>"}], "@id": "http://example.org/foo"}
+            ]
+          }]),
+          context: %({
+            "@vocab": "http://example/",
+            "ex": "http://example.org/",
+            "idmap": {"@container": "@id"}
+          }),
+          output: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "ex": "http://example.org/",
+              "idmap": {"@container": "@id"}
+            },
+            "idmap": {
+              "ex:foo": {"label": "Object with @id <foo>"}
+            }
+          })
+        },
       }.each_pair do |title, params|
         it(title) {run_compact(params)}
       end
@@ -634,6 +656,26 @@
             }
           })
         },
+        "Indexes using compacted @type" => {
+          input: %([{
+            "http://example/typemap": [
+              {"http://example/label": [{"@value": "Object with @type <foo>"}], "@type": ["http://example/Foo"]}
+            ]
+          }]),
+          context: %({
+            "@vocab": "http://example/",
+            "typemap": {"@container": "@type"}
+          }),
+          output: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "typemap": {"@container": "@type"}
+            },
+            "typemap": {
+              "Foo": {"label": "Object with @type <foo>"}
+            }
+          })
+        },
       }.each_pair do |title, params|
         it(title) {run_compact(params)}
       end

spec/expand_spec.rb

@@ -736,6 +736,23 @@
             ]
           }])
         },
+        "Adds expanded @id to object" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "idmap": {"@container": "@id"}
+            },
+            "idmap": {
+              "foo": {"label": "Object with @id <foo>"}
+            }
+          }),
+          output: %([{
+            "http://example/idmap": [
+              {"http://example/label": [{"@value": "Object with @id <foo>"}], "@id": "http://example.org/foo"}
+            ]
+          }]),
+          base: "http://example.org/"
+        },
       }.each do |title, params|
         it(title) {run_expand params}
       end
@@ -785,6 +802,39 @@
             ]
           }])
         },
+        "Adds vocabulary expanded @type to object" => {
+          input: %({
+            "@context": {
+              "@vocab": "http://example/",
+              "typemap": {"@container": "@type"}
+            },
+            "typemap": {
+              "Foo": {"label": "Object with @type <foo>"}
+            }
+          }),
+          output: %([{
+            "http://example/typemap": [
+              {"http://example/label": [{"@value": "Object with @type <foo>"}], "@type": ["http://example/Foo"]}
+            ]
+          }])
+        },
+        "Adds document expanded @type to object" => {
+          input: %({
+            "@context": {
+              "typemap": {"@id": "http://example/typemap", "@container": "@type"},
+              "label": "http://example/label"
+            },
+            "typemap": {
+              "Foo": {"label": "Object with @type <foo>"}
+            }
+          }),
+          output: %([{
+            "http://example/typemap": [
+              {"http://example/label": [{"@value": "Object with @type <foo>"}], "@type": ["http://example.org/Foo"]}
+            ]
+          }]),
+          base: "http://example.org/"
+        },
       }.each do |title, params|
         it(title) {run_expand params}
       end