json-ld 0.1.0 → 0.1.2

data/lib/json/ld/from_rdf.rb

@@ -0,0 +1,166 @@
+require 'rdf/nquads'
+
+module JSON::LD
+  module FromTriples
+    include Utils
+
+    ##
+    # Generate a JSON-LD array representation from an array of `RDF::Statement`.
+    # Representation is in expanded form
+    #
+    # @param [Array<RDF::Statement>] input
+    # @param [BlankNodeNamer] namer
+    # @return [Array<Hash>] the JSON-LD document in normalized form
+    def from_statements(input, namer)
+      array = []
+      listMap = {}
+      restMap = {}
+      subjectMap = {}
+      bnode_map = {}
+
+      value = nil
+      ec = EvaluationContext.new
+
+      # Create a map for subject to object representation
+
+      # For each triple in input
+      input.each do |statement|
+        debug("statement") { statement.to_nquads.chomp}
+
+        subject = ec.expand_iri(statement.subject).to_s
+        name = ec.expand_iri(statement.context).to_s if statement.context
+        subject = namer.get_name(subject) if subject[0,2] == "_:"
+        name = namer.get_name(name) if name.to_s[0,2] == "_:"
+
+        case statement.predicate
+        when RDF.first
+          # If property is rdf:first,
+          # create a new entry in _listMap_ for _name_ and _subject_ and an array value
+          # containing the object representation and continue to the next statement.
+          object_rep = ec.expand_value(nil, statement.object)
+          object_rep['@id'] = namer.get_name(object_rep['@id']) if blank_node?(object_rep)
+          debug("rdf:first") { "save object #{[object_rep].inspect}"}
+          listMap[name] ||= {}
+          listMap[name][subject] = [object_rep]
+          next
+        when RDF.rest
+          # If property is rdf:rest,
+          # and object is a blank node,
+          # create a new entry in _restMap_ for _name_ and _subject_ and a value being the
+          # result of IRI expansion on the object and continue to the next statement.
+          next unless statement.object.is_a?(RDF::Node)
+          object_rep = ec.expand_iri(statement.object).to_s
+          object_rep = namer.get_name(object_rep) if object_rep[0,2] == '_:'
+          debug("rdf:rest") { "save object #{object_rep.inspect}"}
+          restMap[name] ||= {}
+          restMap[name][subject] = object_rep
+          next
+        end
+
+        # If name is not null
+        if name
+          # If _subjectMap_ does not have an entry for null as name and _name_ as subject
+          subjectMap[nil] ||= {}
+          value = subjectMap[nil][name]
+          unless value
+            # Create a new JSON Object with key/value pair of @id and a string representation
+            # of name and append to array.
+            debug("@id") { "new subject: #{name} for graph"}
+            value = Hash.ordered
+            value['@id'] = name
+            array << (subjectMap[nil][name] = value)
+          else
+            # Otherwise, use that entry as value
+          end
+
+          # If value does not have an entry for @graph, initialize it as a new array
+          a = value['@graph'] ||= []
+
+          # If subjectMap does not have an entry for name and subject
+          subjectMap[name] ||= {}
+          value = subjectMap[name][subject]
+          unless value
+            # Create a new JSON Object with key/value pair of @id and a string representation
+            # of name and append to the the graph array for name and use as value.
+            debug("@id") { "new subject: #{subject} for graph: #{name}"}
+            value = Hash.ordered
+            value['@id'] = subject
+            a << (subjectMap[name][subject] = value)
+          else
+            # Otherwise, use that entry as value
+          end
+        else
+          # Otherwise, if subjectMap does not have an entry for _name_ and _subject_
+          subjectMap[name] ||= {}
+          value = subjectMap[nil][subject]
+          unless value
+            # Create a new JSON Object with key/value pair of @id and a string representation
+            # of subject and append to array.
+            debug("@id") { "new subject: #{subject}"}
+            value = Hash.ordered
+            value['@id'] = subject
+            array << (subjectMap[nil][subject] = value)
+          else
+            # Otherwise, use that entry as value
+          end
+        end
+        
+        # If property is http://www.w3.org/1999/02/22-rdf-syntax-ns#type:
+        if statement.predicate == RDF.type
+          object = ec.expand_iri(statement.object).to_s
+          debug("@type") { object.inspect}
+          # append the string representation of object to the array value for the key @type, creating
+          # an entry if necessary
+          (value['@type'] ||= []) << object
+        elsif statement.object == RDF.nil
+          # Otherwise, if object is http://www.w3.org/1999/02/22-rdf-syntax-ns#nil, let
+          # key be the string representation of predicate. Set the value
+          # for key to an empty @list representation {"@list": []}
+          key = ec.expand_iri(statement.predicate).to_s
+          value[key] = {"@list" => []}
+        else
+          # Otherwise, let key be the string representation of predicate and let object representation
+          # be object represented in expanded form as described in Value Expansion.
+          key = ec.expand_iri(statement.predicate).to_s
+          object = ec.expand_value(key, statement.object)
+          debug("object") {"detected that #{object.inspect} is a blank node"}
+          object['@id'] = object_iri = namer.get_name(object['@id']) if blank_node?(object)
+
+          debug("key/value") { "key: #{key}, :value #{object.inspect}"}
+          
+          # Non-normative, save a reference for the bnode to allow for easier list expansion
+          bnode_map[object_iri] = {:obj => value, :key => key} if statement.object.is_a?(RDF::Node)
+
+          # append the object object representation to the array value for key, creating
+          # an entry if necessary
+          (value[key] ||= []) << object
+        end
+      end
+
+      # For each key/value _prev_, _rest_ entry in _restMap_, append to the _listMap_ value identified
+      # by _prev_ the _listMap_ value identified by _rest_
+      debug("restMap") {restMap.inspect}
+      restMap.each do |gname, map|
+        map.each do |prev, rest|
+          debug("@list") { "Fold #{rest} into #{prev}"}
+          listMap[gname][prev] += listMap[gname][rest]
+        end
+      end
+
+      # For each key/value _node_, _list_, in _listMap_ where _list_ exists as a value of an object in _array_,
+      # replace the object value with _list_
+      debug("listMap") {listMap.inspect}
+      listMap.each do |gname, map|
+        map.each do |node, list|
+          next unless bnode_map.has_key?(node)
+          debug("@list") { "Replace #{bnode_map[node][:obj][bnode_map[node][:key]]} with #{listMap[node]}"}
+          bnode_map[node][:obj][bnode_map[node][:key]] = {"@list" => listMap[gname][node]}
+        end
+      end
+
+      # Return array as the graph representation.
+      debug("fromRdf") {array.to_json(JSON_STATE)}
+      array
+    end
+  end
+end

