json-ld 3.1.3 → 3.1.8

data/lib/json/ld/extensions.rb

@@ -11,10 +11,10 @@ module RDF
   class Statement
     # Validate extended RDF
     def valid_extended?
-      has_subject?    && subject.resource? && subject.valid_extended? &&
-      has_predicate?  && predicate.resource? && predicate.valid_extended? &&
-      has_object?     && object.term? && object.valid_extended? &&
-      (has_graph?      ? (graph_name.resource? && graph_name.valid_extended?) : true)
+      subject?    && subject.resource? && subject.valid_extended? &&
+      predicate?  && predicate.resource? && predicate.valid_extended? &&
+      object?     && object.term? && object.valid_extended? &&
+      (graph?      ? (graph_name.resource? && graph_name.valid_extended?) : true)
     end
   end
 

data/lib/json/ld/flatten.rb

@@ -1,5 +1,7 @@
 # -*- encoding: utf-8 -*-
 # frozen_string_literal: true
+require 'json/canonicalization'
+
 module JSON::LD
   module Flatten
     include Utils
@@ -7,6 +9,10 @@ module JSON::LD
     ##
     # This algorithm creates a JSON object node map holding an indexed representation of the graphs and nodes represented in the passed expanded document. All nodes that are not uniquely identified by an IRI get assigned a (new) blank node identifier. The resulting node map will have a member for every graph in the document whose value is another object with a member for every node represented in the document. The default graph is stored under the @default member, all other graphs are stored under their graph name.
     #
+    # For RDF*/JSON-LD*:
+    #   * Values of `@id` can be an object (embedded node); when these are used as keys in a Node Map, they are serialized as canonical JSON, and de-serialized when flattening.
+    #   * The presence of `@annotation` implies an embedded node and the annotation object is removed from the node/value object in which it appears.
+    #
     # @param [Array, Hash] element
     #   Expanded JSON-LD input
     # @param [Hash] graph_map A map of graph name to subjects
@@ -16,12 +22,15 @@ module JSON::LD
     #   Node identifier
     # @param [String] active_property (nil)
     #   Property within current node
+    # @param [Boolean] reverse (false)
+    #   Processing a reverse relationship
     # @param [Array] list (nil)
     #   Used when property value is a list
     def create_node_map(element, graph_map,
                         active_graph: '@default',
                         active_subject: nil,
                         active_property: nil,
+                        reverse: false,
                         list: nil)
       if element.is_a?(Array)
         # If element is an array, process each entry in element recursively by passing item for element, node map, active graph, active subject, active property, and list.
@@ -30,21 +39,45 @@ module JSON::LD
                           active_graph: active_graph,
                           active_subject: active_subject,
                           active_property: active_property,
+                          reverse: false,
                           list: list)
         end
       elsif !element.is_a?(Hash)
         raise "Expected hash or array to create_node_map, got #{element.inspect}"
       else
         graph = (graph_map[active_graph] ||= {})
-        subject_node = graph[active_subject]
+        subject_node = !reverse && graph[active_subject.is_a?(Hash) ? active_subject.to_json_c14n : active_subject]
 
         # Transform BNode types
-        if element.has_key?('@type')
+        if element.key?('@type')
           element['@type'] = Array(element['@type']).map {|t| blank_node?(t) ? namer.get_name(t) : t}
         end
 
         if value?(element)
           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')
