More framing updates for deep object patterns and value patterns.

Author: gkellogg

lib/json/ld/expand.rb

@@ -78,6 +78,7 @@ def expand(input, active_property, context, ordered: true)
               when String
                 context.expand_iri(value, documentRelative: true, log_depth: @options[:log_depth]).to_s
               when Array
+                # Framing allows an array of IRIs, and always puts values in an array
                 raise JsonLdError::InvalidIdValue,
                       "value of @id must be a string, array of string or hash if framing: #{value.inspect}" unless framing
                 context.expand_iri(value, documentRelative: true, log_depth: @options[:log_depth]).to_s
@@ -131,18 +132,43 @@ def expand(input, active_property, context, ordered: true)
               expand(value, '@graph', context, ordered: ordered)
             when '@value'
               # If expanded property is @value and value is not a scalar or null, an invalid value object value error has been detected and processing is aborted. Otherwise, set expanded value to value. If expanded value is null, set the @value member of result to null and continue with the next key from element. Null values need to be preserved in this case as the meaning of an @type member depends on the existence of an @value member.
-              raise JsonLdError::InvalidValueObjectValue,
-                    "Value of #{expanded_property} must be a scalar or null: #{value.inspect}" if value.is_a?(Hash) || value.is_a?(Array)
-              if value.nil?
+              # If framing, always use array form, unless null
+              case value
+              when String, TrueClass, FalseClass, Numeric then (framing ? [value] : value)
+              when nil
                 output_object['@value'] = nil
                 next;
+              when Array
+                raise JsonLdError::InvalidValueObjectValue,
+                      "@value value may not be an array unless framing: #{value.inspect}" unless framing
+                value
+              when Hash
+                raise JsonLdError::InvalidValueObjectValue,
+                      "@value value must be a an empty object for framing: #{value.inspect}" unless
+                      value.empty? && framing
+                [value]
+              else
+                raise JsonLdError::InvalidValueObjectValue,
+                      "Value of #{expanded_property} must be a scalar or null: #{value.inspect}"
               end
-              value
             when '@language'
               # If expanded property is @language and value is not a string, an invalid language-tagged string error has been detected and processing is aborted. Otherwise, set expanded value to lowercased value.
-              raise JsonLdError::InvalidLanguageTaggedString,
-                    "Value of #{expanded_property} must be a string: #{value.inspect}" unless value.is_a?(String)
-              value.downcase
+              # If framing, always use array form, unless null
+              case value
+              when String then (framing ? [value.downcase] : value.downcase)
+              when Array
+                raise JsonLdError::InvalidLanguageTaggedString,
+                      "@language value may not be an array unless framing: #{value.inspect}" unless framing
+                value.map(&:downcase)
+              when Hash
+                raise JsonLdError::InvalidLanguageTaggedString,
+                      "@language value must be a an empty object for framing: #{value.inspect}" unless
+                      value.empty? && framing
+                [value]
+              else
+                raise JsonLdError::InvalidLanguageTaggedString,
+                      "Value of #{expanded_property} must be a string: #{value.inspect}"
+              end
             when '@index'
               # If expanded property is @index and value is not a string, an invalid @index value error has been detected and processing is aborted. Otherwise, set expanded value to value.
               raise JsonLdError::InvalidIndexValue,
@@ -312,21 +338,22 @@ def expand(input, active_property, context, ordered: true)
             "value object has unknown keys: #{output_object.inspect}"
           end
 
-          output_object.delete('@language') if output_object['@language'].to_s.empty?
-          output_object.delete('@type') if output_object['@type'].to_s.empty?
+          output_object.delete('@language') if Array(output_object['@language']).join('').to_s.empty?
+          output_object.delete('@type') if Array(output_object['@type']).join('').to_s.empty?
 
           # If the value of result's @value key is null, then set result to null.
-          return nil if output_object['@value'].nil?
+          return nil if Array(output_object['@value']).empty?
 
-          if !output_object['@value'].is_a?(String) && output_object.has_key?('@language')
+          if !Array(output_object['@value']).all? {|v| v.is_a?(String) || v.is_a?(Hash) && v.empty?} && output_object.has_key?('@language')
             # Otherwise, if the value of result's @value member is not a string and result contains the key @language, an invalid language-tagged value error has been detected (only strings can be language-tagged) and processing is aborted.
             raise JsonLdError::InvalidLanguageTaggedValue,