data/lib/json/ld/reader.rb

@@ -10,10 +10,10 @@ module JSON::LD
     format Format
     
     ##
-    # The graph constructed when parsing.
-    #
-    # @return [RDF::Graph]
-    attr_reader :graph
+    # Override normal symbol generation
+    def self.to_sym
+      :jsonld
+    end
 
     ##
     # Initializes the RDF/JSON reader instance.
@@ -26,6 +26,8 @@ module JSON::LD
     # @yieldreturn [void] ignored
     # @raise [RDF::ReaderError] if the JSON document cannot be loaded
     def initialize(input = $stdin, options = {}, &block)
+      options[:base_uri] ||= options[:base] if options.has_key?(:base)
+      options[:base] ||= options[:base_uri] if options.has_key?(:base_uri)
       super do
         begin
           @doc = JSON.load(input)
@@ -47,12 +49,7 @@ module JSON::LD
     # @private
     # @see   RDF::Reader#each_statement
     def each_statement(&block)
-      @callback = block
-
-      # initialize the evaluation context with initial context
-      ec = EvaluationContext.new(@options)
-
-      traverse("", @doc, nil, nil, ec)
+      JSON::LD::API.toRDF(@doc, @options[:context], nil, @options, &block)
     end
 
     ##
@@ -63,227 +60,6 @@ module JSON::LD
         block.call(*statement.to_triple)
       end
     end
