json-ld 2.2.1 → 3.0.0

data/lib/json/ld/extensions.rb

@@ -7,27 +7,42 @@ module RDF
       Node.new(id + value.to_s)
     end
   end
-end
 
-class Array
-  # Sort values, but impose special keyword ordering
-  # @yield a, b
-  # @yieldparam [Object] a
-  # @yieldparam [Object] b
-  # @yieldreturn [Integer]
-  # @return [Array]
-  KW_ORDER = %w(@base @id @value @type @language @vocab @container @graph @list @set @index).freeze
-  KW_ORDER_CACHE = KW_ORDER.each_with_object({}) do |kw, memo|
-    memo[kw] = "@#{KW_ORDER.index(kw)}"
-  end.freeze
+  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)
+    end
+  end
 
-  # Order, considering keywords to come before other strings
-  def kw_sort
-    self.sort do |a, b|
-      KW_ORDER_CACHE.fetch(a, a) <=> KW_ORDER_CACHE.fetch(b, b)
+  class URI 
+    # Validate extended RDF
+    def valid_extended?
+      self.valid?
     end
   end
 
+  class Node 
+    # Validate extended RDF
+    def valid_extended?
+      self.valid?
+    end
+  end
+
+  class Literal 
+    # Validate extended RDF
+    def valid_extended?
+      return false if language? && language.to_s !~ /^[a-zA-Z]+(-[a-zA-Z0-9]+)*$/
+      return false if datatype? && datatype.invalid?
+      value.is_a?(String)
+    end
+  end
+end
+
+class Array
   # Order terms, length first, then lexographically
   def term_sort
     self.sort do |a, b|

data/lib/json/ld/flatten.rb

@@ -7,111 +7,120 @@ 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.
     #
-    # @param [Array, Hash] input
+    # @param [Array, Hash] element
     #   Expanded JSON-LD input
-    # @param [Hash] graphs A map of graph name to subjects
-    # @param [String] graph
+    # @param [Hash] graph_map A map of graph name to subjects
+    # @param [String] active_graph
     #   The name of the currently active graph that the processor should use when processing.
-    # @param [String] name
-    #   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_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
+    # @param [String] active_subject (nil)
+    #   Node identifier
+    # @param [String] active_property (nil)
+    #   Property within current node
+    # @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,
+                        list: nil)
+      log_debug("node_map") {"active_graph: #{active_graph}, element: #{element.inspect}, active_subject: #{active_subject}"}
+      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.
+        element.map do |o|
+          create_node_map(o, graph_map,
+                          active_graph: active_graph,
+                          active_subject: active_subject,
+                          active_property: active_property,
+                          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]
 
-          # spec requires @type to be named first, so assign names early
-          Array(type).each {|t| namer.get_name(t) if blank_node?(t)}
+        # Transform BNode types
+        if element.has_key?('@type')
+          element['@type'] = Array(element['@type']).map {|t| blank_node?(t) ? namer.get_name(t) : t}
+        end
 
-          # get name for subject
-          if name.nil?
-            name ||= input['@id']
-            name = namer.get_name(name) if blank_node?(name)
+        if value?(element)
+          element['@type'] = element['@type'].first if element ['@type']
+          if list.nil?
+            add_value(subject_node, active_property, element, property_is_array: true, allow_duplicate: false)
+          else
+            list['@list'] << element
           end
+        elsif list?(element)
+          result = {'@list' => []}
+          create_node_map(element['@list'], graph_map,
+                          active_graph: active_graph,
+                          active_subject: active_subject,
+                          active_property: active_property,
+                          list: result)
+          if list.nil?
+            add_value(subject_node, active_property, result, property_is_array: true)
+          else
+            list['@list'] << result
+          end
+        else
+          # Element is a node object
+          id = element.delete('@id')
+          id = namer.get_name(id) if blank_node?(id)
 
-          # add subject reference to list
-          list << {'@id' => name} if list
-
-          # create new subject or merge into existing one
-          subject = (graphs[graph] ||= {})[name] ||= {'@id' => name}
+          node = graph[id] ||= {'@id' => id}
 
-          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
-              end
-            when '@graph'
-              graphs[name] ||= {}
-              create_node_map(objects, graphs, graph: name)
-            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
+          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}
+            if list.nil?
+              add_value(subject_node, active_property, reference, property_is_array: true, allow_duplicate: false)
             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?
+              list['@list'] << reference
+            end
+          end
 
