Partial updates for new RDF 1.2 model using triple terms, and reifiers.

Author: gkellogg

lib/json/ld.rb

@@ -73,7 +73,7 @@ module LD
                          @propagate
                          @protected
                          @preserve
-                         @reifier
+                         @reifies
                          @requireAll
                          @reverse
                          @set
@@ -163,6 +163,7 @@ class InvalidSetOrListObject < JsonLdError; @code = 'invalid set or list object'
       class InvalidStreamingKeyOrder < JsonLdError; @code = 'invalid streaming key order' end
       class InvalidTermDefinition < JsonLdError; @code = 'invalid term definition'; end
       class InvalidTripleTerm < JsonLdError; @code = 'invalid triple term'; end
+      class InvalidReification < JsonLdError; @code = 'invalid reification'; 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

lib/json/ld/expand.rb

@@ -299,7 +299,7 @@ def expand_object(input, active_property, context, output_object,
             end
 
             expanded_value = case expanded_property
-            when '@annotation', '@reifies'
+            when '@annotation'
               # Skip unless rdfstar option is set
               next unless @options[:rdfstar]
 
@@ -477,6 +477,16 @@ def expand_object(input, active_property, context, output_object,
               # Skip unless rdfstar option is set
               next unless @options[:rdfstar]
 
+              # Result may have multiple reifications.
+              rei_nodes = as_array(expand(value, nil, context, log_depth: log_depth.to_i + 1))
+              rei_nodes.each do |rei_node|
+                statements = to_enum(:item_to_rdf, rei_node)
+                unless statements.count >= 1
+                  raise JsonLdError::InvalidReification,
+                    "Reification with #{statements.size.to_i} statements"
+                end
+              end
+
               as_array(expand(value, '@reifies', context,
                 framing: framing,
                 log_depth: log_depth.to_i + 1))

lib/json/ld/flatten.rb

@@ -46,7 +46,7 @@ def create_node_map(element, graph_map,
           raise "Expected hash or array to create_node_map, got #{element.inspect}"
         else
           graph = (graph_map[active_graph] ||= {})
-          subject_node = !reverse && graph[active_subject.is_a?(Hash) ? active_subject.to_json_c14n : active_subject]
+          subject_node = graph[active_subject]
 
           # Transform BNode types
           if element.key?('@type')
@@ -57,27 +57,26 @@ def create_node_map(element, graph_map,
             element['@type'] = element['@type'].first if element['@type']
 
             # For rdfstar, if value contains an `@annotation` member ...
-            # note: active_subject will not be nil, and may be an object itself.
-            if element.key?('@annotation')
+            # note: active_subject will not be nil.
+            if annotation = element.delete('@annotation')
               # rdfstar being true is implicit, as it is checked in expansion
               as = if node_reference?(active_subject)
                 active_subject['@id']
               else
                 active_subject
               end
-              star_subject = {
-                "@id" => as,
-                active_property => [element]
-              }
+
+              reification = {'@id' => as, active_property => [element]}
 
               # Note that annotation is an array, make the reified subject the id of each member of that array.
-              annotation = element.delete('@annotation').map do |a|
-                a.merge('@id' => star_subject)
-              end
+              annotation.each do |a|
+                # XXX may be zero or more reifiers; use bnode for now.
+                reifier = namer.get_name
+                a = a.merge('@id' => reifier, '@reifies' => reification)
 
-              # Invoke recursively using annotation.
-              create_node_map(annotation, graph_map,
-                active_graph: active_graph)
+                # Invoke recursively using annotation.
+                create_node_map(a, graph_map, active_graph: active_graph, active_subject: reifier)
+              end
             end
 
             if list.nil?
@@ -106,20 +105,13 @@ def create_node_map(element, graph_map,
             end
           else
             # Element is a node object
-            ser_id = id = element.delete('@id')
-            if id.is_a?(Hash)
-              # Index graph using serialized id
-              ser_id = id.to_json_c14n
-              raise "Can't happen"
-            elsif id.nil?
-              ser_id = id = namer.get_name
-            end
+            id = element.delete('@id')
+            id = namer.get_name(id) if blank_node?(id)
 
-            node = graph[ser_id] ||= { '@id' => id }
+            node = graph[id] ||= {'@id' => id}
 
-            if reverse
-              # NOTE: active_subject is a Hash
-              # We're processing a reverse-property relationship.
+            if active_subject.is_a?(Hash)
+              # If subject is a hash, then we're processing a reverse-property relationship.
               add_value(node, active_property, active_subject, property_is_array: true, allow_duplicate: false)
             elsif active_property
               reference = { '@id' => id }
@@ -131,30 +123,31 @@ def create_node_map(element, graph_map,
             end
 
             # For rdfstar, if node contains an `@annotation` member ...
-            # note: active_subject will not be nil, and may be an object itself.
+            # note: active_subject will not be nil
             # XXX: what if we're reversing an annotation?
-            if element.key?('@annotation')
+            if annotation = element.delete('@annotation')
               # rdfstar being true is implicit, as it is checked in expansion
               as = if node_reference?(active_subject)
                 active_subject['@id']
               else
                 active_subject
               end
-              star_subject = if reverse
-                { "@id" => node['@id'], active_property => [{ '@id' => as }] }
-              else
-                { "@id" => as, active_property => [{ '@id' => node['@id'] }] }
-              end
+
+              reification = {'@id' => as, active_property => [{ '@id' => node['@id'] }]}
 
               # Note that annotation is an array, make the reified subject the id of each member of that array.
-              annotation = element.delete('@annotation').map do |a|
-                a.merge('@id' => star_subject)
+              annotation.each do |a|
+                # XXX may be zero or more reifiers; use bnode for now.
+                reifier = namer.get_name
+                a = a.merge('@id' => reifier, '@reifies' => reification)
+
+                # Invoke recursively using annotation.
+                create_node_map(a, graph_map, active_graph: active_graph, active_subject: reifier)
               end
+            end
 
-              # Invoke recursively using annotation.
-              create_node_map(annotation, graph_map,
-                active_graph: active_graph,
-                active_subject: star_subject)
+            if element.key?('@reifies')
+              add_value(node, '@reifies', element.delete('@reifies'), property_is_array: true, allow_duplicate: false)
             end
 
             if element.key?('@type')
@@ -210,45 +203,68 @@ def create_node_map(element, graph_map,
       ##
       # Create annotations
       #
-      # Updates a node map from which annotations have been folded into embedded triples to re-extract the annotations.
+      # Updates a node map from which annotations have been folded into reified 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.
+      # Map entries having an `@reifies` key are used to find map entries that have a key based on the reification `@id` and a matching value. 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.
+      # * If the map contains an entry with that value, 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}] node_map
       # @return [Hash{String => Hash}]
       def create_annotations(node_map)
-        node_map.keys
-          .select { |k| k.start_with?('{') }
-          .sort_by(&:length)
-          .reverse_each do |key|
-          annotation = node_map[key]
-          # Deserialize key, and re-serialize the `@id` value.
-          emb = annotation['@id'].dup
-          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
-
-            node_map.delete(key)
-            annotation.delete('@id')
-            add_value(emb_value, '@annotation', annotation, property_is_array: true) unless
-              annotation.empty?
+        node_map
+          .select {|_, node| node.key?('@reifies')}
+          .each do |key, node|
+
+          reif_id = node['@id']
+          reifs = node['@reifies']
+          raise "expected the value of `@reifies` to be an array: #{reifs.inspect}" unless
+            reifs.is_a?(Array)
+
+          # The node has properties other than `@id` and `@reifies`
+          annotation = node.dup.delete_if {|k, _| %w(@id @reifies).include?(k)}
+
+          reifs.each do |reif|
+            # node is a reification which _may_ relate to a value elsewhere in node_map
+            raise "expected the value of `@reifies` to be an array: #{reifs.inspect}" unless
+              reifs.is_a?(Array)
+            target_id = reif['@id']
+            target_node = node_map[target_id]
+            next unless target_node
+
+            # The reification should have just `@id` and an additional property
+            reif_prop = (reif.keys - %w(@id)).first
+            raise "expected reification to have a non-id key: #{node.keys.inspect}" unless
+              reif_prop
+            reif_values = reif[reif_prop]
+            # There should be only a single value
+            raise "expected a single reifiation property value: #{reif}" unless
+              reif_values.length == 1
+
+            reif_value = reif_values.first
+
+            # If target_node has the matching property and a matching value
+            target_values = target_node[reif_prop]
+            next unless target_values
+
+            # target_values must be an array
+            raise "expected target propery value to have an array value: #{target_values.inspect}" unless
+              target_values.is_a?(Array)
+
+            target_values.each do |t_value|
+              next unless t_value == reif_value
+
+              # Add annotation to the identified value
+              t_value['@annotation'] ||= []
+              t_value['@annotation'] << {'@id' => reif_id}.merge(annotation)
+
+              # This consumes the reification
+              node['@reifies'] = node['@reifies'] - [reif]
+            end
           end
+
+          # If all reifications are consumed, remove the reification
+          node_map.delete(reif_id) if node['@reifies'].empty?
         end
       end
 

lib/json/ld/from_rdf.rb

@@ -74,6 +74,13 @@ def from_statements(dataset, useRdfType: false, useNativeTypes: false, extendedR
             next
           end
 
+          # If predicate equals rdf:reifies and object is a triple term, append the @reifies of that triple term.
+          if statement.predicate == RDF.reifies && statement.object.tripleTerm?
+            reification = resource_representation(statement.object, useNativeTypes, extendedRepresentation)
+            merge_value(node, '@reifies', reification['@triple'])
+            next
+          end
+
           # Set value to the result of using the RDF to Object Conversion algorithm, passing object, rdfDirection, and use native types.
           value = resource_representation(statement.object, useNativeTypes, extendedRepresentation)
 

lib/json/ld/to_rdf.rb

@@ -94,6 +94,15 @@ def item_to_rdf(item, graph_name: nil, tripleTerm: false, &block)
         # log_debug("item_to_rdf")  {"subject: #{subject.to_ntriples rescue 'malformed rdf'}"}
         item.each do |property, values|
           case property
+          when '@reifies'
+            next unless @options[:rdfstar]
+
+            # Each value of @reifies returns a single triple
+            as_array(item['@reifies']).each do |rei|
+              item_to_rdf(rei, graph_name: graph_name, tripleTerm: true) do |rei|
+                yield RDF::Statement(subject, RDF.reifies, rei, graph_name: graph_name, tripleTerm: tripleTerm)
+              end
+            end
           when '@type'
             # If property is @type, construct triple as an RDF Triple composed of id, rdf:type, and object from values where id and object are represented either as IRIs or Blank Nodes
             values.each do |v|

lib/json/ld/utils.rb

@@ -97,6 +97,15 @@ def triple_term?(value)
         value.is_a?(Hash) && value.key?('@triple')
       end
 
+      ##
+      # Is value a reification?
+      #
+      # @param [Object] value
+      # @return [Boolean]
+      def reification?(value)
+        value.is_a?(Hash) && value.key?('@reifies')
+      end
+
       ##
       # Is value a literal?
       #

script/tc

@@ -130,7 +130,7 @@ def run_tc(man, tc, options)
             # toRdf/e075 is hard to test, but verified manually
             output == tc.expect ? 'passed' : (tc.input_loc.include?('e075') ? 'passed' : 'failed')
           else
-            expected = RDF::Repository.new << RDF::NQuads::Reader.new(tc.expect, rdfstar: tc.options[:rdfstar], validate: false, logger: [])
+            expected = RDF::Repository.new << RDF::NQuads::Reader.new(tc.expect, rdfstar: tc.options[:rdfstar], validate: false)
             output.isomorphic?(expected) ? 'passed' : 'failed'
           end
         rescue RDF::ReaderError, JSON::LD::JsonLdError
@@ -179,6 +179,8 @@ def run_tc(man, tc, options)
         "failed"
       end
     end
+  ensure
+    STDERR.puts options[:logger].to_s if options[:verbose]
   end
 
   #options[:output].puts("\nOutput:\n" + output) unless options[:quiet]
@@ -200,7 +202,7 @@ def run_tc(man, tc, options)
   puts "#{" test result:" unless options[:quiet]} #{result}"
 end
 
-logger = Logger.new(STDERR)
+logger = RDF::Spec.logger
 logger.level = Logger::WARN
 logger.formatter = lambda {|severity, datetime, progname, msg| "#{severity}: #{msg}\n"}
 

spec/rdfstar_spec.rb

@@ -17,6 +17,7 @@
         describe m.name do
           m.entries.each do |t|
             specify "#{t.property('@id')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
+              pending "annotation folding" if t.name.include?("(with @annotation)")
               t.options[:ordered] = false
               expect { t.run self }.not_to write.to(:error)
             end

spec/writer_spec.rb

@@ -321,7 +321,6 @@
 
             expect(parse(jsonld, format: :jsonld, **t.options)).to be_equivalent_graph(repo, t)
           rescue RDF::WriterError => e
-            #require 'byebug'; byebug
             fail e.message + logger.to_s
           end
         end