+            # rdfstar being true is implicit, as it is checked in expansion
+            as = node_reference?(active_subject) ?
+              active_subject['@id'] :
+              active_subject
+            star_subject = {
+              "@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
+
+            # Invoke recursively using annotation.
+            create_node_map(annotation, graph_map,
+                            active_graph: active_graph)
+          end
+
           if list.nil?
             add_value(subject_node, active_property, element, property_is_array: true, allow_duplicate: false)
           else
@@ -64,13 +97,19 @@ module JSON::LD
           end
         else
           # Element is a node object
-          id = element.delete('@id')
-          id = namer.get_name(id) if blank_node?(id)
+          ser_id = id = element.delete('@id')
+          if id.is_a?(Hash)
+            # Index graph using serialized id
+            ser_id = id.to_json_c14n
+          elsif id.nil?
+            ser_id = id = namer.get_name
+          end
 
-          node = graph[id] ||= {'@id' => id}
+          node = graph[ser_id] ||= {'@id' => id}
 
-          if active_subject.is_a?(Hash)
-            # If subject is a hash, then we're processing a reverse-property relationship.
+          if reverse
+            # Note: active_subject is a Hash
+            # 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}
@@ -81,7 +120,30 @@ module JSON::LD
             end
           end
 
-          if element.has_key?('@type')
+          # For rdfstar, if node contains an `@annotation` member ...
+          # note: active_subject will not be nil, and may be an object itself.
+          # XXX: what if we're reversing an annotation?
+          if element.key?('@annotation')
+            # rdfstar being true is implicit, as it is checked in expansion
+            as = node_reference?(active_subject) ?
+              active_subject['@id'] :
+              active_subject
+            star_subject = reverse ? 
+              {"@id" => node['@id'], active_property => [{'@id' => as}]} :
+              {"@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)
+            end
+
+            # Invoke recursively using annotation.
+            create_node_map(annotation, graph_map,
+                            active_graph: active_graph,
+                            active_subject: star_subject)
+          end
+
+          if element.key?('@type')
             add_value(node, '@type', element.delete('@type'), property_is_array: true, allow_duplicate: false)
           end
 
@@ -99,7 +161,8 @@ module JSON::LD
                 create_node_map(value, graph_map,
                                 active_graph: active_graph,
                                 active_subject: referenced_node,
-                                active_property: property)
+                                active_property: property,
+                                reverse: true)
               end
             end
           end
@@ -128,7 +191,27 @@ module JSON::LD
       end
     end
 
+    ##
+    # Rename blank nodes recursively within an embedded object
+    #
+    # @param [Object] node
+    # @return [Hash]
+    def rename_bnodes(node)
+      case node
+      when Array
+        node.map {|n| rename_bnodes(n)}
+      when Hash
+        node.inject({}) do |memo, (k, v)|
+          v = namer.get_name(v) if k == '@id' && v.is_a?(String) && blank_node?(v)
+          memo.merge(k => rename_bnodes(v))
+        end
+      else
+        node
+      end
+    end
+
   private
+
     ##
     # Merge nodes from all graphs in the graph_map into a new node map
     #

data/lib/json/ld/format.rb

@@ -57,10 +57,11 @@ module JSON::LD
           lambda: ->(files, **options) do
             out = options[:output] || $stdout
             out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
-            options = options.merge(expandContext: options.delete(:context)) if options.has_key?(:context)
+            options = options.merge(expandContext: options.delete(:context)) if options.key?(:context)
+            options[:base] ||= options[:base_uri]
             if options[:format] == :jsonld
               if files.empty?
-                # If files are empty, either use options[:execute]
+                # If files are empty, either use options[:evaluate] or STDIN
                 input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
                 input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
                 JSON::LD::API.expand(input, validate: false, **options) do |expanded|
@@ -93,9 +94,10 @@ module JSON::LD
             raise ArgumentError, "Compacting requires a context" unless options[:context]
             out = options[:output] || $stdout
             out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
+            options[:base] ||= options[:base_uri]
             if options[:format] == :jsonld
               if files.empty?
-                # If files are empty, either use options[:execute]
+                # If files are empty, either use options[:evaluate] or STDIN
                 input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
                 input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
                 JSON::LD::API.compact(input, options[:context], **options) do |compacted|
@@ -126,7 +128,7 @@ module JSON::LD
               control: :url2,
               use: :required,
               on: ["--context CONTEXT"],
-              description: "Context to use when compacting.") {|arg| RDF::URI(arg)},
+              description: "Context to use when compacting.") {|arg| RDF::URI(arg).absolute? ? RDF::URI(arg) : StringIO.new(File.read(arg))},
           ]
         },
         flatten: {
@@ -137,9 +139,10 @@ module JSON::LD
           lambda: ->(files, **options) do
             out = options[:output] || $stdout
             out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
+            options[:base] ||= options[:base_uri]
             if options[:format] == :jsonld
               if files.empty?
-                # If files are empty, either use options[:execute]
+                # If files are empty, either use options[:evaluate] or STDIN
                 input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
                 input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
                 JSON::LD::API.flatten(input, options[:context], **options) do |flattened|
@@ -162,7 +165,16 @@ module JSON::LD
                 end
               end
             end
-          end
+          end,
+          options: [
+            RDF::CLI::Option.new(
+              symbol: :context,
+              datatype: RDF::URI,
+              control: :url2,
+              use: :required,
+              on: ["--context CONTEXT"],
+              description: "Context to use when compacting.") {|arg| RDF::URI(arg)},
+          ]
         },
         frame: {
           description: "Frame JSON-LD or parsed RDF",
@@ -173,9 +185,10 @@ module JSON::LD
             raise ArgumentError, "Framing requires a frame" unless options[:frame]
             out = options[:output] || $stdout
             out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
+            options[:base] ||= options[:base_uri]
             if options[:format] == :jsonld
               if files.empty?
-                # If files are empty, either use options[:execute]
+                # If files are empty, either use options[:evaluate] or STDIN
                 input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
                 input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
                 JSON::LD::API.frame(input, options[:frame], **options) do |framed|
@@ -207,7 +220,7 @@ module JSON::LD
               control: :url2,
               use: :required,
               on: ["--frame FRAME"],
-              description: "Frame to use when serializing.") {|arg| RDF::URI(arg)}
+              description: "Frame to use when serializing.") {|arg| RDF::URI(arg).absolute? ? RDF::URI(arg) : StringIO.new(File.read(arg))}
           ]
         },
       }

