json-ld 2.1.2 → 2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a24e95bd68b625c54093b4d41f19f264147cf28
-  data.tar.gz: db126bfc8830837da1cd36329451443ff610a624
+  metadata.gz: 2089bccb0e9e19a4f349908dd6456c908a653e9f
+  data.tar.gz: 97c3aef58769ce0c233d85e027fca1e0bb660fd6
 SHA512:
-  metadata.gz: 0ecf9190facd71bb800cdce96eb8069da3359afe1816ab381bc21735828f0ca8c19d066850ca30339c405b0408955438d53b29e290efde9fdbe1be72430ae43a
-  data.tar.gz: 3b6bf6517ba347b8b73679c213c2c625b0957990cf9c1a2ecc220a85b4ec0340c3299d79fa8c10453a194bf9a2a5195ac8cf5e001cd96324241d899d07e99fba
+  metadata.gz: 625898c1cbb1f6dbe8a2a4fce2067f6702a3205911099878d1fecaad97dd18c014ff0dcea995d90885e13fff67f04362a6b8efe1fdbad8ac7c5a62b09070c28d
+  data.tar.gz: 8501add1dca033f2b2c61966bf4425aeed1f1852b39b1b9dabeb2253510c56b87b70d8c480652dcc0ac4c28ef078218915554c2037c747ac939b06b65d6d4781

data/README.md

@@ -14,6 +14,8 @@ JSON::LD can now be used to create a _context_ from an RDFS/OWL definition, and
 
 If the [jsonlint][] gem is installed, it will be used when validating an input document.
 
+[Implementation Report](file.earl.html)
+
 Install with `gem install json-ld`
 
 ### MultiJson parser
@@ -45,9 +47,9 @@ This gem implements an optimized streaming writer used for generating JSON-LD fr
     JSON::LD::API.expand(input) =>
     
     [{
-        "http://xmlns.com/foaf/0.1/name": ["Manu Sporny"],
-        "http://xmlns.com/foaf/0.1/homepage": ["http://manu.sporny.org/"],
-        "http://xmlns.com/foaf/0.1/avatar": ["http://twitter.com/account/profile_image/manusporny"]
+        "http://xmlns.com/foaf/0.1/name": [{"@value"=>"Manu Sporny"}],
+        "http://xmlns.com/foaf/0.1/homepage": [{"@value"=>"http://manu.sporny.org/"}], 
+        "http://xmlns.com/foaf/0.1/avatar": [{"@value": "http://twitter.com/account/profile_image/manusporny"}]
     }]
 
 ### Compact a Document
@@ -261,6 +263,107 @@ A context may be serialized to Ruby to speed this process using `Context#to_rb`.
 
 As JSON-LD may come from many different sources, included as an embedded script tag within an HTML document, the RDF Reader will strip input before the leading `{` or `[` and after the trailing `}` or `]`.
 
