json-ld 0.3.2 → 0.9.0

data/lib/json/ld/expand.rb

@@ -47,117 +47,194 @@ module JSON::LD
         depth do
           output_object = Hash.ordered
           # Then, proceed and process each property and value in element as follows:
-          input.each do |key, value|
-            # Remove property from element expand property according to the steps outlined in IRI Expansion
-            property = context.expand_iri(key, :position => :predicate, :quiet => true)
-
-            # Set active property to the original un-expanded property if property if not a keyword
-            active_property = key unless key[0,1] == '@'
-            debug("expand property") {"#{active_property.inspect}, expanded: #{property}, value: #{value.inspect}"}
-          
-            # If property does not expand to a keyword or absolute IRI, remove property from element
-            # and continue to the next property from element
-            if property.nil?
-              debug(" => ") {"skip nil key"}
+          input.keys.kw_sort.each do |property|
+            value = input[property]
+            expanded_property = context.expand_iri(property, :position => :predicate, :quiet => true, :namer => namer)
+
+            if expanded_property.is_a?(Array)
+              # If expanded property is an array, remove every element which is not a absolute IRI.
+              expanded_property = expanded_property.map {|p| p.to_s if p && p.uri? && p.absolute? || p.node?}.compact
+              expanded_property = nil if expanded_property.empty?
+            elsif expanded_property.is_a?(RDF::Resource)
+              expanded_property = expanded_property.to_s
+            end
+
+            debug("expand property") {"ap: #{active_property.inspect}, expanded: #{expanded_property.inspect}, value: #{value.inspect}"}
+
+            # If expanded property is an empty array, or null, continue with the next property from element
+            if expanded_property.nil?
+              debug(" => ") {"skip nil property"}
               next
             end
-            property = property.to_s
-
-            expanded_value = case property
-            when '@id'
-              # If the property is @id the value must be a string. Expand the value according to IRI Expansion.
-              context.expand_iri(value, :position => :subject, :quiet => true).to_s
-            when '@type'
-              # Otherwise, if the property is @type the value must be a string, an array of strings
-              # or an empty JSON Object.
-              # Expand value or each of it's entries according to IRI Expansion
-              debug("@type") {"value: #{value.inspect}"}
-              case value
-              when Array
-                depth do
-                  [value].flatten.map do |v|
-                    v = v['@id'] if node_reference?(v)
-                    raise ProcessingError, "Object value must be a string or a node reference: #{v.inspect}" unless v.is_a?(String)
-                    context.expand_iri(v, options.merge(:position => :property, :quiet => true)).to_s
+            expanded_property
+
+            if expanded_property.is_a?(String) && expanded_property[0,1] == '@'
+              expanded_value = case expanded_property
+              when '@id'
+                # If expanded property is @id, value must be a string. Set the @id member in result to the result of expanding value according the IRI Expansion algorithm relative to the document base and re-labeling Blank Nodes.
+                context.expand_iri(value, :position => :subject, :quiet => true, :namer => namer).to_s
+              when '@type'
+                # If expanded property is @type, value must be a string or array of strings. Set the @type member of result to the result of expanding value according the IRI Expansion algorithm relative to the document base and re-labeling Blank Nodes, unless that result is an empty array.
+                debug("@type") {"value: #{value.inspect}"}
+                case value
+                when Array
+                  depth do
+                    [value].flatten.map do |v|
+                      v = v['@id'] if node_reference?(v)
+                      raise ProcessingError, "Object value must be a string or a node reference: #{v.inspect}" unless v.is_a?(String)
+                      context.expand_iri(v, options.merge(:position => :subject, :quiet => true, :namer => namer)).to_s
+                    end
+                  end
+                when Hash
+                  # Empty object used for @type wildcard or node reference
+                  if node_reference?(value)
+                    context.expand_iri(value['@id'], options.merge(:position => :property, :quiet => true, :namer => namer)).to_s
+                  elsif !value.empty?
+                    raise ProcessingError, "Object value of @type must be empty or a node reference: #{value.inspect}"
+                  else
+                    value
                   end
-                end
-              when Hash
-                # Empty object used for @type wildcard or node reference
-                if node_reference?(value)
-                  context.expand_iri(value['@id'], options.merge(:position => :property, :quiet => true)).to_s
-                elsif !value.empty?
-                  raise ProcessingError, "Object value of @type must be empty or a node reference: #{value.inspect}"
                 else