-              objects.each do |o|
-                o = namer.get_name(o) if property == '@type' && blank_node?(o)
+          if element.has_key?('@type')
+            add_value(node, '@type', element.delete('@type'), property_is_array: true, allow_duplicate: false)
+          end
 
-                case
-                when node?(o) || node_reference?(o)
-                  id = o['@id']
-                  id = namer.get_name(id) if blank_node?(id)
+          if element['@index']
+            raise JsonLdError::ConflictingIndexes,
+                  "Element already has index #{node['@index']} dfferent from #{element['@index']}" if
+                  node.key?('@index') && node['@index'] != element['@index']
+            node['@index'] = element.delete('@index')
+          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
+          if element['@reverse']
+            referenced_node, reverse_map = {'@id' => id}, element.delete('@reverse')
+            reverse_map.each do |property, values|
+              values.each do |value|
+                create_node_map(value, graph_map,
+                                active_graph: active_graph,
+                                active_subject: referenced_node,
+                                active_property: property)
               end
             end
           end
+
+          if element['@graph']
+            create_node_map(element.delete('@graph'), graph_map,
+                            active_graph: id)
+          end
+
+          element.keys.sort.each do |property|
+            value = element[property]
+
+            property = namer.get_name(property) if blank_node?(property)
+            node[property] ||= []
+            create_node_map(value, graph_map,
+                            active_graph: active_graph,
+                            active_subject: id,
+                            active_property: property)
+          end
         end
-      else
-        # add non-object to list
-        list << input if list
       end
     end
 

data/lib/json/ld/format.rb

@@ -63,12 +63,12 @@ module JSON::LD
                 # If files are empty, either use options[:execute]
                 input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
                 input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
-                JSON::LD::API.expand(input, options.merge(validate: false)) do |expanded|
+                JSON::LD::API.expand(input, validate: false, **options) do |expanded|
                   out.puts expanded.to_json(JSON::LD::JSON_STATE)
                 end
               else
                 files.each do |file|
-                  JSON::LD::API.expand(file, options.merge(validate: false)) do |expanded|
+                  JSON::LD::API.expand(file, validate: false, **options) do |expanded|
                     out.puts expanded.to_json(JSON::LD::JSON_STATE)
                   end
                 end

data/lib/json/ld/frame.rb

@@ -20,13 +20,12 @@ module JSON::LD
     # @option options [String] :property (nil)
     #   The parent property.
     # @raise [JSON::LD::InvalidFrame]
-    def frame(state, subjects, frame, **options)
-      log_depth do
-      log_debug("frame") {"subjects: #{subjects.inspect}"}
-      log_debug("frame") {"frame: #{frame.to_json(JSON_STATE)}"}
-      log_debug("frame") {"property: #{options[:property].inspect}"}
+    def frame(state, subjects, frame, parent: nil, property: nil, **options)
+      #log_depth do
+      #log_debug("frame") {"subjects: #{subjects.inspect}"}
+      #log_debug("frame") {"frame: #{frame.to_json(JSON_STATE)}"}
+      #log_debug("frame") {"property: #{property.inspect}"}
 
-      parent, property = options[:parent], options[:property]
       # Validate the frame
       validate_frame(frame)
       frame = frame.first if frame.is_a?(Array)
@@ -46,10 +45,10 @@ module JSON::LD
       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|
+      matches.keys.sort.each do |id|
         subject = matches[id]
 
-        # 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.
+        # Note: In order to treat each top-level match as a compartmentalized result, clear the unique embedded subjects map when the property is nil, which only occurs at the top-level.
         if property.nil?
           state[:uniqueEmbeds] = {state[:graph] => {}}
         else
@@ -105,13 +104,13 @@ module JSON::LD
           if recurse
             state[:graphStack].push(state[:graph])
             state[:graph] = id
-            frame(state, state[:graphMap][id].keys, [subframe], options.merge(parent: output, property: '@graph'))
+            frame(state, state[:graphMap][id].keys, [subframe], parent: output, property: '@graph', **options)
             state[:graph] = state[:graphStack].pop
           end
         end
 
         # iterate over subject properties in order
-        subject.keys.kw_sort.each do |prop|
+        subject.keys.sort.each do |prop|
           objects = subject[prop]
 
           # copy keywords to output
@@ -138,14 +137,14 @@ module JSON::LD
               src = o['@list']
               src.each do |oo|
                 if node_reference?(oo)