+## Extensions from JSON-LD 1.0
+This implementation is being used as a test-bed for features planned for an upcoming JSON-LD 1.1 Community release.
+
+### Scoped Contexts
+A term definition can include `@context`, which is applied to values of that object. This is also used when compacting. Taken together, this allows framing to effectively include context definitions more deeply within the framed structure.
+
+    {
+      "@context": {
+        "ex": "http://example.com/",
+        "foo": {
+          "@id": "ex:foo",
+          "@type": "@vocab"
+          "@context": {
+            "Bar": "ex:Bar",
+            "Baz": "ex:Baz"
+          }
+        }
+      },
+      "foo": "Bar"
+    }
+
+### @id and @type maps
+The value of `@container` in a term definition can include `@id` or `@type`, in addition to `@set`, `@list`, `@language`, and `@index`. This allows value indexing based on either the `@id` or `@type` of associated objects.
+
+    {
+      "@context": {
+        "@vocab": "http://example/",
+        "idmap": {"@container": "@id"}
+      },
+      "idmap": {
+        "http://example.org/foo": {"label": "Object with @id <foo>"},
+        "_:bar": {"label": "Object with @id _:bar"}
+      }
+    }
+
+### Transparent Nesting
+Many JSON APIs separate properties from their entities using an intermediate object. For example, a set of possible labels may be grouped under a common property:
+
+    {
+      "@context": {
+        "skos": "http://www.w3.org/2004/02/skos/core#",
+        "labels": "@nest",
+        "main_label": {"@id": "skos:prefLabel"},
+        "other_label": {"@id": "skos:altLabel"},
+        "homepage": {"@id":"http://schema.org/description", "@type":"@id"}
+      },
+      "@id":"http://example.org/myresource",
+      "homepage": "http://example.org",
+      "labels": {
+         "main_label": "This is the main label for my resource",
+         "other_label": "This is the other label"
+      }
+    }
+ 
+ In this case, the `labels` property is semantically meaningless. Defining it as equivalent to `@nest` causes it to be ignored when expanding, making it equivalent to the following:
+
+    {
+      "@context": {
+        "skos": "http://www.w3.org/2004/02/skos/core#",
+        "labels": "@nest",
+        "main_label": {"@id": "skos:prefLabel"},
+        "other_label": {"@id": "skos:altLabel"},
+        "homepage": {"@id":"http://schema.org/description", "@type":"@id"}
+      },
+      "@id":"http://example.org/myresource",
+      "homepage": "http://example.org",
+      "main_label": "This is the main label for my resource",
+      "other_label": "This is the other label"
+    }
+ 
+ Similarly, properties may be marked with "@nest": "nest-term", to cause them to be nested. Note that the `@nest` keyword can also be aliased in the context.
+
+     {
+       "@context": {
+         "skos": "http://www.w3.org/2004/02/skos/core#",
+         "labels": "@nest",
+         "main_label": {"@id": "skos:prefLabel", "@nest": "labels"},
+         "other_label": {"@id": "skos:altLabel", "@nest": "labels"},
+         "homepage": {"@id":"http://schema.org/description", "@type":"@id"}
+       },
+       "@id":"http://example.org/myresource",
+       "homepage": "http://example.org",
+       "labels": {
+          "main_label": "This is the main label for my resource",
+          "other_label": "This is the other label"
+       }
+     }
+
+In this way, nesting survives round-tripping through expansion, and framed output can include nested properties.
+
+### Framing Updates
+The [JSON-LD Framing 1.1 Specification]() improves on previous un-released versions.
+
+* [More Specific Frame matching](https://github.com/json-ld/json-ld.org/issues/110) – Allows framing to extend to elements of value objects, and objects are matched through recursive frame matching. `{}` is used as a wildcard, and `[]` as matching nothing.
+* [Graph framing](https://github.com/json-ld/json-ld.org/issues/118) – previously, only the merged graph can be framed, this update allows arbitrary graphs to be framed.
+  * Use `@graph` in frame, matches the default graph, not the merged graph.
+  * Use `@graph` in property value, causes the apropriatly named graph to be used for filling in values.
+* [Reverse properties](https://github.com/json-ld/json-ld.org/issues/311) – `@reverse` (or a property defined with `@reverse`) can cause matching values to be included, allowing a matched object to include reverse references to any objects referencing it.
+* [@omitDefault behavior](https://github.com/json-ld/json-ld.org/issues/389) – In addition to `true` and `false`, `@omitDefault` can take `@last`, `@always`, `@never`, and `@link`.
+* [multiple `@id` matching](https://github.com/json-ld/json-ld.org/issues/424) – A frame can match based on one or more specific object `@id` values.
+
 ## Documentation
 Full documentation available on [RubyDoc](http://rubydoc.info/gems/json-ld/file/README.md)
 
@@ -286,7 +389,7 @@ Note, the API method signatures differed in versions before 1.0, in that they al
 
 ## Dependencies
 * [Ruby](http://ruby-lang.org/) (>= 2.2.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.0)
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.2)
 * [JSON](https://rubygems.org/gems/json) (>= 1.5)
 
 ## Installation

data/VERSION

@@ -1 +1 @@
-2.1.2
+2.1.3

data/lib/json/ld.rb

@@ -34,7 +34,7 @@ module JSON
     autoload :Resource,           'json/ld/resource'
     autoload :VERSION,            'json/ld/version'
     autoload :Writer,             'json/ld/writer'
-    
+
     # Initial context
     # @see http://json-ld.org/spec/latest/json-ld-api/#appendix-b
     INITIAL_CONTEXT = {
@@ -53,12 +53,14 @@ module JSON
       @graph
       @language
       @list
+      @nest
       @omitDefault
       @requireAll
       @reverse
       @set
       @type
       @value
+      @version
       @vocab
     ).freeze
 
@@ -87,7 +89,7 @@ module JSON
       array_nl:     "\n"
     )
 
-    class JsonLdError < Exception
+    class JsonLdError < StandardError
       def to_s
         "#{self.class.instance_variable_get :@code}: #{super}"
       end
@@ -95,46 +97,49 @@ module JSON
         self.class.instance_variable_get :@code
       end
 
-      class LoadingDocumentFailed < JsonLdError; @code = "loading document failed"; end
-      class ListOfLists < JsonLdError; @code = "list of lists"; end
-      class InvalidIndexValue < JsonLdError; @code = "invalid @index value"; end
+      class CollidingKeywords < JsonLdError; @code = "colliding keywords"; end
+      class CompactionToListOfLists < JsonLdError; @code = "compaction to list of lists"; end
       class ConflictingIndexes < JsonLdError; @code = "conflicting indexes"; end
-      class InvalidIdValue < JsonLdError; @code = "invalid @id value"; end
-      class InvalidLocalContext < JsonLdError; @code = "invalid local context"; end
-      class MultipleContextLinkHeaders < JsonLdError; @code = "multiple context link headers"; end
-      class LoadingRemoteContextFailed < JsonLdError; @code = "loading remote context failed"; end
-      class InvalidRemoteContext < JsonLdError; @code = "invalid remote context"; end
-      class RecursiveContextInclusion < JsonLdError; @code = "recursive context inclusion"; end
+      class CyclicIRIMapping < JsonLdError; @code = "cyclic IRI mapping"; end
       class InvalidBaseIRI < JsonLdError; @code = "invalid base IRI"; end
-      class InvalidVocabMapping < JsonLdError; @code = "invalid vocab mapping"; end
+      class InvalidContainerMapping < JsonLdError; @code = "invalid container mapping"; end
       class InvalidDefaultLanguage < JsonLdError; @code = "invalid default language"; end
-      class KeywordRedefinition < JsonLdError; @code = "keyword redefinition"; end
-      class InvalidTermDefinition < JsonLdError; @code = "invalid term definition"; end
-      class InvalidReverseProperty < JsonLdError; @code = "invalid reverse property"; end
+      class InvalidIdValue < JsonLdError; @code = "invalid @id value"; end
+      class InvalidIndexValue < JsonLdError; @code = "invalid @index value"; end
+      class InvalidVersionValue < JsonLdError; @code = "invalid @version value"; end
       class InvalidIRIMapping < JsonLdError; @code = "invalid IRI mapping"; end
-      class CyclicIRIMapping < JsonLdError; @code = "cyclic IRI mapping"; end
       class InvalidKeywordAlias < JsonLdError; @code = "invalid keyword alias"; end
-      class InvalidTypeMapping < JsonLdError; @code = "invalid type mapping"; end
       class InvalidLanguageMapping < JsonLdError; @code = "invalid language mapping"; end
-      class CollidingKeywords < JsonLdError; @code = "colliding keywords"; end
-      class InvalidContainerMapping < JsonLdError; @code = "invalid container mapping"; end
-      class InvalidTypeValue < JsonLdError; @code = "invalid type value"; end
-      class InvalidValueObject < JsonLdError; @code = "invalid value object"; end
-      class InvalidValueObjectValue < JsonLdError; @code = "invalid value object value"; end
+      class InvalidLanguageMapValue < JsonLdError; @code = "invalid language map value"; end
       class InvalidLanguageTaggedString < JsonLdError; @code = "invalid language-tagged string"; end
       class InvalidLanguageTaggedValue < JsonLdError; @code = "invalid language-tagged value"; end
-      class InvalidTypedValue < JsonLdError; @code = "invalid typed value"; end
-      class InvalidSetOrListObject < JsonLdError; @code = "invalid set or list object"; end
-      class InvalidLanguageMapValue < JsonLdError; @code = "invalid language map value"; end
-      class CompactionToListOfLists < JsonLdError; @code = "compaction to list of lists"; end
+      class InvalidLocalContext < JsonLdError; @code = "invalid local context"; end
+      class InvalidNestValue < JsonLdError; @code = "invalid @nest value"; end
+      class InvalidRemoteContext < JsonLdError; @code = "invalid remote context"; end
+      class InvalidReverseProperty < JsonLdError; @code = "invalid reverse property"; end
       class InvalidReversePropertyMap < JsonLdError; @code = "invalid reverse property map"; end
-      class InvalidReverseValue < JsonLdError; @code = "invalid @reverse value"; end
       class InvalidReversePropertyValue < JsonLdError; @code = "invalid reverse property value"; end
-    end
-    
-    class InvalidFrame < Exception
-      class MultipleEmbeds < InvalidFrame; end
-      class Syntax < InvalidFrame; end
+      class InvalidReverseValue < JsonLdError; @code = "invalid @reverse value"; end
+      class InvalidScopedContext < JsonLdError; @code = "invalid scoped context"; end
+      class InvalidSetOrListObject < JsonLdError; @code = "invalid set or list object"; end
+      class InvalidTermDefinition < JsonLdError; @code = "invalid term definition"; end
+      class InvalidTypedValue < JsonLdError; @code = "invalid typed value"; end
+      class InvalidTypeMapping < JsonLdError; @code = "invalid type mapping"; end
+      class InvalidTypeValue < JsonLdError; @code = "invalid type value"; end
+      class InvalidValueObject < JsonLdError; @code = "invalid value object"; end
+      class InvalidValueObjectValue < JsonLdError; @code = "invalid value object value"; end
+      class InvalidVocabMapping < JsonLdError; @code = "invalid vocab mapping"; end
+      class KeywordRedefinition < JsonLdError; @code = "keyword redefinition"; end
+      class ListOfLists < JsonLdError; @code = "list of lists"; end
+      class LoadingDocumentFailed < JsonLdError; @code = "loading document failed"; end
+      class LoadingRemoteContextFailed < JsonLdError; @code = "loading remote context failed"; end
+      class MultipleContextLinkHeaders < JsonLdError; @code = "multiple context link headers"; end
+      class ProcessingModeConflict < JsonLdError; @code = "processing mode conflict"; end
+      class RecursiveContextInclusion < JsonLdError; @code = "recursive context inclusion"; end
+      class InvalidFrame < JsonLdError
+        class MultipleEmbeds < InvalidFrame; end
+        class Syntax < InvalidFrame; end
+      end
     end
   end
-end
+end

data/lib/json/ld/api.rb

@@ -69,10 +69,12 @@ module JSON::LD
     #   A context that is used to initialize the active context when expanding a document.
     # @option options [Boolean, String, RDF::URI] :flatten
     #   If set to a value that is not `false`, the JSON-LD processor must modify the output of the Compaction Algorithm or the Expansion Algorithm by coalescing all properties associated with each subject via the Flattening Algorithm. The value of `flatten must` be either an _IRI_ value representing the name of the graph to flatten, or `true`. If the value is `true`, then the first graph encountered in the input document is selected and flattened.
-    # @option options [String] :processingMode ("json-ld-1.1")
+    # @option options [String] :processingMode
     #   Processing mode, json-ld-1.0 or json-ld-1.1. Also can have other values:
     #
     #   * json-ld-1.1-expand-frame – special frame expansion mode.
+    #
+    #   If `processingMode` is not specified, a mode of `json-ld-1.0` or `json-ld-1.1` is set, the context used for `expansion` or `compaction`.
     # @option options [Boolean] :rename_bnodes (true)
     #   Rename bnodes as part of expansion, or keep them the same.
     # @option options [Boolean]  :unique_bnodes   (false)
@@ -88,10 +90,8 @@ module JSON::LD
       @options = {
         compactArrays: true,
         rename_bnodes: true,
-        processingMode: "json-ld-1.1",
         documentLoader: self.class.method(:documentLoader)
       }
-      @options[:validate] = %w(json-ld-1.0 json-ld-1.1).include?(@options[:processingMode])
       @options = @options.merge(options)
       @namer = options[:unique_bnodes] ? BlankNodeUniqer.new : (@options[:rename_bnodes] ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
 
@@ -135,6 +135,10 @@ module JSON::LD
       context ||= (@value['@context'] if @value.is_a?(Hash)) || context_ref
       @context = Context.parse(context || {}, @options)
 
+      # If not set explicitly, the context figures out the processing mode
+      @options[:processingMode] ||= @context.processingMode
+      @options[:validate] ||= %w(json-ld-1.0 json-ld-1.1).include?(@options[:processingMode])
+
       if block_given?
         case block.arity
           when 0, -1 then instance_eval(&block)
@@ -207,7 +211,7 @@ module JSON::LD
       expanded_input = options[:expanded] ? input : API.expand(input, options)
 
       API.new(expanded_input, context, options) do
-        log_debug(".compact") {"expanded input: #{expanded.to_json(JSON_STATE) rescue 'malformed json'}"}
+        log_debug(".compact") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
         result = compact(value)
 
         # xxx) Add the given context to the output
@@ -298,6 +302,7 @@ module JSON::LD
     # @option options [Boolean] :omitDefault (false)
     #   a flag specifying that properties that are missing from the JSON-LD input should be omitted from the output.
     # @option options [Boolean] :expanded Input is already expanded
+    # @option options [Boolean] :pruneBlankNodeIdentifiers (true) removes blank node identifiers that are only used once.
     # @yield jsonld
     # @yieldparam [Hash] jsonld
     #   The framed JSON-LD document
@@ -309,13 +314,14 @@ module JSON::LD
     def self.frame(input, frame, options = {})
       result = nil
       options = {
-        base:           input.is_a?(String) ? input : '',
-        compactArrays:  true,
-        embed:          '@last',
-        explicit:       false,
-        requireAll:     true,
-        omitDefault:    false,
-        documentLoader: method(:documentLoader)
+        base:                       (input if input.is_a?(String)),
+        compactArrays:              true,
+        embed:                      '@last',
+        explicit:                   false,
+        requireAll:                 true,
+        omitDefault:                false,
+        pruneBlankNodeIdentifiers:  true,
+        documentLoader:             method(:documentLoader)
       }.merge!(options)
 
       framing_state = {
@@ -365,7 +371,12 @@ module JSON::LD
 
         result = []
         frame(framing_state, framing_state[:subjects].keys.sort, (expanded_frame.first || {}), options.merge(parent: result))
-        
+
+        # Count blank node identifiers used in the document, if pruning
+        bnodes_to_clear = if options[:pruneBlankNodeIdentifiers]
+          count_blank_node_identifiers(result).collect {|k, v| k if v == 1}.compact
+        end
+
         # Initalize context from frame
         @context = @context.parse(frame['@context'])
         # Compact result
@@ -376,7 +387,7 @@ module JSON::LD
         kwgraph = context.compact_iri('@graph', quiet: true)
         result = context.serialize.merge({kwgraph => compacted})
         log_debug(".frame") {"after compact: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
-        result = cleanup_preserve(result)
+        result = cleanup_preserve(result, bnodes_to_clear || [])
       end
 
       block_given? ? yield(result) : result
@@ -450,6 +461,7 @@ module JSON::LD
     # @option options (see #initialize)
     # @option options [Boolean] :useRdfType (false)
     #   If set to `true`, the JSON-LD processor will treat `rdf:type` like a normal property instead of using `@type`.
+    # @option options [Boolean] :useNativeTypes (false) use native representations
     # @yield jsonld
     # @yieldparam [Hash] jsonld
     #   The JSON-LD document in expanded form
@@ -458,10 +470,11 @@ module JSON::LD
     #   If a block is given, the result of evaluating the block is returned, otherwise, the expanded JSON-LD document
     def self.fromRdf(input, options = {}, &block)
       useRdfType = options.fetch(:useRdfType, false)
+      useNativeTypes = options.fetch(:useNativeTypes, false)
       result = nil
 
       API.new(nil, nil, options) do |api|
-        result = api.from_statements(input, useRdfType: useRdfType)
+        result = api.from_statements(input, useRdfType: useRdfType, useNativeTypes: useNativeTypes)
       end
 
       block_given? ? yield(result) : result

data/lib/json/ld/compact.rb

@@ -16,6 +16,12 @@ module JSON::LD
       #else
       #  log_debug("compact") {"property: #{property.inspect}"}
       #end
+
+      # If the term definition for active property itself contains a context, use that for compacting values.
+      input_context = self.context
+      td = self.context.term_definitions[property] if property
+      self.context = (td && td.context && self.context.parse(td.context)) || input_context
+
       case element
       when Array
         #log_debug("") {"Array #{element.inspect}"}
@@ -46,9 +52,9 @@ module JSON::LD
         end
 
         inside_reverse = property == '@reverse'
-        result = {}
+        result, nest_result = {}, nil
 
-        element.each_key do |expanded_property|
+        element.keys.sort.each do |expanded_property|
           expanded_value = element[expanded_property]
           #log_debug("") {"#{expanded_property}: #{expanded_value.inspect}"}
 
@@ -56,6 +62,15 @@ module JSON::LD
             compacted_value = [expanded_value].flatten.compact.map do |expanded_type|
               context.compact_iri(expanded_type, vocab: (expanded_property == '@type'), log_depth: @options[:log_depth])
             end
+
+            # If key is @type and any compacted value is a term having a local context, overlay that context.
+            if expanded_property == '@type'
+              compacted_value.each do |term|
+                term_context = self.context.term_definitions[term].context if context.term_definitions[term]
+                self.context = context.parse(term_context) if term_context
+              end
+            end
+
             compacted_value = compacted_value.first if compacted_value.length == 1
 
             al = context.compact_iri(expanded_property, vocab: true, quiet: true)
@@ -72,6 +87,7 @@ module JSON::LD
                 value = [value] if !value.is_a?(Array) &&
                   (context.container(prop) == '@set' || !@options[:compactArrays])
                 #log_debug("") {"merge #{prop} => #{value.inspect}"}
+
                 merge_compacted_value(result, prop, value)
                 compacted_value.delete(prop)
               end
@@ -106,8 +122,14 @@ module JSON::LD
                                   reverse: inside_reverse,
                                   log_depth: @options[:log_depth])
 
-            iap = result[item_active_property] ||= []
-            result[item_active_property] = [iap] unless iap.is_a?(Array)
+            if nest_prop = context.nest(item_active_property)
+              result[nest_prop] ||= {}
+              iap = result[result[nest_prop]] ||= []
+              result[nest_prop][item_active_property] = [iap] unless iap.is_a?(Array)
+            else
+              iap = result[item_active_property] ||= []
+              result[item_active_property] = [iap] unless iap.is_a?(Array)
+            end
           end
 
           # At this point, expanded value must be an array due to the Expansion algorithm.
@@ -119,6 +141,14 @@ module JSON::LD
                                   reverse: inside_reverse,
                                   log_depth: @options[:log_depth])
 
+
+            nest_result = if nest_prop = context.nest(item_active_property)
+              # FIXME??: It's possible that nest_prop will be used both for nesting, and for values of @nest
+              result[nest_prop] ||= {}
+            else
+              result
+            end
+
             container = context.container(item_active_property)
             value = list?(expanded_item) ? expanded_item['@list'] : expanded_item
             compacted_item = compact(value, property: item_active_property)
@@ -135,14 +165,36 @@ module JSON::LD
                 end
               else
                 raise JsonLdError::CompactionToListOfLists,
-                      "key cannot have more than one list value" if result.has_key?(item_active_property)
+                      "key cannot have more than one list value" if nest_result.has_key?(item_active_property)
               end
             end
 
-            if %w(@language @index).include?(container)
-              map_object = result[item_active_property] ||= {}
-              compacted_item = compacted_item['@value'] if container == '@language' && value?(compacted_item)
-              map_key = expanded_item[container]
+            if %w(@language @index @id @type).include?(container)
+              map_object = nest_result[item_active_property] ||= {}
+              compacted_item = case container
+              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'
+                map_key = expanded_item[container]
+                compacted_item
+              when '@language'
+                map_key = expanded_item[container]
+                value?(expanded_item) ? expanded_item['@value'] : compacted_item
+              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
+                else        compacted_item[type_prop] = types
+                end
+                compacted_item
+              end
               merge_compacted_value(map_object, map_key, compacted_item)
             else
               compacted_item = [compacted_item] if
@@ -151,7 +203,7 @@ module JSON::LD
                   %w(@set @list).include?(container) ||
                   %w(@list @graph).include?(expanded_property)
                 )
-              merge_compacted_value(result, item_active_property, compacted_item)
+              merge_compacted_value(nest_result, item_active_property, compacted_item)
             end
           end
         end
@@ -163,6 +215,9 @@ module JSON::LD
         #log_debug("compact") {element.class.to_s}
         element
       end
+
+    ensure
+      self.context = input_context
     end
   end
 end