Support expansion and compaction of simple named graphs (i.e., without an @id).

Author: gkellogg

lib/json/ld/compact.rb

@@ -82,6 +82,7 @@ def compact(element, property: nil)
           if expanded_property == '@reverse'
             compacted_value = compact(expanded_value, property: '@reverse')
             #log_debug("@reverse") {"compacted_value: #{compacted_value.inspect}"}
+            # handle double-reversed properties
             compacted_value.each do |prop, value|
               if context.reverse?(prop)
                 value = [value] if !value.is_a?(Array) &&
@@ -162,10 +163,17 @@ def compact(element, property: nil)
 
             container = context.container(item_active_property)
             as_array = context.as_array?(item_active_property)
-            value = list?(expanded_item) ? expanded_item['@list'] : expanded_item
+
+            value = case
+            when list?(expanded_item) then expanded_item['@list']
+            when simple_graph?(expanded_item) then expanded_item['@graph']
+            else expanded_item
+            end
+
             compacted_item = compact(value, property: item_active_property)
             #log_debug("") {" => compacted key: #{item_active_property.inspect} for #{compacted_item.inspect}"}
 
+            # handle @list
             if list?(expanded_item)
               compacted_item = [compacted_item] unless compacted_item.is_a?(Array)
               unless container == '@list'
@@ -178,6 +186,18 @@ def compact(element, property: nil)
               else
                 raise JsonLdError::CompactionToListOfLists,
                       "key cannot have more than one list value" if nest_result.has_key?(item_active_property)
+              # Falls through to add list value below
+              end
+            end
+
+            # handle simple @graph, not the value of a property with @content: @graph
+            if simple_graph?(expanded_item) && container != '@graph'
+              compacted_item = [compacted_item] unless compacted_item.is_a?(Array)
+              al = context.compact_iri('@graph', vocab: true, quiet: true)
+              compacted_item = {al => compacted_item}
+              if expanded_item.has_key?('@index')
+                key = context.compact_iri('@index', vocab: true, quiet: true)
+                compacted_item[key] = expanded_item['@index']
               end
             end
 

lib/json/ld/context.rb

@@ -41,10 +41,6 @@ class TermDefinition
       # @return ['@index', '@language', '@index', '@type', '@id'] Container mapping
       attr_reader :container_mapping
 
-      # If container mapping was defined along with @set
-      # @return [Boolean]
-      attr_reader :as_set
-
       # @return [String] Term used for nest properties
       attr_accessor :nest
 
@@ -78,7 +74,7 @@ def prefix?; @prefix; end
       # @param [String] term
       # @param [String] id
       # @param [String] type_mapping Type mapping
-      # @param ['@index', '@language', '@index', '@set', '@type', '@id'] container_mapping
+      # @param [Array<'@index', '@language', '@index', '@set', '@type', '@id', '@graph'>] container_mapping
       # @param [String] language_mapping
       #   Language mapping of term, `false` is used if there is explicitly no language mapping for this term
       # @param [Boolean] reverse_property
@@ -147,7 +143,7 @@ def to_context_definition(context)
             end
           end
 
-          cm = [container_mapping, ('@set' if as_set)].compact
+          cm = [container_mapping, ('@set' if as_set?)].compact
           cm = cm.first if cm.length == 1
           defn['@container'] = cm unless cm.empty?
           # Language set as false to be output as null
@@ -168,21 +164,25 @@ def to_rb
         %w(id type_mapping container_mapping language_mapping reverse_property nest simple prefix context).each do |acc|
           v = instance_variable_get("@#{acc}".to_sym)
           v = v.to_s if v.is_a?(RDF::Term)
-          if acc == 'container_mapping' && as_set
+          if acc == 'container_mapping' && as_set?
             v = v ? [v, '@set'] : '@set'
           end
           defn << "#{acc}: #{v.inspect}" if v
         end
         defn.join(', ') + ")"
       end
 