-    
-    private
-    ##
-    #
-    # @param [String] path
-    #   location within JSON hash
-    # @param [Hash, Array, String] element
-    #   The current JSON element being processed
-    # @param [RDF::URI] subject
-    #   Inherited subject
-    # @param [RDF::URI] property
-    #   Inherited property
-    # @param [EvaluationContext] ec
-    #   The active context
-    # @return [RDF::Resource] defined by this element
-    # @yield :resource
-    # @yieldparam [RDF::Resource] :resource
-    def traverse(path, element, subject, property, ec)
-      debug(path) {"traverse: e=#{element.class.inspect}, s=#{subject.inspect}, p=#{property.inspect}, e=#{ec.inspect}"}
-
-      traverse_result = case element
-      when Hash
-        # 2.1) If a @context keyword is found, the processor merges each key-value pair in
-        # the local context into the active context ...
-        if element['@context']
-          # Merge context
-          ec = ec.parse(element['@context'])
-          prefixes.merge!(ec.mappings)  # Update parsed prefixes
-        end
-        
-        # 2.2) Create a copy of the current JSON object, changing keys that map to JSON-LD keywords with those keywords.
-        #      Use the new JSON object in subsequent steps
-        new_element = {}
-        element.each do |k, v|
-          k = ec.mapping(k) if ec.mapping(k).to_s[0,1] == '@'
-          new_element[k] = v
-        end
-        unless element == new_element
-          debug(path) {"traverse: keys after map: #{new_element.keys.inspect}"}
-          element = new_element
-        end
-
-        # Other shortcuts to allow use of this method for terminal associative arrays
-        object = if element['@literal']
-          # 2.3) If the JSON object has a @literal key, set the active object to a literal value as follows ...
-          literal_opts = {}
-          literal_opts[:datatype] = ec.expand_iri(element['@type'], :position => :datatype) if element['@type']
-          literal_opts[:language] = element['@language'].to_sym if element['@language']
-          RDF::Literal.new(element['@literal'], literal_opts)
-        elsif element['@list']
-          # 2.4 (Lists)
-          parse_list("#{path}[#{'@list'}]", element['@list'], property, ec) do |resource|
-            add_triple(path, subject, property, resource) if subject && property
-          end
-        end
-
-        if object
-          yield object if block_given?
-          return object
-        end
-        
-        active_subject = if element['@id'].is_a?(String)
-          # 2.5 Subject
-          # 2.5.1 Set active object (subject)
-          ec.expand_iri(element['@id'], :position => :subject)
-        elsif element['@id']
-          # 2.5.2 Recursively process hash or Array values
-          traverse("#{path}[#{'@id'}]", element['@id'], subject, property, ec) do |resource|
-            add_triple(path, subject, property, resource) if subject && property
-          end
-        else
-          # 2.6) Generate a blank node identifier and set it as the active subject.
-          RDF::Node.new
-        end
-
-        subject = active_subject
-        
-        # 2.7) For each key in the JSON object that has not already been processed, perform the following steps:
-        element.each do |key, value|
-          # 2.7.1) If a key that is not @context, @id, or @type, set the active property by
-          # performing Property Processing on the key.
-          property = case key
-          when '@type' then RDF.type
-          when /^@/ then next
-          else      ec.expand_iri(key, :position => :predicate)
-          end
-
-          # 2.7.3) List expansion
-          object = if ec.list(property) && value.is_a?(Array)
-            # If the active property is the target of a @list coercion, and the value is an array,
-            # process the value as a list starting at Step 3.1.
-            parse_list("#{path}[#{key}]", value, property, ec) do |resource|
-              # Adds triple for head BNode only, the rest of the list is done within the method
-              add_triple(path, subject, property, resource) if subject && property
-            end
-          else
-            traverse("#{path}[#{key}]", value, subject, property, ec) do |resource|
-              # Adds triples for each value
-              add_triple(path, subject, property, resource) if subject && property
-            end
-          end
-        end
-        
-        # 2.8) The subject is returned
-        subject
-      when Array
-        # 3) If a regular array is detected ...
-        element.each_with_index do |v, i|
-          traverse("#{path}[#{i}]", v, subject, property, ec) do |resource|
-            add_triple(path, subject, property, resource) if subject && property
-          end
-        end
-        nil # No real value returned from an array
-      when String
-        # 4) Perform coersion of the value, or generate a literal
-        debug(path) do
-          "traverse(#{element}): coerce(#{property.inspect}) == #{ec.coerce(property).inspect}, " +
-          "ec=#{ec.coercions.inspect}"
-        end
-        if ec.coerce(property) == '@id'
-          # 4.1) If the active property is the target of a @id coercion ...
-          ec.expand_iri(element, :position => :object)
-        elsif ec.coerce(property)
-          # 4.2) Otherwise, if the active property is the target of coercion ..
-          RDF::Literal.new(element, :datatype => ec.coerce(property))
-        else
-          # 4.3) Otherwise, set the active object to a plain literal value created from the string.
-          RDF::Literal.new(element, :language => ec.language)
-        end
-      when Float
-        object = RDF::Literal::Double.new(element)
-        debug(path) {"traverse(#{element}): native: #{object.inspect}"}
-        object
-      when Fixnum
-        object = RDF::Literal.new(element)
-        debug(path) {"traverse(#{element}): native: #{object.inspect}"}
-        object
-      when TrueClass, FalseClass
-        object = RDF::Literal::Boolean.new(element)
-        debug(path) {"traverse(#{element}): native: #{object.inspect}"}
-        object
-      else
-        raise RDF::ReaderError, "Traverse to unknown element: #{element.inspect} of type #{element.class}"
-      end
-      
-      # Yield and return traverse_result
-      yield traverse_result if traverse_result && block_given?
-      traverse_result
-    end
-
-    ##
-    # Parse a List
-    #
-    # @param [String] path
-    #   location within JSON hash
-    # @param [Array] list
-    #   The Array to serialize as a list
-    # @param [RDF::URI] property
-    #   Inherited property
-    # @param [EvaluationContext] ec
-    #   The active context
-    # @return [RDF::Resource] BNode or nil for head of list
-    # @yield :resource
-    #   BNode or nil for head of list
-    # @yieldparam [RDF::Resource] :resource
-    def parse_list(path, list, property, ec)
-      debug(path) {"list: #{list.inspect}, p=#{property.inspect}, e=#{ec.inspect}"}
-
-      last = list.pop
-      result = first_bnode = last ? RDF::Node.new : RDF.nil
-
-      list.each do |list_item|
-        # Traverse the value, using _property_, not rdf:first, to ensure that
-        # proper type coercion is performed
-        traverse("#{path}", list_item, first_bnode, property, ec) do |resource|
-          add_triple("#{path}", first_bnode, RDF.first, resource)
-        end
-        rest_bnode = RDF::Node.new
-        add_triple("#{path}", first_bnode, RDF.rest, rest_bnode)
-        first_bnode = rest_bnode
-      end
-      if last
-        traverse("#{path}", last, first_bnode, property, ec) do |resource|
-          add_triple("#{path}", first_bnode, RDF.first, resource)
-        end
-        add_triple("#{path}", first_bnode, RDF.rest, RDF.nil)
-      end
-      
-      yield result if block_given?
-      result
-    end
-
-    ##
-    # add a statement, object can be literal or URI or bnode
-    #
-    # @param [String] path
-    # @param [URI, BNode] subject the subject of the statement
-    # @param [URI] predicate the predicate of the statement
-    # @param [URI, BNode, Literal] object the object of the statement
-    # @return [Statement] Added statement
-    # @raise [ReaderError] Checks parameter types and raises if they are incorrect if parsing mode is _validate_.
-    def add_triple(path, subject, predicate, object)
-      predicate = RDF.type if predicate == '@type'
-      statement = RDF::Statement.new(subject, predicate, object)
-      debug(path) {"statement: #{statement.to_ntriples}"}
-      @callback.call(statement)
-    end
-
-    ##
-    # Add debug event to debug array, if specified
-    #
-    # @param [XML Node, any] node:: XML Node or string for showing context
-    # @param [String] message
-    # @yieldreturn [String] appended to message, to allow for lazy-evaulation of message
-    def debug(*args)
-      return unless ::JSON::LD.debug? || @options[:debug]
-      message = " " * (@depth || 0) * 2 + (args.empty? ? "" : args.join(": "))
-      message += yield if block_given?
-      puts message if JSON::LD::debug?
-      @options[:debug] << message if @options[:debug].is_a?(Array)
-    end
   end
 end
 