-                  "when @language is used, @value must be a string: #{@value.inspect}"
-          elsif !output_object.fetch('@type', "").is_a?(String) ||
-                !context.expand_iri(output_object.fetch('@type', ""), vocab: true, log_depth: @options[:log_depth]).is_a?(RDF::URI)
+                  "when @language is used, @value must be a string: #{output_object.inspect}"
+          elsif !Array(output_object.fetch('@type', "")).all? {|t|
+                  t.is_a?(String) && context.expand_iri(t, vocab: true, log_depth: @options[:log_depth]).is_a?(RDF::URI) ||
+                  t.is_a?(Hash) && t.empty?}
             # Otherwise, if the result has a @type member and its value is not an IRI, an invalid typed value error has been detected and processing is aborted.
             raise JsonLdError::InvalidTypedValue,
-                  "value of @type must be an IRI: #{output_object['@type'].inspect}"
+                  "value of @type must be an IRI: #{output_object.inspect}"
           end
         elsif !output_object.fetch('@type', []).is_a?(Array)
           # Otherwise, if result contains the key @type and its associated value is not an array, set it to an array containing only the associated value.

lib/json/ld/frame.rb

@@ -43,11 +43,6 @@ def frame(state, subjects, frame, **options)
         state = state.merge(uniqueEmbeds: {}) if property.nil?
 
         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
@@ -90,6 +85,8 @@ def frame(state, subjects, frame, **options)
 
           # add objects
           objects.each do |o|
+            subframe = Array(frame[prop]).first || create_implicit_frame(flags)
+
             case
             when list?(o)
               # add empty list
@@ -99,19 +96,16 @@ def frame(state, subjects, frame, **options)
               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
               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
+            when value_match?(subframe, o)
+              # Include values if they match
               add_frame_output(output, prop, o.dup)
             end
           end
@@ -191,7 +185,7 @@ def cleanup_preserve(input)
     #
     # @param [Hash{Symbol => Object}] state
     #   Current framing state
-    # @param [Hash{String => Hash}] subjects
+    # @param [Array<String>] subjects
     #   The subjects to filter
     # @param [Hash{String => Object}] frame
     # @param [Hash{Symbol => String}] flags the frame flags.
@@ -219,65 +213,77 @@ def filter_subjects(state, subjects, frame, flags)
     #
     # @return [Boolean] true if the node matches, false if not.
     def filter_subject(subject, frame, state, flags)
-      types = frame.fetch('@type', [])
-      subject_types = subject.fetch('@type', [])
-      ids = frame.fetch('@id', [])
-      subject_ids = subject.fetch('@id', [])
-      subject_ids = [subject_ids] unless subject_ids.is_a?(Array)
-
-      # Match on specific @id.
-      return !(ids & subject_ids).empty? if !ids.empty? && ids != [{}]
-
-      # Match on specific @type
-      return !(types & subject_types).empty? if !types.empty? && types != [{}]
-
-      # Match on wildcard @type
-      return true if types == [{}] && !subject_types.empty?
-
-      # Don't Match on no @type
-      return false if frame['@type'] == [] && !subject_types.empty?
-
       # Duck typing, for nodes not having a type, but having @id
       wildcard, matches_some = true, false
 
-      frame.reject {|k| k.start_with?('@')}.each do |k, v|
-        is_empty = v.empty?
-        if v = v.first
-          validate_frame(v)
-          has_default = v.has_key?('@default')
-          # Exclude framing keywords
-          v = v.dup.delete_if {|kk,vv| %w(@default @embed @explicit @omitDefault @requireAll).include?(kk)}
-        end
-
+      frame.each do |k, v|
         node_values = subject.fetch(k, [])
 
