json-ld 2.0.0.1 → 2.1.0

data/lib/json/ld/extensions.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 module RDF
   class Node
     # Odd case of appending to a BNode identifier

data/lib/json/ld/flatten.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 module JSON::LD
   module Flatten
     include Utils
@@ -14,109 +16,103 @@ module JSON::LD
     #   The name assigned to the current input if it is a bnode
     # @param [Array] list
     #   List to append to, nil for none
-    def create_node_map(input,
-                        graphs,
-                        graph = '@default',
-                        name  = nil,
-                        list  = nil)
-      log_depth do
-        log_debug("node_map") {"graph: #{graph}, input: #{input.inspect}, name: #{name}"}
-        case input
-        when Array
-          # If input is an array, process each entry in input recursively by passing item for input, node map, active graph, active subject, active property, and list.
-          input.map {|o| create_node_map(o, graphs, graph, nil, list)}
-        when Hash
-          type = input['@type']
-          if value?(input)
-            # Rename blanknode @type
-            input['@type'] = namer.get_name(type) if type && blank_node?(type)
-            list << input if list
-          else
-            # Input is a node definition
+    def create_node_map(input, graphs, graph: '@default', name: nil, list: nil)
+      #log_debug("node_map") {"graph: #{graph}, input: #{input.inspect}, name: #{name}"}
+      case input
+      when Array
+        # If input is an array, process each entry in input recursively by passing item for input, node map, active graph, active subject, active property, and list.
+        input.map {|o| create_node_map(o, graphs, graph: graph, list: list)}
+      when Hash
+        type = input['@type']
+        if value?(input)
+          # Rename blanknode @type
+          input['@type'] = namer.get_name(type) if type && blank_node?(type)
+          list << input if list
+        else
+          # Input is a node definition
 
-            # spec requires @type to be named first, so assign names early
-            Array(type).each {|t| namer.get_name(t) if blank_node?(t)}
+          # spec requires @type to be named first, so assign names early
+          Array(type).each {|t| namer.get_name(t) if blank_node?(t)}
 
-            # get name for subject
-            if name.nil?
-              name ||= input['@id']
-              name = namer.get_name(name) if blank_node?(name)
-            end
+          # get name for subject
+          if name.nil?
+            name ||= input['@id']
+            name = namer.get_name(name) if blank_node?(name)
+          end
 
-            # add subject reference to list
-            list << {'@id' => name} if list
+          # add subject reference to list
+          list << {'@id' => name} if list
 
-            # create new subject or merge into existing one
-            subject = (graphs[graph] ||= {})[name] ||= {'@id' => name}
+          # create new subject or merge into existing one
+          subject = (graphs[graph] ||= {})[name] ||= {'@id' => name}
 
-            input.keys.kw_sort.each do |property|
-              objects = input[property]
-              case property
-              when '@id'
-                # Skip
-              when '@reverse'
-                # handle reverse properties
-                referenced_node, reverse_map = {'@id' => name}, objects
-                reverse_map.each do |reverse_property, items|
-                  items.each do |item|
-                    item_name = item['@id']
-                    item_name = namer.get_name(item_name) if blank_node?(item_name)
-                    create_node_map(item, graphs, graph, item_name)
-                    add_value(graphs[graph][item_name],
-                              reverse_property,
-                              referenced_node,
-                              property_is_array: true,
-                              allow_duplicate: false)
-                  end
-                end
-              when '@graph'
-                graphs[name] ||= {}
-                g = graph == '@merged' ? graph : name
-                create_node_map(objects, graphs, g)
-              when /^@(?!type)/
-                # copy non-@type keywords
-                if property == '@index' && subject['@index']
-                  raise JsonLdError::ConflictingIndexes,
-                        "Element already has index #{subject['@index']} dfferent from #{input['@index']}" if
-                        subject['@index'] != input['@index']
-                  subject['@index'] = input.delete('@index')
+          input.keys.kw_sort.each do |property|
+            objects = input[property]
+            case property
+            when '@id'
+              # Skip
+            when '@reverse'
+              # handle reverse properties
+              referenced_node, reverse_map = {'@id' => name}, objects
+              reverse_map.each do |reverse_property, items|
+                items.each do |item|
+                  item_name = item['@id']
+                  item_name = namer.get_name(item_name) if blank_node?(item_name)
+                  create_node_map(item, graphs, graph: graph, name: item_name)
+                  add_value(graphs[graph][item_name],
+                            reverse_property,
+                            referenced_node,
+                            property_is_array: true,
+                            allow_duplicate: false)
                 end
