Add createAnnotations option to flatten, and use in fromRdf.

Author: gkellogg

lib/json/ld/api.rb

@@ -253,6 +253,8 @@ def self.compact(input, context, expanded: false, **options)
     # @param [Boolean] expanded (false) Input is already expanded
     # @param  [Hash{Symbol => Object}] options
     # @option options (see #initialize)
+    # @option options [Boolean] :createAnnotations
+    #   Unfold embedded nodes which can be represented using `@annotation`.
     # @yield jsonld
     # @yieldparam [Hash] jsonld
     #   The flattened JSON-LD document
@@ -284,6 +286,13 @@ def self.flatten(input, context, expanded: false, **options)
         graph_maps = {'@default' => {}}
         create_node_map(value, graph_maps)
 
+        # If create annotations flag is set, then update each node map in graph maps with the result of calling the create annotations algorithm.
+        if options[:createAnnotations]
+          graph_maps.values.each do |node_map|
+            create_annotations(node_map)
+          end
+        end
+
         default_graph = graph_maps['@default']
         graph_maps.keys.opt_sort(ordered: @options[:ordered]).each do |graph_name|
           next if graph_name == '@default'

lib/json/ld/flatten.rb

@@ -191,6 +191,50 @@ def create_node_map(element, graph_map,
       end
     end
 
+    ##
+    # Create annotations
+    #
+    # Updates a node map from which annotations have been folded into embedded triples to re-extract the annotations.
+    #
+    # Map entries where the key is of the form of a canonicalized JSON object are used to find keys with the `@id` and property components. If found, the original map entry is removed and entries added to an `@annotation` property of the associated value.
+    #
+    # * Keys which are of the form of a canonicalized JSON object are examined in inverse order of length.
+    # * Deserialize the key into a map, and re-serialize the value of `@id`.
+    # * If the map contains an entry with that value (after re-canonicalizing, as appropriate), and the associated antry has a item which matches the non-`@id` item from the map, the node is used to create an `@annotation` entry within that value.
+    #
+    # @param [Hash{String => Hash}] input
+    # @return [Hash{String => Hash}]
+    def create_annotations(node_map)
+      node_map.keys.
+        select {|k| k.start_with?('{')}.
+        sort_by(&:length).
+        reverse.each do |key|
+
+        # Deserialize key, and re-serialize the `@id` value.
+        emb = JSON.parse(key)
+        id = emb.delete('@id')
+        property, value = emb.to_a.first
+
+        # If id is a map, set it to the result of canonicalizing that value, otherwise to itself.
+        id = id.to_json_c14n if id.is_a?(Hash)
+
+        next unless node_map.key?(id)
+        # If node map has an entry for id and that entry contains the same property and value from entry:
+        node = node_map[id] 
+
+        next unless node.key?(property)
+
+        node[property].each do |emb_value|
+          next unless emb_value == value.first
+
+          annotation = node_map.delete(key)
+          annotation.delete('@id')
+          add_value(emb_value, '@annotation', annotation, property_is_array: true) unless
+            annotation.empty?
+        end
+      end
+    end
+
     ##
     # Rename blank nodes recursively within an embedded object
     #

lib/json/ld/format.rb

@@ -174,6 +174,13 @@ def self.cli_commands
               use: :required,
               on: ["--context CONTEXT"],
               description: "Context to use when compacting.") {|arg| RDF::URI(arg)},
+            RDF::CLI::Option.new(
+              symbol: :createAnnotations,
+              datatype: TrueClass,
+              default: false,
+              control: :checkbox,
+              on: ["--[no-]create-annotations"],
+              description: "Unfold embedded nodes which can be represented using `@annotation`."),
           ]
         },
         frame: {

lib/json/ld/from_rdf.rb

@@ -40,8 +40,10 @@ def from_statements(dataset, useRdfType: false, useNativeTypes: false)
 
         default_graph[name] ||= {'@id' => name} unless name == '@default'
 
-        subject = statement.subject.to_s
-        node = node_map[subject] ||= resource_representation(statement.subject,useNativeTypes)
+        subject = statement.subject.statement? ?
+          resource_representation(statement.subject, useNativeTypes)['@id'].to_json_c14n :
+          statement.subject.to_s
+        node = node_map[subject] ||= resource_representation(statement.subject, useNativeTypes)
 
         # If predicate is rdf:datatype, note subject in compound literal subjects map
         if @options[:rdfDirection] == 'compound-literal' && statement.predicate == RDF.to_uri + 'direction'
@@ -50,12 +52,14 @@ def from_statements(dataset, useRdfType: false, useNativeTypes: false)
 
         # If object is an IRI, blank node identifier, or statement, and node map does not have an object member, create one and initialize its value to a new JSON object consisting of a single member @id whose value is set to object.
         unless statement.object.literal?
-          node_map[statement.object.to_s] ||=
+          object = statement.object.statement? ?
+            resource_representation(statement.object, useNativeTypes)['@id'].to_json_c14n :
+            statement.object.to_s
+          node_map[object] ||=
             resource_representation(statement.object, useNativeTypes)
         end
 
         # If predicate equals rdf:type, and object is an IRI or blank node identifier, append object to the value of the @type member of node. If no such member exists, create one and initialize it to an array whose only item is object. Finally, continue to the next RDF triple.
-        # XXX JSON-LD* does not support embedded value of @type
         if statement.predicate == RDF.type && statement.object.resource? && !useRdfType
           merge_value(node, '@type', statement.object.to_s)
           next
@@ -112,8 +116,7 @@ def from_statements(dataset, useRdfType: false, useNativeTypes: false)
           end
         end
 
-        # Skip to next graph, unless this one has lists
-        next unless nil_var = graph_object[RDF.nil.to_s]
+        nil_var = graph_object.fetch(RDF.nil.to_s, {})
 
         # For each item usage in the usages member of nil, perform the following steps:
         nil_var.fetch(:usages, []).each do |usage|
@@ -141,6 +144,9 @@ def from_statements(dataset, useRdfType: false, useNativeTypes: false)
           head['@list'] = list.reverse
           list_nodes.each {|node_id| graph_object.delete(node_id)}
         end
+
+        # Create annotations on graph object
+        create_annotations(graph_object)
       end
 
       result = []

spec/spec_helper.rb

@@ -77,7 +77,6 @@ def remap_bnodes(actual, expected)
     bijection = bijection.inject({}) {|memo, (k, v)| memo.merge(k.to_s => v.to_s)}
 
     # Recursively replace blank nodes in actual with the bijection
-    #require 'byebug'; byebug
     replace_nodes(actual, bijection)
   else
     actual