Partial update for frame matching.

gkellogg · gkellogg · commit 4fa248dc30da · 2016-11-05T18:31:11.000-07:00
diff --git a/lib/json/ld/expand.rb b/lib/json/ld/expand.rb
@@ -14,7 +14,6 @@ module Expand
     # @param [Context] context
     # @param [Boolean] ordered (true)
     #   Ensure output objects have keys ordered properly
-    # @param [Boolean] framing (false)
     # @param [Hash{Symbol => Object}] options
     #   See {JSON::LD::API.expand}
     # @return [Array<Hash{String => Object}>]
@@ -75,18 +74,36 @@ def expand(input, active_property, context, ordered: true)
             expanded_value = case expanded_property
             when '@id'
               # If expanded property is @id and value is not a string, an invalid @id value error has been detected and processing is aborted
-              case value
+              e_id = case value
               when String
+                context.expand_iri(value, documentRelative: true, log_depth: @options[:log_depth]).to_s
+              when 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
+                value.map do |v|
+                  raise JsonLdError::InvalidTypeValue,
+                        "@id value must be a string or array of strings for framing: #{v.inspect}" unless v.is_a?(String)
+                  context.expand_iri(v, documentRelative: true, quiet: true, log_depth: @options[:log_depth]).to_s
+                end
               when Hash
                 raise JsonLdError::InvalidIdValue,
                       "value of @id must be a string unless framing: #{value.inspect}" unless framing
+                raise JsonLdError::InvalidTypeValue,
+                      "value of @id must be a an empty object for framing: #{value.inspect}" unless
+                      value.empty? && framing
+                [{}]
               else
                 raise JsonLdError::InvalidIdValue,
                       "value of @id must be a string or hash if framing: #{value.inspect}"
               end
 
-              # Otherwise, set expanded value to the result of using the IRI Expansion algorithm, passing active context, value, and true for document relative.
-              context.expand_iri(value, documentRelative: true, log_depth: @options[:log_depth]).to_s
+              # Use array form if framing
+              if framing && !e_id.is_a?(Array)
+                [e_id]
+              else
+                e_id
+              end
             when '@type'
               # If expanded property is @type and value is neither a string nor an array of strings, an invalid type value error has been detected and processing is aborted. Otherwise, set expanded value to the result of using the IRI Expansion algorithm, passing active context, true for vocab, and true for document relative to expand the value or each of its items.
               #log_debug("@type") {"value: #{value.inspect}"}
@@ -103,7 +120,8 @@ def expand(input, active_property, context, ordered: true)
                 # For framing
                 raise JsonLdError::InvalidTypeValue,
                       "@type value must be a an empty object for framing: #{value.inspect}" unless
-                      value.empty?
+                      value.empty? && framing
+                [{}]
               else
                 raise JsonLdError::InvalidTypeValue,
                       "@type value must be a string or array of strings: #{value.inspect}"
diff --git a/lib/json/ld/frame.rb b/lib/json/ld/frame.rb
@@ -21,7 +21,7 @@ module Frame
     def frame(state, subjects, frame, **options)
       parent, property = options[:parent], options[:property]
       # Validate the frame
-      validate_frame(state, frame)
+      validate_frame(frame)
       frame = frame.first if frame.is_a?(Array)
 
       # Get values for embedOn and explicitOn
@@ -200,7 +200,7 @@ def cleanup_preserve(input)
     def filter_subjects(state, subjects, frame, flags)
       subjects.inject({}) do |memo, id|
         subject = state[:subjects][id]
-        memo[id] = subject if filter_subject(subject, frame, flags)
+        memo[id] = subject if filter_subject(subject, frame, state, flags)
         memo
       end
     end
@@ -214,55 +214,84 @@ def filter_subjects(state, subjects, frame, flags)
     #
     # @param [Hash{String => Object}] subject the subject to check.
     # @param [Hash{String => Object}] frame the frame to check.
+    # @param [Hash{Symbol => Object}] state Current framing state
     # @param [Hash{Symbol => Object}] flags the frame flags.
     #
     # @return [Boolean] true if the node matches, false if not.