-                subject[property] = objects
-              else
-                # if property is a bnode, assign it a new id
-                property = namer.get_name(property) if blank_node?(property)
+              end
+            when '@graph'
+              graphs[name] ||= {}
+              g = graph == '@merged' ? graph : name
+              create_node_map(objects, graphs, graph: g)
+            when /^@(?!type)/
+              # copy non-@type keywords
+              if property == '@index' && subject['@index']
+                raise JsonLdError::ConflictingIndexes,
+                      "Element already has index #{subject['@index']} dfferent from #{input['@index']}" if
+                      subject['@index'] != input['@index']
+                subject['@index'] = input.delete('@index')
+              end
+              subject[property] = objects
+            else
+              # if property is a bnode, assign it a new id
+              property = namer.get_name(property) if blank_node?(property)
 
-                add_value(subject, property, [], property_is_array: true) if objects.empty?
+              add_value(subject, property, [], property_is_array: true) if objects.empty?
 
-                objects.each do |o|
-                  o = namer.get_name(o) if property == '@type' && blank_node?(o)
+              objects.each do |o|
+                o = namer.get_name(o) if property == '@type' && blank_node?(o)
 
-                  case
-                  when node?(o) || node_reference?(o)
-                    id = o['@id']
-                    id = namer.get_name(id) if blank_node?(id)
+                case
+                when node?(o) || node_reference?(o)
+                  id = o['@id']
+                  id = namer.get_name(id) if blank_node?(id)
 
-                    # add reference and recurse
-                    add_value(subject, property, {'@id' => id}, property_is_array: true, allow_duplicate: false)
-                    create_node_map(o, graphs, graph, id)
-                  when list?(o)
-                    olist = []
-                    create_node_map(o['@list'], graphs, graph, name, olist)
-                    o = {'@list' => olist}
-                    add_value(subject, property, o, property_is_array: true, allow_duplicate: true)
-                  else
-                    # handle @value
-                    create_node_map(o, graphs, graph, name)
-                    add_value(subject, property, o, property_is_array: true, allow_duplicate: false)
-                  end
+                  # add reference and recurse
+                  add_value(subject, property, {'@id' => id}, property_is_array: true, allow_duplicate: false)
+                  create_node_map(o, graphs, graph: graph, name: id)
+                when list?(o)
+                  olist = []
+                  create_node_map(o['@list'], graphs, graph: graph, name: name, list: olist)
+                  o = {'@list' => olist}
+                  add_value(subject, property, o, property_is_array: true, allow_duplicate: true)
+                else
+                  # handle @value
+                  create_node_map(o, graphs, graph: graph, name: name)
+                  add_value(subject, property, o, property_is_array: true, allow_duplicate: false)
                 end
               end
             end
           end
-        else
-          # add non-object to list
-          list << input if list
         end
+      else
+        # add non-object to list
+        list << input if list
       end
     end
   end

data/lib/json/ld/format.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 module JSON::LD
   ##
   # JSON-LD format specification.
@@ -44,7 +46,7 @@ module JSON::LD
 
     ##
     # Hash of CLI commands appropriate for this format