-        # No longer a wildcard pattern if frame has any non-keyword properties
-        wildcard = false
+        case k
+        when '@id'
+          ids = v || []
+
+          # Match on specific @id.
+          return ids.include?(subject['@id']) if !ids.empty? && ids != [{}]
+          match_this = true
+        when '@type'
+          # No longer a wildcard pattern
+          wildcard = false
+
+          match_this = case v
+          when []
+            # Don't Match on no @type
+            return false if !node_values.empty?
+            true
+          when [{}]
+            # Match on wildcard @type
+            !node_values.empty?
+          else
+            # Match on specific @type
+            return !(v & node_values).empty?
+            false
+          end
+        when /@/
+          # Skip other keywords
+          next
+        else
+          is_empty = v.empty?
+          if v = v.first
+            validate_frame(v)
+            has_default = v.has_key?('@default')
+            # Exclude framing keywords
+            v = v.dup.delete_if {|kk,vv| %w(@default @embed @explicit @omitDefault @requireAll).include?(kk)}
+          end
 
-        # Skip, but allow match if node has no value for property, and frame has a default value
-        next if node_values.empty? && has_default
 
-        # If frame value is empty, don't match if subject has any value
-        return false if !node_values.empty? && is_empty
+          # No longer a wildcard pattern if frame has any non-keyword properties
+          wildcard = false
 
-        match_this = case v
-        when nil
-          # node does not match if values is not empty and the value of property in frame is match none.
-          return false unless node_values.empty?
-          true
-        when {}
-          # node matches if values is not empty and the value of property in frame is wildcard
-          !node_values.empty?
-        else
-          if value?(v)
-            # Match on any matching value
-            node_values.any? {|nv| value_match?(v, nv)}
-          elsif node?(v) || node_reference?(v)
-            node_values.any? do |nv|
-              node_match?(v, nv, state, flags)
-            end
+          # Skip, but allow match if node has no value for property, and frame has a default value
+          next if node_values.empty? && has_default
+
+          # If frame value is empty, don't match if subject has any value
+          return false if !node_values.empty? && is_empty
+
+          match_this = case v
+          when nil
+            # node does not match if values is not empty and the value of property in frame is match none.
+            return false unless node_values.empty?
+            true
+          when {}
+            # node matches if values is not empty and the value of property in frame is wildcard
+            !node_values.empty?
           else
-            false # No matching on non-value or node values
+            if value?(v)
+              # Match on any matching value
+              node_values.any? {|nv| value_match?(v, nv)}
+            elsif node?(v) || node_reference?(v)
+              node_values.any? do |nv|
+                node_match?(v, nv, state, flags)
+              end
+            else
+              false # No matching on non-value or node values
+            end
           end
         end
 
@@ -398,7 +404,7 @@ def add_frame_output(parent, property, output)
     # @param [Hash] flags the current framing flags.
     # @return [Array<Hash>] the implicit frame.
     def create_implicit_frame(flags)
-      [flags.keys.inject({}) {|memo, key| memo["@#{key}"] = [flags[key]]; memo}]
+      flags.keys.inject({}) {|memo, key| memo["@#{key}"] = [flags[key]]; memo}
     end
 
   private
@@ -411,15 +417,17 @@ def node_match?(pattern, value, state, flags)
 
     # Value matches if it is a value, and matches the value pattern.
     #
+    # * `pattern` is empty
     # * @values are the same, or `pattern[@value]` is a wildcard, and
     # * @types are the same or `value[@type]` is not null and `pattern[@type]` is `{}`, or `value[@type]` is null and `pattern[@type]` is null or `[]`, and
     # * @languages are the same or `value[@language]` is not null and `pattern[@language]` is `{}`, or `value[@language]` is null and `pattern[@language]` is null or `[]`.
     def value_match?(pattern, value)
       v1, t1, l1 = value['@value'], value['@type'], value['@language']
-      v2, t2, l2 = pattern['@value'], pattern['@type'], pattern['@language']
-      return false unless v1 == v2 || v1 && v2 == {}
-      return false unless t1 == t2 || t1 && t2 == {} || t1.nil? && (t2 || []) == []
-      return false unless l1 == l2 || l1 && l2 == {} || l1.nil? && (l2 || []) == []
+      v2, t2, l2 = Array(pattern['@value']), Array(pattern['@type']), Array(pattern['@language'])
+      return true if (v2 + t2 + l2).empty?
+      return false unless v2.include?(v1) || v2 == [{}]
+      return false unless t2.include?(t1) || t1 && t2 == [{}] || t1.nil? && (t2 || []) == []
+      return false unless l2.include?(l1) || l1 && l2 == [{}] || l1.nil? && (l2 || []) == []
       true
     end
   end