-                  value
+                  context.expand_iri(value, options.merge(:position => :property, :quiet => true, :namer => namer)).to_s
+                end
+              when '@value'
+                # If expanded property is @value, value must be a scalar or null. Set the @value member of result to value.
+                raise ProcessingError::Lossy, "Value of #{expanded_property} must be a string, was #{value.inspect}" if value.is_a?(Hash) || value.is_a?(Array)
+                value
+              when '@language'
+                # If expanded property is @language, value must be a string with the lexical form described in [BCP47] or null. Set the @language member of result to the lowercased value.
+                raise ProcessingError::Lossy, "Value of #{expanded_property} must be a string, was #{value.inspect}" if value.is_a?(Hash) || value.is_a?(Array)
+                value.to_s.downcase
+              when '@annotation'
+                # If expanded property is @annotation value must be a string. Set the @annotation member of result to value.
+                value = value.first if value.is_a?(Array) && value.length == 1
+                raise ProcessingError, "Value of @annotation is not a string: #{value.inspect}" unless value.is_a?(String)
+                value.to_s
+              when '@list', '@set', '@graph'
+                # If expanded property is @set, @list, or @graph, set the expanded property member of result to the result of expanding value by recursively using this algorithm, along with the active context and active property. If expanded property is @list and active property is null or @graph, pass @list as active property instead.
+                value = [value] unless value.is_a?(Array)
+                ap = expanded_property == '@list' && ((active_property || '@graph') == '@graph') ? '@list' : active_property
+                value = depth { expand(value, ap, context, options) }
+
+                # If expanded property is @list, and any expanded value
+                # is an object containing an @list property, throw an exception, as lists of lists are not supported
+                if expanded_property == '@list' && value.any? {|v| v.is_a?(Hash) && v.has_key?('@list')}
+                  raise ProcessingError::ListOfLists, "A list may not contain another list"
                 end
+
+                value
               else
-                context.expand_iri(value, options.merge(:position => :property, :quiet => true)).to_s
+                # Skip unknown keyword
+                next
               end
-            when '@value', '@language'
-              # Otherwise, if the property is @value or @language the value must not be a JSON object or an array.
-              raise ProcessingError::Lossy, "Value of #{property} must be a string, was #{value.inspect}" if value.is_a?(Hash) || value.is_a?(Array)
-              value
-            when '@list', '@set', '@graph'
-              # Otherwise, if the property is @list, @set, or @graph, expand value recursively
-              # using this algorithm, passing copies of the active context and active property.
-              # If the expanded value is not an array, convert it to an array.
-              value = [value] unless value.is_a?(Array)
-              value = depth { expand(value, active_property, context, options) }
-
-              # If property is @list, and any expanded value
-              # is an object containing an @list property, throw an exception, as lists of lists are not supported
-              if property == '@list' && value.any? {|v| v.is_a?(Hash) && v.has_key?('@list')}
-                raise ProcessingError::ListOfLists, "A list may not contain another list"
+
+              debug("expand #{expanded_property}") { expanded_value.inspect}
+              output_object[expanded_property] = expanded_value
+              next
+            end
+
+            expanded_value = if context.container(property) == '@language' && value.is_a?(Hash)
+              # Otherwise, if value is a JSON object and property is not a keyword and its associated term entry in the active context has a @container key associated with a value of @language, process the associated value as a language map:
+              
+              # Set multilingual array to an empty array.
+              language_map_values = []
+
+              # For each key-value in the language map:
+              value.keys.sort.each do |k|
+                [value[k]].flatten.each do |v|
+                  # Create a new JSON Object, referred to as an expanded language object.
+                  expanded_language_object = Hash.new
+
+                  # Add a key-value pair to the expanded language object where the key is @value and the value is the value associated with the key in the language map.
+                  raise ProcessingError::LanguageMap, "Expected #{vv.inspect} to be a string" unless v.is_a?(String)
+                  expanded_language_object['@value'] = v
+
+                  # Add a key-value pair to the expanded language object where the key is @language, and the value is the key in the language map, transformed to lowercase.
+                  # FIXME: check for BCP47 conformance
+                  expanded_language_object['@language'] = k.downcase
+                  # Append the expanded language object to the multilingual array.
+                  language_map_values << expanded_language_object
+                end
               end