data/lib/json/ld/to_rdf.rb

@@ -0,0 +1,181 @@
+require 'rdf/nquads'
+
+module JSON::LD
+  module Triples
+    include Utils
+
+    ##
+    #
+    # @param [String] path
+    #   location within JSON hash
+    # @param [Hash, Array, String] element
+    #   The current JSON element being processed
+    # @param [RDF::Node] subject
+    #   Inherited subject
+    # @param [RDF::URI] property
+    #   Inherited property
+    # @param [RDF::Node] name
+    #   Inherited inherited graph name
+    # @return [RDF::Resource] defined by this element
+    # @yield :statement
+    # @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 = "jld_t0000" unless subject || property
+
+      traverse_result = depth do
+        case element
+        when Hash
+          # Other shortcuts to allow use of this method for terminal associative arrays
+          object = if element.has_key?('@value')
+            # 1.2) If the JSON object has a @value key, set the active object to a literal value as follows ...
+            literal_opts = {}
+            literal_opts[:datatype] = RDF::URI(element['@type']) if element['@type']
+            literal_opts[:language] = element['@language'].to_sym if element['@language']
+            RDF::Literal.new(element['@value'], literal_opts)
+          elsif element.has_key?('@list')
+            # 1.3 (Lists)
+            parse_list("#{path}[#{'@list'}]", element['@list'], property, name, &block)
+          end
+
+          if object
+            # 1.4
+            add_quad(path, subject, property, object, name, &block) if subject && property
+            return object
+          end
+        
+          active_subject = if element.fetch('@id', nil).is_a?(String)
+            # 1.5 Subject
+            # 1.5.1 Set active object (subject)
+            context.expand_iri(element['@id'], :quite => true)
+          else
+            # 1.6) Generate a blank node identifier and set it as the active subject.
+            node
+          end
+
+          # 1.7) For each key in the JSON object that has not already been processed,
+          # perform the following steps:
+          element.each do |key, value|
+            active_property = case key
+            when '@type'
+              # If the key is @type, set the active property to rdf:type.
+              RDF.type
+            when '@graph'
+              # 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)
+              next
+            when /^@/
+              # Otherwise, if property is a keyword, skip this step.
+              next
+            else
+              # 1.7.1) If a key that is not @id, @graph, or @type, set the active property by
+              # performing Property Processing on the key.
+              context.expand_iri(key, :quite => true)
+            end
+
+            debug("statements[Step 1.7.4]")
+            statements("#{path}[#{key}]", value, active_subject, active_property, name, &block)
+          end
+        
+          # 1.8) The active_subject is returned
+          active_subject
+        when Array
+          # 2) If a regular array is detected ...
+          debug("statements[Step 2]")
+          element.each_with_index do |v, i|
+            statements("#{path}[#{i}]", v, subject, property, name, &block)
+          end
+          nil # No real value returned from an array
+        when String
+          object = RDF::Literal.new(element)
+          debug(path) {"statements[Step 3]: plain: #{object.inspect}"}
+          object
+        when Float
+          object = RDF::Literal::Double.new(element)
+          debug(path) {"statements[Step 4]: native: #{object.inspect}"}
+          object
+        when Fixnum
+          object = RDF::Literal.new(element)
+          debug(path) {"statements[Step 5]: native: #{object.inspect}"}
+          object
+        when TrueClass, FalseClass
+          object = RDF::Literal::Boolean.new(element)
+          debug(path) {"statements[Step 6]: native: #{object.inspect}"}
+          object
+        else
+          raise RDF::ReaderError, "Traverse to unknown element: #{element.inspect} of type #{element.class}"
+        end
+      end
+
+      # Yield and return traverse_result
+      add_quad(path, subject, property, traverse_result, name, &block) if subject && property && traverse_result
+      traverse_result
+    end
+
+    ##
+    # Parse a List
+    #
+    # @param [String] path
+    #   location within JSON hash
+    # @param [Array] list
+    #   The Array to serialize as a list
+    # @param [RDF::URI] property
+    #   Inherited property
+    # @param [RDF::Resource] name
+    #   Inherited named graph context
+    # @param [EvaluationContext] ec
+    #   The active context
+    # @return [RDF::Resource] BNode or nil for head of list
+    # @yield :statement
+    # @yieldparam [RDF::Statement] :statement
+    def parse_list(path, list, property, name, &block)
+      debug(path) {"list: #{list.inspect}, p=#{property.inspect}, n=#{name.inspect}"}
+
+      last = list.pop
+      result = first_bnode = last ? node : RDF.nil
+
+      depth do
+        list.each do |list_item|
+          # Traverse the value
+          statements("#{path}", list_item, first_bnode, RDF.first, name, &block)
+          rest_bnode = node
+          add_quad("#{path}", first_bnode, RDF.rest, rest_bnode, name, &block)
+          first_bnode = rest_bnode
+        end
+        if last
+          statements("#{path}", last, first_bnode, RDF.first, name, &block)
+          add_quad("#{path}", first_bnode, RDF.rest, RDF.nil, name, &block)
+        end
+      end
+      result
+    end
+
+    ##
+    # Create a new named node using the sequence
+    def node
+      n = RDF::Node.new(@node_seq)
+      @node_seq = @node_seq.succ
+      n
+    end
+
+    ##
+    # add a statement, object can be literal or URI or bnode
+    #
+    # @param [String] path
+    # @param [RDF::Resource] subject the subject of the statement
+    # @param [RDF::URI] predicate the predicate of the statement
+    # @param [RDF::Term] object the object of the statement
+    # @param [RDF::Resource] name the named graph context of the statement
+    # @yield :statement
+    # @yieldparam [RDF::Statement] :statement
+    def add_quad(path, subject, predicate, object, name)
+      predicate = RDF.type if predicate == '@type'
+      object = RDF::URI(object.to_s) if object.literal? && predicate == RDF.type
+      statement = RDF::Statement.new(subject, predicate, object, :context => name)
+      debug(path) {"statement: #{statement.to_nquads}"}
+      yield statement
+    end
+  end
+end