+      # If container mapping was defined along with @set
+      # @return [Boolean]
+      def as_set?; @as_set || false; end
+
       def inspect
         v = %w([TD)
         v << "id=#{@id}"
         v << "term=#{@term}"
         v << "rev" if reverse_property
         v << "container=#{container_mapping}" if container_mapping
-        v << "as_set=#{as_set.inspect}"
+        v << "as_set=#{as_set?.inspect}"
         v << "lang=#{language_mapping.inspect}" unless language_mapping.nil?
         v << "type=#{type_mapping}" unless type_mapping.nil?
         v << "nest=#{nest.inspect}" unless nest.nil?
@@ -876,21 +876,20 @@ def find_definition(term)
     # @param [Term, #to_s] term in unexpanded form
     # @return [String]
     def container(term)
-      return '@set' if term == '@graph'
       return term if KEYWORDS.include?(term)
       term = find_definition(term)
       term && term.container_mapping
     end
 
     ##
-    # Should values be represented as a set?
+    # Should values be represented using an array?
     #
     # @param [Term, #to_s] term in unexpanded form
     # @return [Boolean]
     def as_array?(term)
-      return true if term == '@graph' || term == '@list'
+      return true if CONTEXT_CONTAINER_ARRAY_TERMS.include?(term)
       term = find_definition(term)
-      term && (term.as_set || term.container_mapping == '@list')
+      term && (term.as_set? || term.container_mapping == '@list')
     end
 
     ##
@@ -1122,6 +1121,11 @@ def compact_iri(iri, value: nil, vocab: nil, reverse: false, quiet: false, **opt
             tl_value = common_language
           end
           #log_debug("") {"list: containers: #{containers.inspect}, type/language: #{tl.inspect}, type/language value: #{tl_value.inspect}"} unless quiet
+        elsif graph?(value)
+          # TODO: support `@graphId`?
+          # TODO: "@graph@set"?
+          containers << '@graph'
+          containers << '@set'
         else
           if value?(value)
             if value.has_key?('@language') && !index?(value)
@@ -1442,6 +1446,8 @@ def alias(value)
 
   private
 
+    CONTEXT_CONTAINER_ARRAY_TERMS = %w(@set @list @graph).freeze
+
     def uri(value)
       case value.to_s
       when /^_:(.*)$/
@@ -1482,7 +1488,26 @@ def bnode(value = nil)
     #
     # To make use of an inverse context, a list of preferred container mappings and the type mapping or language mapping are gathered for a particular value associated with an IRI. These parameters are then fed to the Term Selection algorithm, which will find the term that most appropriately matches the value's mappings.
     #
+    # @example Basic structure of resulting inverse context
+    #     {
+    #       "http://example.com/term": {
+    #         "@language": {
+    #           "@null": "term",
+    #           "@none": "term",
+    #           "en": "term"
+    #         },
+    #         "@type": {
+    #           "@reverse": "term",
+    #           "@none": "term",
+    #           "http://datatype": "term"
+    #         },
+    #         "@any": {
+    #           "@none": "term",
+    #         }
+    #       }
+    #     }
     # @return [Hash{String => Hash{String => String}}]
+    # @todo May want to include @set along with container to allow selecting terms using @set over those without @set. May require adding some notion of value cardinality to compact_iri
     def inverse_context
       @inverse_context ||= begin
         result = {}
@@ -1491,7 +1516,14 @@ def inverse_context
           a.length == b.length ? (a <=> b) : (a.length <=> b.length)
         end.each do |term|
           next unless td = term_definitions[term]
-          container = td.container_mapping || (td.as_set ? '@set' : '@none')
+
+          container = td.container_mapping || (td.as_set? ? '@set' : '@none')
+          # FIXME: Alternative to consider
+          ## Creates "@language", "@language@set", "@set", or "@none"
+          ## for each of "@language", "@index", "@type", "@id", "@list", and "@graph"
+          #container = td.container_mapping.to_s
+          #container += '@set' if td.as_set?
+          #container = '@none' if container.empty?
           container_map = result[td.id.to_s] ||= {}
           tl_map = container_map[container] ||= {'@language' => {}, '@type' => {}, '@any' => {}}
           type_map = tl_map['@type']
@@ -1630,7 +1662,7 @@ def check_container(container, local_context, defined, term)
         # Okay
       when '@language', '@index', nil
         # Okay
-      when '@type', '@id', nil
+      when '@type', '@id', '@graph', nil
         raise JsonLdError::InvalidContainerMapping,
               "unknown mapping for '@container' to #{container.inspect} on term #{term.inspect}" if
                (processingMode || 'json-ld-1.0') < 'json-ld-1.1'

lib/json/ld/expand.rb

@@ -424,10 +424,19 @@ def expand_object(input, active_property, context, output_object, ordered: false
         # If the container mapping associated to key in active context is @list and expanded value is not already a list object, convert expanded value to a list object by first setting it to an array containing only expanded value if it is not already an array, and then by setting it to a JSON object containing the key-value pair @list-expanded value.
         if active_context.container(key) == '@list' && !list?(expanded_value)
           #log_debug(" => ") { "convert #{expanded_value.inspect} to list"}
-          expanded_value = {'@list' => [expanded_value].flatten}
+          expanded_value = [expanded_value] unless expanded_value.is_a?(Array)
+          expanded_value = {'@list' => expanded_value}
         end
         #log_debug {" => #{expanded_value.inspect}"}
 
+        # convert expanded value to @graph if container specifies it
+        # FIXME value may be a named graph, as well as a simple graph.
+        if active_context.container(key) == '@graph' && !graph?(expanded_value)
+          #log_debug(" => ") { "convert #{expanded_value.inspect} to list"}
+          expanded_value = [expanded_value] unless expanded_value.is_a?(Array)
+          expanded_value = {'@graph' => expanded_value}
+        end
+
         # Otherwise, if the term definition associated to key indicates that it is a reverse property
         # Spec FIXME: this is not an otherwise.
         if (td = context.term_definitions[key]) && td.reverse_property

lib/json/ld/utils.rb

@@ -46,6 +46,27 @@ def blank_node?(value)
       end
     end
 
+    ##
+    # Is value an expaned @graph?
+    #
+    # Note: A value is a simple graph if all of these hold true:
+    # 1. It is an object.
+    # 2. It has an `@graph` key.
+    # 3. It may have '@id' or '@index'
+    #
+    # @param [Object] value
+    # @return [Boolean]
+    def graph?(value)
+      value.is_a?(Hash) && (value.keys - UTIL_GRAPH_KEYS) == ['@graph']
+    end
+    ##
+    # Is value a simple @graph (lacking @id)?
+    # @param [Object] value
+    # @return [Boolean]
+    def simple_graph?(value)
+      graph?(value) && !value.has_key?('@id')
+    end
+    
     ##
     # Is value an expaned @list?
     #
@@ -184,6 +205,7 @@ def has_value(subject, property, value)
     end
 
     private
+    UTIL_GRAPH_KEYS = %w(@id @index).freeze
 
     # Merge the last value into an array based for the specified key if hash is not null and value is not already in that array
     def merge_value(hash, key, value)

spec/compact_spec.rb

@@ -744,6 +744,110 @@
       end
     end
 
+    context "@container: @graph" do
+      {
+        "Compacts simple graph" => {
+          input: %([{
+            "http://example.org/input": [{
+              "@graph": [{
+                "http://example.org/value": [{"@value": "x"}]
+              }]
+            }]
+          }]),
+          context: %({
+            "@vocab": "http://example.org/",
+            "input": {"@container": "@graph"}
+          }),
+          output: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "input": {"@container": "@graph"}
+            },
+            "input": {
+              "value": "x"
+            }
+          })
+        },
+        "Compacts simple graph with @set" => {
+          input: %([{
+            "http://example.org/input": [{
+              "@graph": [{
+                "http://example.org/value": [{"@value": "x"}]
+              }]
+            }]
+          }]),
+          context: %({
+            "@vocab": "http://example.org/",
+            "input": {"@container": ["@graph", "@set"]}
+          }),
+          output: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "input": {"@container": ["@graph", "@set"]}
+            },
+            "input": [{
+              "value": "x"
+            }]
+          })
+        },
+        "Compacts simple graph with @index" => {
+          input: %([{
+            "http://example.org/input": [{
+              "@graph": [{
+                "http://example.org/value": [{"@value": "x"}]
+              }],
+              "@index": "ndx"
+            }]
+          }]),
+          context: %({
+            "@vocab": "http://example.org/",
+            "input": {"@container": "@graph"}
+          }),
+          output: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "input": {"@container": "@graph"}
+            },
+            "input": {
+              "value": "x"
+            }
+          })
+        },
+        "Does not compacts graph with @id" => {
+          input: %([{
+            "http://example.org/input": [{
+              "@graph": [{
+                "http://example.org/value": [{"@value": "x"}]
+              }],
+              "@id": "http://example.org/id"
+            }]
+          }]),
+          context: %({
+            "@vocab": "http://example.org/",
+            "input": {"@container": "@graph"}
+          }),
+          output: %({
+            "@context": {
+              "@vocab": "http://example.org/",
+              "input": {
+                "@container": "@graph"
+              }
+            },
+            "input": {
+              "@id": "http://example.org/id",
+              "@graph": [
+                {
+                  "value": "x"
+                }
+              ]
+            }
+          })
+        },
+      }.each_pair do |title, params|
+        it(title) {run_compact({processingMode: "json-ld-1.1"}.merge(params))}
+      end
+    end
+
     context "@nest" do
       {
         "Indexes to @nest for property with @container: @nest" => {