-                  frame(state, [oo['@id']], subframe, options.merge(parent: list, property: '@list'))
+                  frame(state, [oo['@id']], subframe, parent: list, property: '@list', **options)
                 else
                   add_frame_output(list, '@list', oo.dup)
                 end
               end
             when node_reference?(o)
               # recurse into subject reference
-              frame(state, [o['@id']], subframe, options.merge(parent: output, property: prop))
+              frame(state, [o['@id']], subframe, parent: output, property: prop, **options)
             when value_match?(subframe, o)
               # Include values if they match
               add_frame_output(output, prop, o.dup)
@@ -154,15 +153,14 @@ module JSON::LD
         end
 
         # handle defaults in order
-        frame.keys.kw_sort.each do |prop|
+        frame.keys.sort.each do |prop|
           next if prop.start_with?('@')
 
           # 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)
+            preserve = as_array(n.fetch('@default', '@null').dup)
             output[prop] = [{'@preserve' => preserve}]
           end
         end
@@ -174,7 +172,7 @@ module JSON::LD
               # 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]))
+              frame(state, [r_id], subframe, parent: output['@reverse'][reverse_prop], property: property, **options)
             end
           end
         end
@@ -185,7 +183,7 @@ module JSON::LD
         # pop matching subject from circular ref-checking stack
         state[:subjectStack].pop()
       end
-      end
+      #end
     end
 
     ##
@@ -213,19 +211,45 @@ module JSON::LD
       end
     end
 
+    ##
+    # Prune BNode identifiers recursively
+    #
+    # @param [Array, Hash] input
+    # @param [Array<String>] bnodes_to_clear
+    # @return [Array, Hash]
+    def prune_bnodes(input, bnodes_to_clear)
+      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| prune_bnodes(o, bnodes_to_clear)}.compact
+      when Hash
+        output = Hash.new
+        input.each do |key, value|
+          if context.expand_iri(key) == '@id' && bnodes_to_clear.include?(value)
+            # Don't add this to output, as it is pruned as being superfluous
+          else
+            output[key] = prune_bnodes(value, bnodes_to_clear)
+          end
+        end
+        output
+      else
+        input
+      end
+      result
+    end
+
     ##
     # Replace @preserve keys with the values, also replace @null with null.
     #
     # Optionally, remove BNode identifiers only used once.
     #
     # @param [Array, Hash] input
-    # @param [Array<String>] bnodes_to_clear
     # @return [Array, Hash]
-    def cleanup_preserve(input, bnodes_to_clear)
+    def cleanup_preserve(input)
       result = case input
       when Array
         # If, after replacement, an array contains only the value null remove the value, leaving an empty array.
-        v = input.map {|o| cleanup_preserve(o, bnodes_to_clear)}.compact
+        v = input.map {|o| cleanup_preserve(o)}.compact
 
         # If the array contains a single member, which is itself an array, use that value as the result
         (v.length == 1 && v.first.is_a?(Array)) ? v.first : v
@@ -234,11 +258,9 @@ module JSON::LD
         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, bnodes_to_clear)
-          elsif context.expand_iri(key) == '@id' && bnodes_to_clear.include?(value)
-            # Don't add this to output, as it is pruned as being superfluous
+            output = cleanup_preserve(value)
           else
-            v = cleanup_preserve(value, bnodes_to_clear)
+            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.as_array?(key)
@@ -275,8 +297,6 @@ module JSON::LD
       end
     end
 
-    EXCLUDED_FRAMING_KEYWORDS = Set.new(%w(@default @embed @explicit @omitDefault @requireAll)).freeze
-
     ##
     # Returns true if the given node matches the given frame.
     #
@@ -319,7 +339,6 @@ module JSON::LD
           else
             # Match on specific @type
             return !(v & node_values).empty?
-            false
           end
         when /@/
           # Skip other keywords
@@ -329,8 +348,6 @@ module JSON::LD
           if v = v.first
             validate_frame(v)
             has_default = v.has_key?('@default')
-            # Exclude framing keywords
-            v = v.reject {|kk,vv| EXCLUDED_FRAMING_KEYWORDS.include?(kk)}
           end
 
 
@@ -348,7 +365,7 @@ module JSON::LD
             # 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 {}
+          when Hash # Empty other than framing keywords
             # node matches if values is not empty and the value of property in frame is wildcard
             !node_values.empty?
           else