+              # Set the value associated with property to the multilingual array.
+              language_map_values
+            elsif context.container(property) == '@annotation' && value.is_a?(Hash)
+              # Otherwise, if value is a JSON object and property is not a keyword and its associated term entry in the active context has a @container key associated with a value of @annotation, process the associated value as a annotation:
+              
+              # Set ary to an empty array.
+              annotation_map_values = []
 
-              value
+              # For each key-value in the object:
+              value.keys.sort.each do |k|
+                [value[k]].flatten.each do |v|
+                  # Expand the value, adding an '@annotation' key with value equal to the key
+                  expanded_value = depth { expand(v, property, context, options) }
+                  next unless expanded_value
+                  expanded_value['@annotation'] ||= k
+                  annotation_map_values << expanded_value
+                end
+              end
+              # Set the value associated with property to the multilingual array.
+              annotation_map_values
             else
-              # Otherwise, expand value recursively using this algorithm, passing copies of the active context and active property.
-              depth { expand(value, active_property, context, options) }
+              # Otherwise, expand value by recursively using this algorithm, passing copies of the active context and property as active property.
+              depth { expand(value, property, context, options) }
             end
 
-            # moved from step 2.2.3
-            # If expanded value is null and property is not @value, continue with the next property
-            # from element.
-            if property != '@value' && expanded_value.nil?
+            # Continue to the next property-value pair from element if value is null.
+            if expanded_value.nil?
               debug(" => skip nil value")
               next
             end
 
-            # If the expanded value is not null and property is not a keyword
-            # and the active property has a @container set to @list,
-            # convert value to an object with an @list property whose value is set to value
-            # (unless value is already in that form)
-            if expanded_value && property[0,1] != '@' && context.container(active_property) == '@list' &&
-               (!expanded_value.is_a?(Hash) || !expanded_value.fetch('@list', false))
-               debug(" => ") { "convert #{expanded_value.inspect} to list"}
+            # If property's container mapping is set to @list and value is not a JSON object or is a JSON object without a @list member, replace value with a JSON object having a @list member whose value is set to value, ensuring that value is an array.
+            if context.container(property) == '@list' &&
+              (!expanded_value.is_a?(Hash) || !expanded_value.fetch('@list', false))
+
+              debug(" => ") { "convert #{expanded_value.inspect} to list"}
               expanded_value = {'@list' => [expanded_value].flatten}
             end
 
-            # Convert value to array form unless value is null or property is @id, @type, @value, or @language.
-            if !%(@id @language @type @value).include?(property) && !expanded_value.is_a?(Array)
-              debug(" => make #{expanded_value.inspect} an array")
-              expanded_value = [expanded_value]
-            end
+            # Convert value to array form
+            debug(" => ") {"expanded property: #{expanded_property.inspect}"}
+            expanded_value = [expanded_value] unless expanded_value.is_a?(Array)
 
-            if output_object.has_key?(property)
-              # If element already contains a property property, append value to the existing value.
-              output_object[property] += expanded_value
+            if expanded_property.is_a?(Array)
+              label_blanknodes(expanded_value)
+              expanded_property.map(&:to_s).each do |prop|
+                # label all blank nodes in value with blank node identifiers by using the Label Blank Nodes Algorithm.
+                output_object[prop] ||= []
+                output_object[prop] += expanded_value.dup
+              end
             else
-              # Otherwise, create a property property with value as value.
-              output_object[property] = expanded_value
+              if output_object.has_key?(expanded_property)
+                # If element already contains a expanded_property property, append value to the existing value.
+                output_object[expanded_property] += expanded_value
+              else
+                # Otherwise, create a property property with value as value.
+                output_object[expanded_property] = expanded_value
+              end
             end
             debug {" => #{expanded_value.inspect}"}
           end
 
           debug("output object") {output_object.inspect}
 
+          # If the active property is null or @graph and element has a @value member without an @annotation member, or element consists of only an @id member, set element to null.
+          debug("output object(ap)") {((active_property || '@graph') == '@graph').inspect}
+          if (active_property || '@graph') == '@graph' &&
+             ((output_object.has_key?('@value') && !output_object.has_key?('@annotation')) ||
+              (output_object.keys - %w(@id)).empty?)
+            debug("empty top-level") {output_object.inspect}
+            return nil
+          end
+
           # If the processed element has an @value property
           if output_object.has_key?('@value')
             output_object.delete('@language') if output_object['@language'].to_s.empty?
             output_object.delete('@type') if output_object['@type'].to_s.empty?