data/lib/json/ld/frame.rb

@@ -52,7 +52,7 @@ module JSON::LD
           state[:uniqueEmbeds][state[:graph]] ||= {}
         end
 
-        if flags[:embed] == '@link' && link.has_key?(id)
+        if flags[:embed] == '@link' && link.key?(id)
           # add existing linked subject
           add_frame_output(parent, property, link[id])
           next
@@ -66,7 +66,7 @@ module JSON::LD
           warn "[DEPRECATION] #{flags[:embed]}  is not a valid value of @embed in 1.1 mode.\n"
         end
 
-        if !state[:embedded] && state[:uniqueEmbeds][state[:graph]].has_key?(id)
+        if !state[:embedded] && state[:uniqueEmbeds][state[:graph]].key?(id)
           # Skip adding this node object to the top-level, as it was included in another node object
           next
         elsif state[:embedded] &&
@@ -76,7 +76,7 @@ module JSON::LD
           next
         elsif state[:embedded] &&
           %w(@first @once).include?(flags[:embed]) &&
-          state[:uniqueEmbeds][state[:graph]].has_key?(id)
+          state[:uniqueEmbeds][state[:graph]].key?(id)
 
           # if only the first match should be embedded
           # Embed unless already embedded
@@ -97,7 +97,7 @@ module JSON::LD
         state[:subjectStack] << {subject: subject, graph: state[:graph]}
 
         # Subject is also the name of a graph
-        if state[:graphMap].has_key?(id)
+        if state[:graphMap].key?(id)
           # check frame's "@graph" to see what to do next
           # 1. if it doesn't exist and state.graph === "@merged", don't recurse
           # 2. if it doesn't exist and state.graph !== "@merged", recurse
@@ -105,7 +105,7 @@ module JSON::LD
           # 4. if "@default" then don't recurse
           # 5. recurse
           recurse, subframe = false, nil
-          if !frame.has_key?('@graph')
+          if !frame.key?('@graph')
             recurse, subframe = (state[:graph] != '@merged'), {}
           else
             subframe = frame['@graph'].first
@@ -134,7 +134,7 @@ module JSON::LD
           end
 
           # explicit is on and property isn't in frame, skip processing
-          next if flags[:explicit] && !frame.has_key?(prop)
+          next if flags[:explicit] && !frame.key?(prop)
 
           # add objects
           objects.each do |o|
@@ -267,7 +267,7 @@ module JSON::LD
         # If, after replacement, an array contains only the value null remove the value, leaving an empty array.
         input.map {|o| cleanup_preserve(o)}
       when Hash
-        if input.has_key?('@preserve')
+        if input.key?('@preserve')
           # Replace with the content of `@preserve`
           cleanup_preserve(input['@preserve'].first)
         else
@@ -388,7 +388,7 @@ module JSON::LD
           is_empty = v.empty?
           if v = v.first
             validate_frame(v)
-            has_default = v.has_key?('@default')
+            has_default = v.key?('@default')
           end
 
           # No longer a wildcard pattern if frame has any non-keyword properties

data/lib/json/ld/from_rdf.rb