-    # @return [Hash{Symbol => Lambda(Array, Hash)}]
+    # @return [Hash{Symbol => Hash}]
     def self.cli_commands
       {
         expand: {

data/lib/json/ld/frame.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 module JSON::LD
   module Frame
     include Utils
@@ -17,131 +19,133 @@ module JSON::LD
     #   The parent property.
     # @raise [JSON::LD::InvalidFrame]
     def frame(state, subjects, frame, options = {})
-      log_depth do
-        parent, property = options[:parent], options[:property]
-        # Validate the frame
-        validate_frame(state, frame)
-        frame = frame.first if frame.is_a?(Array)
-
-        # Get values for embedOn and explicitOn
-        flags = {
-          embed: get_frame_flag(frame, options, :embed),
-          explicit: get_frame_flag(frame, options, :explicit),
-          requireAll: get_frame_flag(frame, options, :requireAll),
-        }
-
-        # Create a set of matched subjects by filtering subjects by checking the map of flattened subjects against frame
-        # This gives us a hash of objects indexed by @id
-        matches = filter_subjects(state, subjects, frame, flags)
-
-        # For each id and node from the set of matched subjects ordered by id
-        matches.keys.kw_sort.each do |id|
-          subject = matches[id]
-
-          if flags[:embed] == '@link' && state[:link].has_key?(id)
-            # TODO: may want to also match an existing linked subject
-            # against the current frame ... so different frames could
-            # produce different subjects that are only shared in-memory
-            # when the frames are the same
-
-            # add existing linked subject
-            add_frame_output(parent, property, state[:link][id])
-            next
-          end
+      parent, property = options[:parent], options[:property]
+      # Validate the frame
+      validate_frame(state, frame)
+      frame = frame.first if frame.is_a?(Array)
+
+      # Get values for embedOn and explicitOn
+      flags = {
+        embed: get_frame_flag(frame, options, :embed),
+        explicit: get_frame_flag(frame, options, :explicit),
+        requireAll: get_frame_flag(frame, options, :requireAll),
+      }
+
+      # Create a set of matched subjects by filtering subjects by checking the map of flattened subjects against frame
+      # This gives us a hash of objects indexed by @id
+      matches = filter_subjects(state, subjects, frame, flags)
+
+      # For each id and node from the set of matched subjects ordered by id
+      matches.keys.kw_sort.each do |id|
+        subject = matches[id]
+
+        if flags[:embed] == '@link' && state[:link].has_key?(id)
+          # TODO: may want to also match an existing linked subject
+          # against the current frame ... so different frames could
+          # produce different subjects that are only shared in-memory
+          # when the frames are the same
+
+          # add existing linked subject
+          add_frame_output(parent, property, state[:link][id])
+          next
+        end
 
-          # Note: In order to treat each top-level match as a
-          # compartmentalized result, clear the unique embedded subjects map
-          # when the property is None, which only occurs at the top-level.
-          state = state.merge(uniqueEmbeds: {}) if property.nil?
-
-          output = {'@id' => id}
-          state[:link][id] = output
-
-          # if embed is @never or if a circular reference would be created
-          # by an embed, the subject cannot be embedded, just add the
-          # reference; note that a circular reference won't occur when the
-          # embed flag is `@link` as the above check will short-circuit
-          # before reaching this point
-          if flags[:embed] == '@never' || creates_circular_reference(subject, state[:subjectStack])
-            add_frame_output(parent, property, output)
-            next
-          end
+        # Note: In order to treat each top-level match as a compartmentalized result, clear the unique embedded subjects map when the property is None, which only occurs at the top-level.
+        state = state.merge(uniqueEmbeds: {}) if property.nil?
 
-          # if only the last match should be embedded
-          if flags[:embed] == '@last'
-            # remove any existing embed
-            remove_embed(state, id) if state[:uniqueEmbeds].include?(id)
-            state[:uniqueEmbeds][id] = {
-              parent: parent,
-              property: property
-            }
-          end
+        output = {'@id' => id}
+        state[:link][id] = output
 
-          # push matching subject onto stack to enable circular embed checks
-          state[:subjectStack] << subject
+        # if embed is @never or if a circular reference would be created by an embed, the subject cannot be embedded, just add the reference; note that a circular reference won't occur when the embed flag is `@link` as the above check will short-circuit before reaching this point
+        if flags[:embed] == '@never' || creates_circular_reference(subject, state[:subjectStack])
+          add_frame_output(parent, property, output)
+          next
+        end
 
-          # iterate over subject properties in order
-          subject.keys.kw_sort.each do |prop|
-            objects = subject[prop]
+        # if only the last match should be embedded
+        if flags[:embed] == '@last'
+          # remove any existing embed
+          remove_embed(state, id) if state[:uniqueEmbeds].include?(id)
+          state[:uniqueEmbeds][id] = {
+            parent: parent,
+            property: property
+          }
+        end
 
-            # copy keywords to output
-            if prop.start_with?('@')
-              output[prop] = objects.dup
-              next
-            end
+        # push matching subject onto stack to enable circular embed checks
+        state[:subjectStack] << subject
+
+        # iterate over subject properties in order
+        subject.keys.kw_sort.each do |prop|
+          objects = subject[prop]
+
+          # copy keywords to output
+          if prop.start_with?('@')
+            output[prop] = objects.dup
+            next
+          end
 
-            # explicit is on and property isn't in frame, skip processing
-            next if flags[:explicit] && !frame.has_key?(prop)
-
-            # add objects
-            objects.each do |o|
-              case
-              when list?(o)
-                # add empty list
-                list = {'@list' => []}
-                add_frame_output(output, prop, list)
-
-                src = o['@list']
-                src.each do |oo|
-                  if node_reference?(oo)
-                    subframe = frame[prop].first['@list'] if frame[prop].is_a?(Array) && frame[prop].first.is_a?(Hash)
-                    subframe ||= create_implicit_frame(flags)
-                    frame(state, [oo['@id']], subframe, options.merge(parent: list, property: '@list'))
-                  else
-                    add_frame_output(list, '@list', oo.dup)
-                  end
+          # explicit is on and property isn't in frame, skip processing
+          next if flags[:explicit] && !frame.has_key?(prop)
+
+          # add objects
+          objects.each do |o|
+            case
+            when list?(o)
+              # add empty list
+              list = {'@list' => []}
+              add_frame_output(output, prop, list)
+
+              src = o['@list']
+              src.each do |oo|
+                if node_reference?(oo)
+                  subframe = frame[prop].first['@list'] if frame[prop].is_a?(Array) && frame[prop].first.is_a?(Hash)
+                  subframe ||= create_implicit_frame(flags)
+                  frame(state, [oo['@id']], subframe, options.merge(parent: list, property: '@list'))
+                else
+                  add_frame_output(list, '@list', oo.dup)
                 end
-              when node_reference?(o)
-                # recurse into subject reference
-                subframe = frame[prop] || create_implicit_frame(flags)
-                frame(state, [o['@id']], subframe, options.merge(parent: output, property: prop))
-              else
-                # include other values automatically
-                add_frame_output(output, prop, o.dup)
               end
+            when node_reference?(o)
+              # recurse into subject reference
+              subframe = frame[prop] || create_implicit_frame(flags)
+              frame(state, [o['@id']], subframe, options.merge(parent: output, property: prop))
+            else
+              # include other values automatically
+              add_frame_output(output, prop, o.dup)
             end
           end
+        end
+
+        # handle defaults in order
+        frame.keys.kw_sort.reject {|p| p.start_with?('@')}.each do |prop|
+          # if omit default is off, then include default values for properties that appear in the next frame but are not in the matching subject
+          n = frame[prop].first || {}
+          omit_default_on = get_frame_flag(n, options, :omitDefault)
+          if !omit_default_on && !output[prop]
+            preserve = n.fetch('@default', '@null').dup
+            preserve = [preserve] unless preserve.is_a?(Array)
+            output[prop] = [{'@preserve' => preserve}]
+          end
+        end
 
-          # handle defaults in order
-          frame.keys.kw_sort.reject {|p| p.start_with?('@')}.each do |prop|
-            # if omit default is off, then include default values for
-            # properties that appear in the next frame but are not in
-            # the matching subject
-            n = frame[prop].first || {}
-            omit_default_on = get_frame_flag(n, options, :omitDefault)
-            if !omit_default_on && !output[prop]
-              preserve = n.fetch('@default', '@null').dup
-              preserve = [preserve] unless preserve.is_a?(Array)
-              output[prop] = [{'@preserve' => preserve}]
+        # If frame has @reverse, embed identified nodes having this subject as a value of the associated property.
+        frame.fetch('@reverse', {}).each do |reverse_prop, subframe|
+          state[:subjects].each do |r_id, node|
+            if Array(node[reverse_prop]).any? {|v| v['@id'] == id}
+              # Node has property referencing this subject
+              # recurse into  reference
+              (output['@reverse'] ||= {})[reverse_prop] ||= []
+              frame(state, [r_id], subframe, options.merge(parent: output['@reverse'][reverse_prop]))
             end
           end
+        end
 
-          # add output to parent
-          add_frame_output(parent, property, output)
+        # add output to parent
+        add_frame_output(parent, property, output)
 
-          # pop matching subject from circular ref-checking stack
-          state[:subjectStack].pop()
-        end
+        # pop matching subject from circular ref-checking stack
+        state[:subjectStack].pop()
       end
     end
 
@@ -151,35 +155,33 @@ module JSON::LD
     # @param [Array, Hash] input
     # @return [Array, Hash]
     def cleanup_preserve(input)
-      log_depth do
-        result = case input
-        when Array
-          # If, after replacement, an array contains only the value null remove the value, leaving an empty array.
-          input.map {|o| cleanup_preserve(o)}.compact
-        when Hash
-          output = Hash.new
-          input.each do |key, value|
-            if key == '@preserve'
-              # replace all key-value pairs where the key is @preserve with the value from the key-pair
-              output = cleanup_preserve(value)
-            else
-              v = cleanup_preserve(value)
+      result = case input
+      when Array
+        # If, after replacement, an array contains only the value null remove the value, leaving an empty array.
+        input.map {|o| cleanup_preserve(o)}.compact
+      when Hash
+        output = Hash.new
+        input.each do |key, value|
+          if key == '@preserve'
+            # replace all key-value pairs where the key is @preserve with the value from the key-pair
+            output = cleanup_preserve(value)
+          else
+            v = cleanup_preserve(value)
 
-              # Because we may have added a null value to an array, we need to clean that up, if we possible
-              v = v.first if v.is_a?(Array) && v.length == 1 &&
-                context.expand_iri(key) != "@graph" && context.container(key).nil?
-              output[key] = v
-            end
+            # Because we may have added a null value to an array, we need to clean that up, if we possible
+            v = v.first if v.is_a?(Array) && v.length == 1 &&
+              context.expand_iri(key) != "@graph" && context.container(key).nil?
+            output[key] = v
           end
-          output
-        when '@null'
-          # If the value from the key-pair is @null, replace the value with nul
-          nil
-        else
-          input
         end
-        result
+        output
+      when '@null'
+        # If the value from the key-pair is @null, replace the value with nul
+        nil
+      else
+        input
       end
+      result
     end
 
     private
@@ -206,13 +208,9 @@ module JSON::LD
     ##
     # Returns true if the given node matches the given frame.
     #
-    # Matches either based on explicit type inclusion where the node
-    # has any type listed in the frame. If the frame has empty types defined
-    # matches nodes not having a @type. If the frame has a type of {} defined
-    # matches nodes having any type defined.
+    # Matches either based on explicit type inclusion where the node has any type listed in the frame. If the frame has empty types defined matches nodes not having a @type. If the frame has a type of {} defined matches nodes having any type defined.
     #
-    # Otherwise, does duck typing, where the node must have all of the properties
-    # defined in the frame.
+    # Otherwise, does duck typing, where the node must have all of the properties defined in the frame.
     #
     # @param [Hash{String => Object}] subject the subject to check.
     # @param [Hash{String => Object}] frame the frame to check.
@@ -238,22 +236,21 @@ module JSON::LD
           case k
           when '@id'
             return false if v.is_a?(String) && subject['@id'] != v
-            wildcard, matches_some = true, true
+            wildcard, matches_some = false, true
           when '@type'
-            wildcard, matches_some = true, true
+            wildcard, matches_some = false, false
           when /^@/
           else
             wildcard = false
 
             # v == [] means do not match if property is present
             if subject.has_key?(k)
-              return false if v == []
+              return false if v == [] && !subject[k].nil?
               matches_some = true
               next
             end
 
-            # all properties must match to be a duck unless a @default is
-            # specified
+            # all properties must match to be a duck unless a @default is specified
             has_default = v.is_a?(Array) && v.length == 1 && v.first.is_a?(Hash) && v.first.has_key?('@default')
             return false if flags[:requireAll] && !has_default
           end
@@ -270,8 +267,7 @@ module JSON::LD
         frame.is_a?(Hash) || (frame.is_a?(Array) && frame.first.is_a?(Hash) && frame.length == 1)
     end
 
-    # Checks the current subject stack to see if embedding the given subject
-    # would cause a circular reference.
+    # Checks the current subject stack to see if embedding the given subject would cause a circular reference.
     # 
     # @param subject_to_embed the subject to embed.
     # @param subject_stack the current stack of subjects.
@@ -283,6 +279,7 @@ module JSON::LD
       end
     end
 
+    ##
     # Gets the frame flag value for the given flag name.
     # 
     # @param frame the frame.
@@ -336,17 +333,14 @@ module JSON::LD
 
       # recursively remove dependent dangling embeds
       def remove_dependents(id, embeds)
-
-        log_depth do
-          # get embed keys as a separate array to enable deleting keys in map
-          embeds.each do |id_dep, e|
-            p = e.fetch(:parent, {}) if e.is_a?(Hash)
-            next unless p.is_a?(Hash)
-            pid = p.fetch('@id', nil)
-            if pid == id
-              embeds.delete(id_dep)
-              remove_dependents(id_dep, embeds)
-            end
+        # get embed keys as a separate array to enable deleting keys in map
+        embeds.each do |id_dep, e|
+          p = e.fetch(:parent, {}) if e.is_a?(Hash)
+          next unless p.is_a?(Hash)
+          pid = p.fetch('@id', nil)
+          if pid == id
+            embeds.delete(id_dep)
+            remove_dependents(id_dep, embeds)
           end
         end
       end
@@ -369,10 +363,7 @@ module JSON::LD
       end
     end
 
-    # Creates an implicit frame when recursing through subject matches. If
-    # a frame doesn't have an explicit frame for a particular property, then
-    # a wildcard child frame will be created that uses the same flags that
-    # the parent frame used.
+    # Creates an implicit frame when recursing through subject matches. If a frame doesn't have an explicit frame for a particular property, then a wildcard child frame will be created that uses the same flags that the parent frame used.
     #
     # @param [Hash] flags the current framing flags.
     # @return [Array<Hash>] the implicit frame.