-            if output_object.keys.length > 2 || (%w(@language @type) - output_object.keys).empty?
-              raise ProcessingError, "element must not have more than one other property, which can either be @language or @type with a string value." unless value.is_a?(String)
+            if (%w(@annotation @language @type) - output_object.keys).empty?
+              raise ProcessingError, "element must not have more than one other property other than @annotation, which can either be @language or @type with a string value." unless value.is_a?(String)
             end
 
             # if the value of @value equals null, replace element with the value of null.
@@ -168,24 +245,53 @@ module JSON::LD
             output_object['@type'] = [output_object['@type']]
           end
 
-          # If element has an @set or @list property, it must be the only property. Set element to the value of @set;
+          # If element has an @set or @list property, it must be the only property (other tha @annotation). Set element to the value of @set;
           # leave @list untouched.
           if !(%w(@set @list) & output_object.keys).empty?
-            raise ProcessingError, "element must have only @set, @list or @graph" if output_object.keys.length > 1
+            o_keys = output_object.keys - %w(@set @list @annotation)
+            raise ProcessingError, "element must have only @set or  @list: #{output_object.keys.inspect}" if o_keys.length > 1
             
             output_object = output_object.values.first unless output_object.has_key?('@list')
           end
 
-          # If element has just a @language property, set element to null.
-          output_object unless output_object.is_a?(Hash) && output_object.keys == %w(@language)
+          # Re-order result keys
+          if output_object.is_a?(Hash) && output_object.keys == %w(@language)
+            # If element has just a @language property, set element to null.
+            nil
+          elsif output_object.is_a?(Hash)
+            r = Hash.ordered
+            output_object.keys.kw_sort.each {|k| r[k] = output_object[k]}
+            r
+          else
+            output_object
+          end
         end
       else
         # Otherwise, unless the value is a number, expand the value according to the Value Expansion rules, passing active property.
-        context.expand_value(active_property, input, :position => :subject, :depth => @depth) unless input.nil?
+        context.expand_value(active_property, input,
+          :position => :subject, :namer => namer, :depth => @depth
+        ) unless input.nil? || active_property.nil? || active_property == '@graph'
       end
 
       debug {" => #{result.inspect}"}
       result
     end
+
+    protected
+    # @param [Array, Hash] input
+    def label_blanknodes(element)
+      if element.is_a?(Array)
+        element.each {|e| label_blanknodes(e)}
+      elsif list?(element)
+        element['@list'].each {|e| label_blanknodes(e)}
+      elsif element.is_a?(Hash)
+        element.keys.sort.each do |k|
+          label_blanknodes(element[k])
+        end
+        if node?(element) and !element.has_key?('@id')
+          element['@id'] = namer.get_name(nil)
+        end
+      end
+    end
   end
-end
+end

data/lib/json/ld/extensions.rb

@@ -62,6 +62,24 @@ module RDF
   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 = %(@id @value @type @language @vocab @container @graph @list @set)
+
+  def kw_sort
+    self.sort do |a, b|
+      a = "@#{KW_ORDER.index(a)}" if KW_ORDER.include?(a)
+      b = "@#{KW_ORDER.index(b)}" if KW_ORDER.include?(b)
+      a <=> b
+    end
+  end
+end
+
 if RUBY_VERSION < "1.9"
   class InsertOrderPreservingHash < Hash
     include Enumerable

data/lib/json/ld/flatten.rb

@@ -13,14 +13,13 @@ module JSON::LD
     #   Graph name for results
     # @param [Array] list
     #   List for saving list elements
-    # @param [BlankNodeNamer] namer
-    # @param [String] id
+    # @param [String] id (nil)
     #   Identifier already associated with element
-    def generate_node_map(element, node_map, graph, list, namer, id = nil)
+    def generate_node_map(element, node_map, graph, list = nil, id = nil)
       depth do
         debug("nodeMap") {"element: #{element.inspect}, graph: #{graph}"}
         if element.is_a?(Array)
-          element.map {|o| generate_node_map(o, node_map, graph, list, namer)}
+          element.map {|o| generate_node_map(o, node_map, graph, list)}
         elsif !element.is_a?(Hash) || value?(element)
           list << element if list
         else