@@ -14,16 +14,14 @@ module JSON::LD
     # @param [Boolean] useRdfType (false)
     #   If set to `true`, the JSON-LD processor will treat `rdf:type` like a normal property instead of using `@type`.
     # @param [Boolean] useNativeTypes (false) use native representations
-    # @param [Boolean] ordered (true)
-    #   Ensure output objects have keys ordered properly
+    #
     # @return [Array<Hash>] the JSON-LD document in normalized form
-    def from_statements(dataset, useRdfType: false, useNativeTypes: false, ordered: false)
+    def from_statements(dataset, useRdfType: false, useNativeTypes: false)
       default_graph = {}
       graph_map = {'@default' => default_graph}
       referenced_once = {}
 
       value = nil
-      ec = @context
 
       # Create an entry for compound-literal node detection
       compound_literal_subjects = {}
@@ -34,7 +32,7 @@ module JSON::LD
       dataset.each do |statement|
         #log_debug("statement") { statement.to_nquads.chomp}
 
-        name = statement.graph_name ? ec.expand_iri(statement.graph_name).to_s : '@default'
+        name = statement.graph_name ? @context.expand_iri(statement.graph_name, base: @options[:base]).to_s : '@default'
 
         # Create a graph entry as needed
         node_map = graph_map[name] ||= {}
@@ -42,30 +40,29 @@ module JSON::LD
 
         default_graph[name] ||= {'@id' => name} unless name == '@default'
 
-        subject = ec.expand_iri(statement.subject, as_string: true)
-        node = node_map[subject] ||= {'@id' => subject}
+        subject = 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'
           compound_literal_subjects[name][subject] ||= true
         end
 
-        # If object is an IRI or blank node identifier, 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.
-        node_map[statement.object.to_s] ||= {'@id' => statement.object.to_s} unless
-          statement.object.literal?
+        # 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] ||=
+            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
         end
 
         # Set value to the result of using the RDF to Object Conversion algorithm, passing object, rdfDirection, and use native types.
-        value = ec.expand_value(nil,
-                                statement.object,
-                                rdfDirection: @options[:rdfDirection],
-                                useNativeTypes: useNativeTypes,
-                                log_depth: @options[:log_depth])
+        value = resource_representation(statement.object, useNativeTypes)
 
         merge_value(node, statement.predicate.to_s, value)
 
@@ -78,7 +75,7 @@ module JSON::LD
             property: statement.predicate.to_s,
             value:    value
           })
-        elsif referenced_once.has_key?(statement.object.to_s)
+        elsif referenced_once.key?(statement.object.to_s)
           referenced_once[statement.object.to_s] = false
         elsif statement.object.node?
           referenced_once[statement.object.to_s] = {
@@ -147,11 +144,11 @@ module JSON::LD
       end
 
       result = []
-      default_graph.keys.opt_sort(ordered: ordered).each do |subject|
+      default_graph.keys.opt_sort(ordered: @options[:ordered]).each do |subject|
         node = default_graph[subject]
-        if graph_map.has_key?(subject)
+        if graph_map.key?(subject)
           node['@graph'] = []
-          graph_map[subject].keys.opt_sort(ordered: ordered).each do |s|
+          graph_map[subject].keys.opt_sort(ordered: @options[:ordered]).each do |s|
             n = graph_map[subject][s]
             n.delete(:usages)
             node['@graph'] << n unless node_reference?(n)
@@ -163,5 +160,31 @@ module JSON::LD
       #log_debug("fromRdf") {result.to_json(JSON_STATE) rescue 'malformed json'}
       result
     end
+
+    private
+    def resource_representation(resource, useNativeTypes)
+      case resource
+      when RDF::Statement
+        # Note, if either subject or object are a BNode which is used elsewhere,
+        # this might not work will with the BNode accounting from above.
+        rep = {'@id' => resource_representation(resource.subject, false)}
+        if resource.predicate == RDF.type
+          rep['@id'].merge!('@type' => resource.object.to_s)
+        else
+          rep['@id'].merge!(
+            resource.predicate.to_s =>
+            as_array(resource_representation(resource.object, useNativeTypes)))
+        end
+        rep
+      when RDF::Literal
+        @context.expand_value(nil,
+                              resource,
+                              rdfDirection: @options[:rdfDirection],
+                              useNativeTypes: useNativeTypes,
+                              base: @options[:base])
+      else
+        {'@id' => resource.to_s}
+      end
+    end
   end
 end