json-ld 3.2.3 → 3.2.5

data/lib/json/ld/streaming_writer.rb

@@ -1,116 +1,117 @@
-# -*- encoding: utf-8 -*-
 # frozen_string_literal: true
-module JSON::LD
-  ##
-  # Streaming writer interface.
-  #
-  # Writes an array of statements serialized in expanded JSON-LD. No provision for turning rdf:first/rest into @list encodings.
-  # @author [Gregg Kellogg](http://greggkellogg.net/)
-  module StreamingWriter
-    ##
-    # Write out array start, and note not to prepend node-separating ','
-    # @return [void] `self`
-    def stream_prologue
-
-      # If we were provided a context, or prefixes, use them to compact the output
-      @context = case @options[:context]
-      when nil then nil
-      when Context then @options[:context]
-      else Context.parse(@options[:context])
-      end
-
-      #log_debug("prologue") {"context: #{context.inspect}"}
-      if context
-        @output.puts %({"@context": #{context.serialize['@context'].to_json}, "@graph": [)
-      else
-        @output.puts "["
-      end
-      self
-    end
 
+module JSON
+  module LD
     ##
-    # Write a statement, creating a current node definition, if necessary.
-    #
-    # Once a new/first statement is seen, terminate the current node definition and compact if provided a context.
-    #
-    # Also expects all statements in the same context to be contained in a block including all subjects in a block (except for list elements)
+    # Streaming writer interface.
     #
-    # Note that if list elements are not received in order using the same subject and property, this may cause a bad serialization.
-    #
-    # @return [void] `self`
-    def stream_statement(statement)
-      #log_debug("ss") {"state: #{@state.inspect}, stmt: #{statement}"}
-      if @current_graph != statement.graph_name
-        end_graph
-        start_graph(statement.graph_name)
+    # Writes an array of statements serialized in expanded JSON-LD. No provision for turning rdf:first/rest into @list encodings.
+    # @author [Gregg Kellogg](http://greggkellogg.net/)
+    module StreamingWriter
+      ##
+      # Write out array start, and note not to prepend node-separating ','
+      # @return [void] `self`
+      def stream_prologue
+        # If we were provided a context, or prefixes, use them to compact the output
+        @context = case @options[:context]
+        when nil then nil
+        when Context then @options[:context]
+        else Context.parse(@options[:context])
+        end
+
+        # log_debug("prologue") {"context: #{context.inspect}"}
+        if context
+          @output.puts %({"@context": #{context.serialize['@context'].to_json}, "@graph": [)
+        else
+          @output.puts "["
+        end
+        self
       end
 
-      # If we're writing a list
-      @current_node_def ||= {'@id' => statement.subject.to_s}
+      ##
+      # Write a statement, creating a current node definition, if necessary.
+      #
+      # Once a new/first statement is seen, terminate the current node definition and compact if provided a context.
+      #
+      # Also expects all statements in the same context to be contained in a block including all subjects in a block (except for list elements)
+      #
+      # Note that if list elements are not received in order using the same subject and property, this may cause a bad serialization.
+      #
+      # @return [void] `self`
+      def stream_statement(statement)
+        # log_debug("ss") {"state: #{@state.inspect}, stmt: #{statement}"}
+        if @current_graph != statement.graph_name
+          end_graph
+          start_graph(statement.graph_name)
+        end
 
-      if statement.subject.to_s != @current_node_def['@id']
-        end_node
-        @current_node_def = {'@id' => statement.subject.to_s}
-      end
+        # If we're writing a list
+        @current_node_def ||= { '@id' => statement.subject.to_s }
 
-      if statement.predicate == RDF.type
-        (@current_node_def['@type'] ||= []) << statement.object.to_s
-      else
-        pd = (@current_node_def[statement.predicate.to_s] ||= [])
+        if statement.subject.to_s != @current_node_def['@id']
+          end_node
+          @current_node_def = { '@id' => statement.subject.to_s }
+        end
 
-        pd << if statement.object.resource?
-          {'@id' => statement.object.to_s}
-        elsif statement.object.datatype == RDF::URI(RDF.to_uri + "JSON")
-          {"@value" => MultiJson.load(statement.object.to_s), "@type" => "@json"}
+        if statement.predicate == RDF.type
+          (@current_node_def['@type'] ||= []) << statement.object.to_s
         else
-          lit = {"@value" => statement.object.to_s}
-          lit["@type"] = statement.object.datatype.to_s if statement.object.datatype?
-          lit["@language"] = statement.object.language.to_s if statement.object.language?
-          lit
+          pd = (@current_node_def[statement.predicate.to_s] ||= [])
+
+          pd << if statement.object.resource?
+            { '@id' => statement.object.to_s }
+          elsif statement.object.datatype == RDF_JSON
+            { "@value" => MultiJson.load(statement.object.to_s), "@type" => "@json" }
+          else
+            lit = { "@value" => statement.object.to_s }
+            lit["@type"] = statement.object.datatype.to_s if statement.object.datatype?
+            lit["@language"] = statement.object.language.to_s if statement.object.language?
+            lit
+          end
         end
+        self
       end
-      self
-    end
 
-    ##
-    # Complete open statements
-    # @return [void] `self`
-    def stream_epilogue
-      #log_debug("epilogue") {"state: #{@state.inspect}"}
-      end_graph
-      if context
-        @output.puts "\n]}"
-      else
-        @output.puts "\n]"
+      ##
+      # Complete open statements
+      # @return [void] `self`
+      def stream_epilogue
+        # log_debug("epilogue") {"state: #{@state.inspect}"}
+        end_graph
+        if context
+          @output.puts "\n]}"
+        else
+          @output.puts "\n]"
+        end
+        self
       end
-      self
-    end
 
-    private
-    
-    def start_graph(resource)
-      #log_debug("start_graph") {"state: #{@state.inspect}, resource: #{resource}"}
-      if resource
-        @output.puts(",") if %i(wrote_node wrote_graph).include?(@state)
-        @output.puts %({"@id": "#{resource}", "@graph": [)
-        @state = :in_graph
+      private
+
+      def start_graph(resource)
+        # log_debug("start_graph") {"state: #{@state.inspect}, resource: #{resource}"}
+        if resource
+          @output.puts(",") if %i[wrote_node wrote_graph].include?(@state)
+          @output.puts %({"@id": "#{resource}", "@graph": [)
+          @state = :in_graph
+        end
+        @current_graph = resource
       end
-      @current_graph = resource
-    end
 
-    def end_graph
-      #log_debug("end_graph") {"state: #{@state.inspect}, ctx: #{@current_graph}"}
-      end_node
-      if @current_graph
+      def end_graph
+        # log_debug("end_graph") {"state: #{@state.inspect}, ctx: #{@current_graph}"}
+        end_node
+        return unless @current_graph
+
         @output.write %(]})
         @state = :wrote_graph
       end
-    end
 
-    def end_node
-      #log_debug("end_node") {"state: #{@state.inspect}, node: #{@current_node_def.to_json}"}
-      @output.puts(",") if %i(wrote_node wrote_graph).include?(@state)
-      if @current_node_def
+      def end_node
+        # log_debug("end_node") {"state: #{@state.inspect}, node: #{@current_node_def.to_json}"}
+        @output.puts(",") if %i[wrote_node wrote_graph].include?(@state)
+        return unless @current_node_def
+
         node_def = if context
           compacted = JSON::LD::API.compact(@current_node_def, context, rename_bnodes: false, **@options)
           compacted.delete('@context')

data/lib/json/ld/to_rdf.rb

@@ -1,192 +1,196 @@
-# -*- encoding: utf-8 -*-
 # frozen_string_literal: true
+
 require 'rdf'
 require 'rdf/nquads'
 require 'json/canonicalization'
 
-module JSON::LD
-  module ToRDF
-    include Utils
-
-    ##
-    # @param [Hash{String => Object}] item
-    # @param [RDF::Resource] graph_name
-    # @param [Boolean] quoted emitted triples are quoted triples.
-    # @yield statement
-    # @yieldparam [RDF::Statement] statement
-    # @return RDF::Resource the subject of this item
-    def item_to_rdf(item, graph_name: nil, quoted: false, &block)
-      # Just return value object as Term
-      return unless item
-
-      if value?(item)
-        value, datatype = item.fetch('@value'), item.fetch('@type', nil)
-
-        datatype = RDF::URI(RDF.to_uri + "JSON") if datatype == '@json'
-
-        case value
-        when TrueClass, FalseClass
-          # If value is true or false, then set value its canonical lexical form as defined in the section Data Round Tripping. If datatype is null, set it to xsd:boolean.
-          value = value.to_s
-          datatype ||= RDF::XSD.boolean.to_s
-        when Numeric
-          # Otherwise, if value is a number, then set value to its canonical lexical form as defined in the section Data Round Tripping. If datatype is null, set it to either xsd:integer or xsd:double, depending on if the value contains a fractional and/or an exponential component.
-          value = if datatype == RDF::URI(RDF.to_uri + "JSON")
-            value.to_json_c14n
-          else
-            # Don't serialize as double if there are no fractional bits
-            as_double = value.ceil != value || value >= 1e21 || datatype == RDF::XSD.double
-            lit = if as_double
-              RDF::Literal::Double.new(value, canonicalize: true)
+module JSON
+  module LD
+    module ToRDF
+      include Utils
+
+      ##
+      # @param [Hash{String => Object}] item
+      # @param [RDF::Resource] graph_name
+      # @param [Boolean] quoted emitted triples are quoted triples.
+      # @yield statement
+      # @yieldparam [RDF::Statement] statement
+      # @return RDF::Resource the subject of this item
+      def item_to_rdf(item, graph_name: nil, quoted: false, &block)
+        # Just return value object as Term
+        return unless item
+
+        if value?(item)
+          value = item.fetch('@value')
+          datatype = item.fetch('@type', nil)
+
+          datatype = RDF_JSON if datatype == '@json'
+
+          case value
+          when RDF::Value
+            return value
+          when TrueClass, FalseClass
+            # If value is true or false, then set value its canonical lexical form as defined in the section Data Round Tripping. If datatype is null, set it to xsd:boolean.
+            value = value.to_s
+            datatype ||= RDF::XSD.boolean.to_s
+          when Numeric
+            # Otherwise, if value is a number, then set value to its canonical lexical form as defined in the section Data Round Tripping. If datatype is null, set it to either xsd:integer or xsd:double, depending on if the value contains a fractional and/or an exponential component.
+            value = if datatype == RDF_JSON
+              value.to_json_c14n
             else
-              RDF::Literal.new(value.numerator, canonicalize: true)
+              # Don't serialize as double if there are no fractional bits
+              as_double = value.ceil != value || value >= 1e21 || datatype == RDF::XSD.double
+              lit = if as_double
+                RDF::Literal::Double.new(value, canonicalize: true)
+              else
+                RDF::Literal.new(value.numerator, canonicalize: true)
+              end
+
+              datatype ||= lit.datatype
+              lit.to_s.sub("E+", "E")
             end
-
-            datatype ||= lit.datatype
-            lit.to_s.sub("E+", "E")
-          end
-        when Array, Hash
-          # Only valid for rdf:JSON
-          value = value.to_json_c14n
-        else
-          if item.key?('@direction') && @options[:rdfDirection]
-            # Either serialize using a datatype, or a compound-literal
-            case @options[:rdfDirection]
-            when 'i18n-datatype'
-              datatype = RDF::URI("https://www.w3.org/ns/i18n##{item.fetch('@language', '').downcase}_#{item['@direction']}")
-            when 'compound-literal'
-              cl = RDF::Node.new
-              yield RDF::Statement(cl, RDF.value, item['@value'].to_s)
-              yield RDF::Statement(cl, RDF.to_uri + 'language', item['@language'].downcase) if item['@language']
-              yield RDF::Statement(cl, RDF.to_uri + 'direction', item['@direction'])
-              return cl
+          when Array, Hash
+            # Only valid for rdf:JSON
+            value = value.to_json_c14n
+          else
+            if item.key?('@direction') && @options[:rdfDirection]
+              # Either serialize using a datatype, or a compound-literal
+              case @options[:rdfDirection]
+              when 'i18n-datatype'
+                datatype = RDF::URI("https://www.w3.org/ns/i18n##{item.fetch('@language',
+                  '').downcase}_#{item['@direction']}")
+              when 'compound-literal'
+                cl = RDF::Node.new
+                yield RDF::Statement(cl, RDF.value, item['@value'].to_s)
+                yield RDF::Statement(cl, RDF_LANGUAGE, item['@language'].downcase) if item['@language']
+                yield RDF::Statement(cl, RDF_DIRECTION, item['@direction'])
+                return cl
+              end
             end
-          end
 
-          # Otherwise, if datatype is null, set it to xsd:string or xsd:langString, depending on if item has a @language key.
-          datatype ||= item.key?('@language') ? RDF.langString : RDF::XSD.string
-          if datatype == RDF::URI(RDF.to_uri + "JSON")
-            value = value.to_json_c14n
+            # Otherwise, if datatype is null, set it to xsd:string or xsd:langString, depending on if item has a @language key.
+            datatype ||= item.key?('@language') ? RDF.langString : RDF::XSD.string
+            value = value.to_json_c14n if datatype == RDF_JSON
           end
+          datatype = RDF::URI(datatype) if datatype && !datatype.is_a?(RDF::URI)
+
+          # Initialize literal as an RDF literal using value and datatype. If element has the key @language and datatype is xsd:string, then add the value associated with the @language key as the language of the object.
+          language = item.fetch('@language', nil) if datatype == RDF.langString
+          return RDF::Literal.new(value, datatype: datatype, language: language)
+        elsif list?(item)
+          # If item is a list object, initialize list_results as an empty array, and object to the result of the List Conversion algorithm, passing the value associated with the @list key from item and list_results.
+          return parse_list(item['@list'], graph_name: graph_name, &block)
         end
-        datatype = RDF::URI(datatype) if datatype && !datatype.is_a?(RDF::URI)
-                  
-        # Initialize literal as an RDF literal using value and datatype. If element has the key @language and datatype is xsd:string, then add the value associated with the @language key as the language of the object.
-        language = item.fetch('@language', nil) if datatype == RDF.langString
-        return RDF::Literal.new(value, datatype: datatype, language: language)
-      elsif list?(item)
-        # If item is a list object, initialize list_results as an empty array, and object to the result of the List Conversion algorithm, passing the value associated with the @list key from item and list_results.
-        return parse_list(item['@list'], graph_name: graph_name, &block)
-      end
 
-      subject = case item['@id']
-      when nil then node
-      when String then as_resource(item['@id'])
-      when Object
-        # Embedded/quoted statement
-        # (No error checking, as this is done in expansion)
-        to_enum(:item_to_rdf, item['@id'], quoted: true).to_a.first
-      end
+        subject = case item['@id']
+        when nil then node
+        when String then as_resource(item['@id'])
+        when Object
+          # Embedded/quoted statement
+          # (No error checking, as this is done in expansion)
+          to_enum(:item_to_rdf, item['@id'], quoted: true).to_a.first
+        end
 
-      #log_debug("item_to_rdf")  {"subject: #{subject.to_ntriples rescue 'malformed rdf'}"}
-      item.each do |property, values|
-        case property
-        when '@type'
-          # If property is @type, construct triple as an RDF Triple composed of id, rdf:type, and object from values where id and object are represented either as IRIs or Blank Nodes
-          values.each do |v|
-            object = as_resource(v)
-            #log_debug("item_to_rdf")  {"type: #{object.to_ntriples rescue 'malformed rdf'}"}
-            yield RDF::Statement(subject, RDF.type, object, graph_name: graph_name, quoted: quoted)
-          end
-        when '@graph'
-          values = [values].compact unless values.is_a?(Array)
-          values.each do |nd|
-            item_to_rdf(nd, graph_name: subject, quoted: quoted, &block)
-          end
-        when '@reverse'
-          raise "Huh?" unless values.is_a?(Hash)
-          values.each do |prop, vv|
-            predicate = as_resource(prop)
-            #log_debug("item_to_rdf")  {"@reverse predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
-            # For each item in values
-            vv.each do |v|
-              # Item is a node definition. Generate object as the result of the Object Converstion algorithm passing item.
-              object = item_to_rdf(v, graph_name: graph_name, &block)
-              #log_debug("item_to_rdf")  {"subject: #{object.to_ntriples rescue 'malformed rdf'}"}
-              # yield subject, prediate, and literal to results.
-              yield RDF::Statement(object, predicate, subject, graph_name: graph_name, quoted: quoted)
+        # log_debug("item_to_rdf")  {"subject: #{subject.to_ntriples rescue 'malformed rdf'}"}
+        item.each do |property, values|
+          case property
+          when '@type'
+            # If property is @type, construct triple as an RDF Triple composed of id, rdf:type, and object from values where id and object are represented either as IRIs or Blank Nodes
+            values.each do |v|
+              object = as_resource(v)
+              # log_debug("item_to_rdf")  {"type: #{object.to_ntriples rescue 'malformed rdf'}"}
+              yield RDF::Statement(subject, RDF.type, object, graph_name: graph_name, quoted: quoted)
             end
-          end
-        when '@included'
-          values.each do |v|
-            item_to_rdf(v, graph_name: graph_name, &block)
-          end
-        when /^@/
-          # Otherwise, if @type is any other keyword, skip to the next property-values pair
-        else
-          # Otherwise, property is an IRI or Blank Node identifier
-          # Initialize predicate from  property as an IRI or Blank node
-          predicate = as_resource(property)
-          #log_debug("item_to_rdf")  {"predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
-
-          # For each item in values
-          values.each do |v|
-            if list?(v)
-              #log_debug("item_to_rdf")  {"list: #{v.inspect}"}
-              # If item is a list object, initialize list_results as an empty array, and object to the result of the List Conversion algorithm, passing the value associated with the @list key from item and list_results.
-              object = parse_list(v['@list'], graph_name: graph_name, &block)
-
-              # Append a triple composed of subject, prediate, and object to results and add all triples from list_results to results.
-              yield RDF::Statement(subject, predicate, object, graph_name: graph_name, quoted: quoted)
-            else
-              # Otherwise, item is a value object or a node definition. Generate object as the result of the Object Converstion algorithm passing item.
-              object = item_to_rdf(v, graph_name: graph_name, &block)
-              #log_debug("item_to_rdf")  {"object: #{object.to_ntriples rescue 'malformed rdf'}"}
-              # yield subject, prediate, and literal to results.
+          when '@graph'
+            values = [values].compact unless values.is_a?(Array)
+            values.each do |nd|
+              item_to_rdf(nd, graph_name: subject, quoted: quoted, &block)
+            end
+          when '@reverse'
+            raise "Huh?" unless values.is_a?(Hash)
+
+            values.each do |prop, vv|
+              predicate = as_resource(prop)
+              # log_debug("item_to_rdf")  {"@reverse predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
+              # For each item in values
+              vv.each do |v|
+                # Item is a node definition. Generate object as the result of the Object Converstion algorithm passing item.
+                object = item_to_rdf(v, graph_name: graph_name, &block)
+                # log_debug("item_to_rdf")  {"subject: #{object.to_ntriples rescue 'malformed rdf'}"}
+                # yield subject, prediate, and literal to results.
+                yield RDF::Statement(object, predicate, subject, graph_name: graph_name, quoted: quoted)
+              end
+            end
+          when '@included'
+            values.each do |v|
+              item_to_rdf(v, graph_name: graph_name, &block)
+            end
+          when /^@/
+            # Otherwise, if @type is any other keyword, skip to the next property-values pair
+          else
+            # Otherwise, property is an IRI or Blank Node identifier
+            # Initialize predicate from  property as an IRI or Blank node
+            predicate = as_resource(property)
+            # log_debug("item_to_rdf")  {"predicate: #{predicate.to_ntriples rescue 'malformed rdf'}"}
+
+            # For each item in values
+            values.each do |v|
+              if list?(v)
+                # log_debug("item_to_rdf")  {"list: #{v.inspect}"}
+                # If item is a list object, initialize list_results as an empty array, and object to the result of the List Conversion algorithm, passing the value associated with the @list key from item and list_results.
+                object = parse_list(v['@list'], graph_name: graph_name, &block)
+
+                # Append a triple composed of subject, prediate, and object to results and add all triples from list_results to results.
+              else
+                # Otherwise, item is a value object or a node definition. Generate object as the result of the Object Converstion algorithm passing item.
+                object = item_to_rdf(v, graph_name: graph_name, &block)
+                # log_debug("item_to_rdf")  {"object: #{object.to_ntriples rescue 'malformed rdf'}"}
+                # yield subject, prediate, and literal to results.
+              end
               yield RDF::Statement(subject, predicate, object, graph_name: graph_name, quoted: quoted)
             end
           end
         end
-      end
-
-      subject
-    end
 
-    ##
-    # Parse a List
-    #
-    # @param [Array] list
-    #   The Array to serialize as a list
-    # @yield statement
-    # @yieldparam [RDF::Resource] statement
-    # @return [Array<RDF::Statement>]
-    #   Statements for each item in the list
-    def parse_list(list, graph_name: nil, &block)
-      #log_debug('parse_list') {"list: #{list.inspect}"}
-
-      last = list.pop
-      result = first_bnode = last ? node : RDF.nil
-
-      list.each do |list_item|
-        # Set first to the result of the Object Converstion algorithm passing item.
-        object = item_to_rdf(list_item, graph_name: graph_name, &block)
-        yield RDF::Statement(first_bnode, RDF.first, object, graph_name: graph_name)
-        rest_bnode = node
-        yield RDF::Statement(first_bnode, RDF.rest, rest_bnode, graph_name: graph_name)
-        first_bnode = rest_bnode
+        subject
       end
-      if last
-        object = item_to_rdf(last, graph_name: graph_name, &block)
-        yield RDF::Statement(first_bnode, RDF.first, object, graph_name: graph_name)
-        yield RDF::Statement(first_bnode, RDF.rest, RDF.nil, graph_name: graph_name)
+
+      ##
+      # Parse a List
+      #
+      # @param [Array] list
+      #   The Array to serialize as a list
+      # @yield statement
+      # @yieldparam [RDF::Resource] statement
+      # @return [Array<RDF::Statement>]
+      #   Statements for each item in the list
+      def parse_list(list, graph_name: nil, &block)
+        # log_debug('parse_list') {"list: #{list.inspect}"}
+
+        last = list.pop
+        result = first_bnode = last ? node : RDF.nil
+
+        list.each do |list_item|
+          # Set first to the result of the Object Converstion algorithm passing item.
+          object = item_to_rdf(list_item, graph_name: graph_name, &block)
+          yield RDF::Statement(first_bnode, RDF.first, object, graph_name: graph_name)
+          rest_bnode = node
+          yield RDF::Statement(first_bnode, RDF.rest, rest_bnode, graph_name: graph_name)
+          first_bnode = rest_bnode
+        end
+        if last
+          object = item_to_rdf(last, graph_name: graph_name, &block)
+          yield RDF::Statement(first_bnode, RDF.first, object, graph_name: graph_name)
+          yield RDF::Statement(first_bnode, RDF.rest, RDF.nil, graph_name: graph_name)
+        end
+        result
       end
-      result
-    end
 
-    ##
-    # Create a new named node using the sequence
-    def node
-      RDF::Node.new(namer.get_sym)
+      ##
+      # Create a new named node using the sequence
+      def node
+        RDF::Node.new(namer.get_sym)
+      end
     end
   end
 end