@@ -48,7 +47,7 @@ module JSON::LD
             when '@graph'
               # If property is @graph, recursively call this algorithm passing value for element, nodeMap, nil for list and if graph is @merged use graph, otherwise use id for graph and then continue.
               graph = graph == '@merged' ? '@merged' : id
-              generate_node_map(value, node_map, graph, nil, namer)
+              generate_node_map(value, node_map, graph)
             when /^@(?!type)/
               # If property is not @type and is a keyword, merge property and value into node and then continue.
               debug("nodeMap") {"merge keyword#{prop}: #{value.inspect}"}
@@ -75,7 +74,7 @@ module JSON::LD
                   }
 
                   # Recursively call this algorithm passing v for value, nodeMap, graph, and nil for list.
-                  generate_node_map(v, node_map, graph, nil, namer, name)
+                  generate_node_map(v, node_map, graph, nil, name)
                 elsif list?(v)
                   # Otherwise if v has the property @list then recursively call this algorithm with the value of @list as element, nodeMap, graph, and a new array flattenedList as list.
                   debug("nodeMap") {"list value #{prop}: #{v.inspect}"}
@@ -83,8 +82,7 @@ module JSON::LD
                   generate_node_map(v['@list'],
                     node_map,
                     graph,
-                    flattened_list,
-                    namer)
+                    flattened_list)
                   # Create a new JSON object with the property @list set to flattenedList and add it to node for property.
                   (node[prop] ||= []) << {'@list' => flattened_list}
                 elsif prop == '@type'

data/lib/json/ld/frame.rb

@@ -36,7 +36,7 @@ module JSON::LD
         debug("frame") {"embed: #{embed.inspect}, explicit: #{explicit.inspect}"}
       
         # For each id and node from the set of matched nodes ordered by id
-        matches.keys.sort.each do |id|
+        matches.keys.kw_sort.each do |id|
           element = matches[id]
           # If the active property is null, set the map of embeds in state to an empty map
           state = state.merge(:embeds => {}) if property.nil?
@@ -77,7 +77,7 @@ module JSON::LD
             debug("frame") {"add embedded_node: #{embedded_node.inspect}"}
         
             # Process each property and value in the matched node as follows
-            element.keys.sort.each do |prop|
+            element.keys.kw_sort.each do |prop|
               value = element[prop]
               if prop[0,1] == '@'
                 # If property is a keyword, add property and a copy of value to output and continue with the next property from node
@@ -138,7 +138,7 @@ module JSON::LD
             end
 
             # Process each property and value in frame in lexographical order, where property is not a keyword, as follows:
-            frame.keys.sort.each do |prop|
+            frame.keys.kw_sort.each do |prop|
               next if prop[0,1] == '@' || output.has_key?(prop)
               property_frame = frame[prop]
               debug("frame") {"frame prop: #{prop.inspect}. property_frame: #{property_frame.inspect}"}

data/lib/json/ld/to_rdf.rb

@@ -1,3 +1,4 @@
+require 'rdf'
 require 'rdf/nquads'
 
 module JSON::LD
@@ -21,7 +22,6 @@ module JSON::LD
     # @yieldparam [RDF::Statement] statement
     def statements(path, element, subject, property, name, &block)
       debug(path) {"statements: e=#{element.inspect}, s=#{subject.inspect}, p=#{property.inspect}, n=#{name.inspect}"}
-      @node_seq = "t0" unless subject || property
 
       traverse_result = depth do
         case element
@@ -55,7 +55,7 @@ module JSON::LD
 
           # 1.7) For each key in the JSON object that has not already been processed,
           # perform the following steps:
-          element.keys.sort.each do |key|
+          element.keys.kw_sort.each do |key|
             value = element[key]
             active_property = case key
             when '@type'
@@ -65,7 +65,7 @@ module JSON::LD
               # Otherwise, if property is @graph, process value algorithm recursively, using active subject
               # as graph name and null values for active subject and active property and then continue to
               # next property
-              statements("#{path}[#{key}]", value, nil, nil, active_subject, &block)
+              statements("#{path}[#{key}]", value, nil, nil, (active_subject unless active_subject.node?), &block)
               next
             when /^@/
               # Otherwise, if property is a keyword, skip this step.
@@ -154,9 +154,7 @@ module JSON::LD
     ##
     # Create a new named node using the sequence
     def node
-      n = RDF::Node.new(@node_seq)
-      @node_seq = @node_seq.succ
-      n
+      RDF::Node.new(namer.get_sym)
     end
 
     ##