-    def filter_subject(subject, frame, flags)
+    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)
 
-      # check @type (object value means 'any' type, fall through to ducktyping)
-      if !types.empty? && types != [{}]
-        # A subject must match if node has a @type property including any IRI from the corresponding @type property in frame.
-        return types.any? {|t| subject_types.include?(t)}
-      elsif types == [{}]
-        # Otherwise, a subject must match if node has a @type property and frame has a @type property containing only an empty dictionary.
-        return !subject_types.empty?
-      else
-        # Duck typing, for nodes not having a type, but having @id
-        wildcard, matches_some = true, false
-
-        frame.each do |k, v|
-          case k
-          when '@id'
-            return false if v.is_a?(String) && subject['@id'] != v
-            wildcard, matches_some = false, true
-          when '@type'
-            wildcard, matches_some = false, false
-          when /^@/
-          else
-            wildcard = false
-
-            if subject.has_key?(k)
-              matches_some = true
-              next
-            elsif v == []
-              # v == [] means do not match if property is present
-              return false
-            end
+      # 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
 
-            # 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
+        node_values = subject.fetch(k, [])
+
+        # No longer a wildcard pattern if frame has any non-keyword properties
+        wildcard = false
+
+        # 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
+          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
 
-        # return true if wildcard or subject matches some properties
-        wildcard || matches_some
+        # All non-defaulted values must match if @requireAll is set
+        return false if !match_this && flags[:requireAll]
+
+        matches_some ||= match_this
       end
+
+      # return true if wildcard or subject matches some properties
+      wildcard || matches_some
     end
 
-    def validate_frame(state, frame)
+    def validate_frame(frame)
       raise InvalidFrame::Syntax,
             "Invalid JSON-LD syntax; a JSON-LD frame must be an object: #{frame.inspect}" unless
         frame.is_a?(Hash) || (frame.is_a?(Array) && frame.first.is_a?(Hash) && frame.length == 1)
@@ -371,5 +400,27 @@ def add_frame_output(parent, property, output)
     def create_implicit_frame(flags)
       [flags.keys.inject({}) {|memo, key| memo["@#{key}"] = [flags[key]]; memo}]
     end
+
+  private
+    # Node matches if it is a node, and matches the pattern as a frame
+    def node_match?(pattern, value, state, flags)
+      return false unless value['@id']
+      node_object = state[:subjects][value['@id']]
+      node_object && filter_subject(node_object, pattern, state, flags)
+    end
+
+    # Value matches if it is a value, and matches the value pattern.
+    #
+    # * @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 || []) == []
+      true
+    end
   end
 end
diff --git a/spec/frame_spec.rb b/spec/frame_spec.rb
@@ -7,7 +7,7 @@
 
   describe ".frame" do
     {
-      "A subject must match if node has a @type property including any IRI from the corresponding @type property in frame" => {
+      "exact @type match" => {
         frame: %({
           "@context": {"ex": "http://example.org/"},
           "@type": "ex:Type1"
@@ -31,7 +31,7 @@
           }]
         })
       },
-      "A subject must match if node has a @type any property and frame has a @type property containing only an empty JSON object" => {
+      "wildcard type match" => {
         frame: %({
           "@context": {"ex": "http://example.org/"},
           "@type": {}
@@ -58,7 +58,7 @@
           }]
         })
       },
-      "A subject must match if node and frame both have the same @id property" => {
+      "@id match" => {
         frame: %({
           "@context": {"ex": "http://example.org/"},
           "@id": "ex:Sub1"
@@ -82,7 +82,7 @@
           }]
         })
       },
-      "A subject must not match if node has a property where frame has an empty array for that same property" => {
+      "wildcard with empty property no-match" => {
         frame: %({
           "@context": {"ex": "http://example.org/"},
           "ex:p": [],
@@ -103,8 +103,8 @@
         output: %({
           "@context": {"ex": "http://example.org/"},
           "@graph": [{
-            "@id": "ex:Sub2",
-            "ex:p": "foo",
+            "@id": "ex:Sub1",
+            "ex:p": null,
             "ex:q": "bar"
           }]
         })
