json-ld 3.1.6 → 3.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2509fe2ee3a0766a3e332d062f11ad05d02bf7a3c00e423dfe4ac8eec23f9746
-  data.tar.gz: 277416c70b52a06ec85d89394fe18ccbe9eacb53538a6c65432ed390728b93ca
+  metadata.gz: 0324a9e3b617b6dabe52c3f36c81e4b7fc4b78eaab9450510f45a760933064ba
+  data.tar.gz: 7cf759dd5940a052969477e50c50bb0dc31d7cac38a5ccc8e1bdc046e3994a43
 SHA512:
-  metadata.gz: 20db323ff35ccd493d9fbd0b6f73f4c5fc517678363aff6fbf21f114ce33e2e491f4717e87c3ad3f2a19c31beb728c627b00cb7f8bff268575c6655cc29e6ff2
-  data.tar.gz: da506865a8f17c2fc304159bfb61411d11c433b656ea58bf1b19371618a2c0f02c08274f8a5a6ca97f1f9087a7d797b9be087314fd0cd41e154fe53721fcb6d8
+  metadata.gz: 9d427823af59053d28e4999984f698cde37229fb9a3336a22f06517bcc65fbf80527a535b50dd28eaeca1e5d67e38d0d140dbace8854b9a62944f8ba149ea61c
+  data.tar.gz: 83ba9860d9b7fe72924c9469a26bd5337a051003396b02fdcf5ae9e4b2bbd13940c37d7b4d95c16b427248fda64fa799551c3dcf5c767436e804ea89fba03b4f

data/README.md

@@ -4,7 +4,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/json-ld.png)](https://rubygems.org/gems/json-ld)
 [![Build Status](https://secure.travis-ci.org/ruby-rdf/json-ld.png?branch=develop)](https://github.com/ruby-rdf/json-ld/actions?query=workflow%3ACI)
-[![Coverage Status](https://coveralls.io/repos/ruby-rdf/json-ld/badge.svg)](https://coveralls.io/github/ruby-rdf/json-ld)
+[![Coverage Status](https://coveralls.io/repos/ruby-rdf/json-ld/badge.svg?branch=develop)](https://coveralls.io/github/ruby-rdf/json-ld?branch=develop)
 [![Gitter chat](https://badges.gitter.im/ruby-rdf.png)](https://gitter.im/gitterHQ/gitter)
 
 ## Features
@@ -14,10 +14,10 @@ JSON::LD parses and serializes [JSON-LD][] into [RDF][] and implements expansion
 JSON::LD can now be used to create a _context_ from an RDFS/OWL definition, and optionally include a JSON-LD representation of the ontology itself. This is currently accessed through the `script/gen_context` script.
 
 * If the [jsonlint][] gem is installed, it will be used when validating an input document.
-* If available, uses [Nokogiri][] and/or [Nokogumbo][] for parsing HTML, falls back to REXML otherwise.
-* Provisional support for [JSON-LD*][JSON-LD*].
+* If available, uses [Nokogiri][] for parsing HTML, falls back to REXML otherwise.
+* Provisional support for [JSON-LD-star][JSON-LD-star].
 
-[Implementation Report](file.earl.html)
+[Implementation Report](https://ruby-rdf.github.io/json-ld/etc/earl.html)
 
 Install with `gem install json-ld`
 
@@ -37,9 +37,9 @@ The order of triples retrieved from the `RDF::Enumerable` dataset determines the
 ### MultiJson parser
 The [MultiJson](https://rubygems.org/gems/multi_json) gem is used for parsing JSON; this defaults to the native JSON parser, but will use a more performant parser if one is available. A specific parser can be specified by adding the `:adapter` option to any API call. See [MultiJson](https://rubygems.org/gems/multi_json) for more information.
 
-### JSON-LD* (RDFStar)
+### JSON-LD-star (RDFStar)
 
-The {JSON::LD::API.toRdf} and {JSON::LD::API.fromRdf} API methods, along with the {JSON::LD::Reader} and {JSON::LD::Writer}, include provisional support for [JSON-LD*][JSON-LD*].
+The {JSON::LD::API.expand}, {JSON::LD::API.compact}, {JSON::LD::API.toRdf}, and {JSON::LD::API.fromRdf} API methods, along with the {JSON::LD::Reader} and {JSON::LD::Writer}, include provisional support for [JSON-LD-star][JSON-LD-star].
 
 Internally, an `RDF::Statement` is treated as another resource, along with `RDF::URI` and `RDF::Node`, which allows an `RDF::Statement` to have a `#subject` or `#object` which is also an `RDF::Statement`.
 
@@ -55,6 +55,19 @@ In JSON-LD, with the `rdfstar` option set, the value of `@id`, in addition to an
       "ex:certainty": 0.9
     }
 
+Additionally, the `@annotation` property (or alias) may be used on a node object or value object to annotate the statement for which the associated node is the object of a triple.
+
+    {
+      "@context": {"foaf": "http://xmlns.com/foaf/0.1/"},
+      "@id": "bob",
+      "foaf:age" 23,
+      "@annotation": {
+        "ex:certainty": 0.9
+      }
+    }
+
+In the first case, the embedded node is not asserted, and only appears as the subject of a triple. In the second case, the triple is asserted and used as the subject in another statement which annotates it.
+
 **Note: This feature is subject to change or elimination as the standards process progresses.**
 
 #### Serializing a Graph containing embedded statements
@@ -623,7 +636,7 @@ see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [YARD-GS]:          https://rubydoc.info/docs/yard/file/docs/GettingStarted.md
 [PDD]:              https://unlicense.org/#unlicensing-contributions
 [RDF.rb]:           https://rubygems.org/gems/rdf
-[JSON-LD*]:             https://json-ld.github.io/json-ld-star/
+[JSON-LD-star]:             https://json-ld.github.io/json-ld-star/
 [Rack::LinkedData]: https://rubygems.org/gems/rack-linkeddata
 [Backports]:        https://rubygems.org/gems/backports
 [JSON-LD]:          https://www.w3.org/TR/json-ld11/ "JSON-LD 1.1"

data/VERSION

@@ -1 +1 @@
-3.1.6
+3.1.10

data/bin/jsonld

@@ -24,36 +24,36 @@ def run(input, options, parser_options)
 
   start = Time.new
   if options[:expand]
-    parser_options = parser_options.merge(expandContext: parser_options.delete(:context)) if parser_options.has_key?(:context)
+    parser_options = parser_options.merge(expandContext: parser_options.delete(:context)) if parser_options.key?(:context)
     input = JSON::LD::API.fromRdf(reader) if reader
-    output = JSON::LD::API.expand(input, parser_options)
+    output = JSON::LD::API.expand(input, **parser_options)
     secs = Time.new - start
     options[:output].puts output.to_json(JSON::LD::JSON_STATE)
     STDERR.puts "Expanded in #{secs} seconds." unless options[:quiet]
   elsif options[:compact]
     input = JSON::LD::API.fromRdf(reader) if reader
-    output = JSON::LD::API.compact(input, parser_options[:context], parser_options)
+    output = JSON::LD::API.compact(input, parser_options[:context], **parser_options)
     secs = Time.new - start
     options[:output].puts output.to_json(JSON::LD::JSON_STATE)
     STDERR.puts "Compacted in #{secs} seconds." unless options[:quiet]
   elsif options[:flatten]
     input = JSON::LD::API.fromRdf(reader) if reader
-    output = JSON::LD::API.flatten(input, parser_options[:context], parser_options)
+    output = JSON::LD::API.flatten(input, parser_options[:context], **parser_options)
     secs = Time.new - start
     options[:output].puts output.to_json(JSON::LD::JSON_STATE)
     STDERR.puts "Flattened in #{secs} seconds." unless options[:quiet]
   elsif options[:frame]
     input = JSON::LD::API.fromRdf(reader) if reader
-    output = JSON::LD::API.frame(input, parser_options[:frame], parser_options)
+    output = JSON::LD::API.frame(input, parser_options[:frame], **parser_options)
     secs = Time.new - start
     options[:output].puts output.to_json(JSON::LD::JSON_STATE)
     STDERR.puts "Framed in #{secs} seconds." unless options[:quiet]
   else
-    parser_options = parser_options.merge(expandContext: parser_options.delete(:context)) if parser_options.has_key?(:context)
+    parser_options = parser_options.merge(expandContext: parser_options.delete(:context)) if parser_options.key?(:context)
     parser_options[:standard_prefixes] = true
-    reader ||= JSON::LD::Reader.new(input, parser_options)
+    reader ||= JSON::LD::Reader.new(input, **parser_options)
     num = 0
-    RDF::Writer.for(options[:output_format]).new(options[:output], parser_options) do |w|
+    RDF::Writer.for(options[:output_format]).new(options[:output], **parser_options) do |w|
       reader.each do |statement|
         num += 1
         w << statement
@@ -113,6 +113,7 @@ OPT_ARGS = [
   ["--processingMode",GetoptLong::REQUIRED_ARGUMENT,"Set processing mode, defaults to json-ld-1.1"],
   ["--quiet",         GetoptLong::NO_ARGUMENT,      "Supress most output other than progress indicators"],
   ["--rename_bnodes", GetoptLong::OPTIONAL_ARGUMENT,"Rename bnodes as part of expansion, or keep them the same"],
+  ["--rdfstar",       GetoptLong::NO_ARGUMENT,      "Parse JSON-LD-star"],
   ["--requireAll",    GetoptLong::OPTIONAL_ARGUMENT,"Rename bnodes as part of expansion, or keep them the same"],
   ["--stream",        GetoptLong::NO_ARGUMENT,      "Use Streaming reader/writer"],
   ["--unique_bnodes", GetoptLong::OPTIONAL_ARGUMENT,"Use unique bnode identifiers"],
@@ -140,7 +141,7 @@ opts = GetoptLong.new(*OPT_ARGS.map {|o| o[0..-2]})
 opts.each do |opt, arg|
   case opt
   when '--debug'          then logger.level = Logger::DEBUG
-  when '--compact'        then parser_options[:compact] = true
+  when '--compact'        then options[:compact] = true
   when "--compactArrays"  then parser_options[:compactArrays] = (arg || 'true') == 'true'
   when '--context'        then parser_options[:context] = RDF::URI(arg).absolute? ? arg : File.open(arg)
   when '--evaluate'       then input = arg
@@ -158,6 +159,7 @@ opts.each do |opt, arg|
   when '--quiet'
     options[:quiet] = true
     logger.level = Logger::FATAL
+  when "--rdfstar"        then parser_options[:rdfstar] = true
   when "--rename_bnodes"  then parser_options[:rename_bnodes] = (arg || 'true') == 'true'
   when "--requireAll"     then parser_options[:requireAll] = (arg || 'true') == 'true'
   when '--stream'         then parser_options[:stream] = true
@@ -181,7 +183,7 @@ opts.each do |opt, arg|
 end
 
 # Hack
-if !(options.keys & [:expand, :compact, :flatten, :frame]).empty? &&
+if !(options.keys & %i{expand compact flatten frame}).empty? &&
    (parser_options[:stream] || options[:output_format] != :jsonld)
    STDERR.puts "Incompatible options"
    exit(1)
@@ -193,7 +195,7 @@ if ARGV.empty?
 else
   ARGV.each do |file|
     # Call with opened files
-    RDF::Util::File.open_file(file, options) {|f| run(f, options, parser_options)}
+    RDF::Util::File.open_file(file, **options) {|f| run(f, options, parser_options)}
   end
 end
 puts

data/lib/json/ld/api.rb

@@ -90,7 +90,7 @@ module JSON::LD
     #   Processing mode, json-ld-1.0 or json-ld-1.1.
     #   If `processingMode` is not specified, a mode of `json-ld-1.0` or `json-ld-1.1` is set, the context used for `expansion` or `compaction`.
     # @option options [Boolean] rdfstar      (false)
-    #   support parsing JSON-LD* statement resources.
+    #   support parsing JSON-LD-star statement resources.
     # @option options [Boolean] :rename_bnodes (true)
     #   Rename bnodes as part of expansion, or keep them the same.
     # @option options [Boolean]  :unique_bnodes   (false)
@@ -102,13 +102,15 @@ module JSON::LD
     # @yield [api]
     # @yieldparam [API]
     # @raise [JsonLdError]
-    def initialize(input, context, rename_bnodes: true, unique_bnodes: false, **options, &block)
+    def initialize(input, context, **options, &block)
       @options = {
         compactArrays:      true,
         ordered:            false,
         extractAllScripts:  false,
+        rename_bnodes:      true,
+        unique_bnodes:      false,
       }.merge(options)
-      @namer = unique_bnodes ? BlankNodeUniqer.new : (rename_bnodes ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
+      @namer = @options[:unique_bnodes] ? BlankNodeUniqer.new : (@options[:rename_bnodes] ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
 
       @options[:base] = RDF::URI(@options[:base]) if @options[:base] && !@options[:base].is_a?(RDF::URI)
       # For context via Link header
@@ -202,9 +204,9 @@ module JSON::LD
     #   The JSON-LD object to copy and perform the compaction upon.
     # @param [String, #read, Hash, Array, JSON::LD::Context] context
     #   The base context to use when compacting the input.
+    # @param [Boolean] expanded (false) Input is already expanded
     # @param  [Hash{Symbol => Object}] options
     # @option options (see #initialize)
-    # @option options [Boolean] :expanded Input is already expanded
     # @yield jsonld
     # @yieldparam [Hash] jsonld
     #   The compacted JSON-LD document
@@ -248,9 +250,11 @@ module JSON::LD
     #   The JSON-LD object or array of JSON-LD objects to flatten or an IRI referencing the JSON-LD document to flatten.
     # @param [String, #read, Hash, Array, JSON::LD::EvaluationContext] context
     #   An optional external context to use additionally to the context embedded in input when expanding the input.
+    # @param [Boolean] expanded (false) Input is already expanded
     # @param  [Hash{Symbol => Object}] options
     # @option options (see #initialize)
-    # @option options [Boolean] :expanded Input is already expanded
+    # @option options [Boolean] :createAnnotations
+    #   Unfold embedded nodes which can be represented using `@annotation`.
     # @yield jsonld
     # @yieldparam [Hash] jsonld
     #   The flattened JSON-LD document
@@ -275,10 +279,20 @@ module JSON::LD
       API.new(expanded_input, context, no_default_base: true, **options) do
         log_debug(".flatten") {"expanded input: #{value.to_json(JSON_STATE) rescue 'malformed json'}"}
 
+        # Rename blank nodes recusively. Note that this does not create new blank node identifiers where none exist, which is performed in the node map generation algorithm.
+        @value = rename_bnodes(@value) if @options[:rename_bnodes]
+
         # Initialize node map to a JSON object consisting of a single member whose key is @default and whose value is an empty JSON object.
         graph_maps = {'@default' => {}}
         create_node_map(value, graph_maps)
 
+        # If create annotations flag is set, then update each node map in graph maps with the result of calling the create annotations algorithm.
+        if options[:createAnnotations]
+          graph_maps.values.each do |node_map|
+            create_annotations(node_map)
+          end
+        end
+
         default_graph = graph_maps['@default']
         graph_maps.keys.opt_sort(ordered: @options[:ordered]).each do |graph_name|
           next if graph_name == '@default'
@@ -297,7 +311,7 @@ module JSON::LD
         if context && !flattened.empty?
           # Otherwise, return the result of compacting flattened according the Compaction algorithm passing context ensuring that the compaction result uses the @graph keyword (or its alias) at the top-level, even if the context is empty or if there is only one element to put in the @graph array. This ensures that the returned document has a deterministic structure.
           compacted = as_array(compact(flattened))
-          kwgraph = self.context.compact_iri('@graph')
+          kwgraph = self.context.compact_iri('@graph', vocab: true)
           flattened = self.context.
             serialize(provided_context: context).
             merge(kwgraph => compacted)
@@ -316,6 +330,7 @@ module JSON::LD
     #   The JSON-LD object to copy and perform the framing on.
     # @param [String, #read, Hash, Array] frame
     #   The frame to use when re-arranging the data.
+    # @param [Boolean] expanded (false) Input is already expanded
     # @option options (see #initialize)
     # @option options ['@always', '@link', '@once', '@never'] :embed ('@once')
     #   a flag specifying that objects should be directly embedded in the output, instead of being referred to by their IRI.
@@ -325,7 +340,6 @@ module JSON::LD
     #   A flag specifying that all properties present in the input frame must either have a default value or be present in the JSON-LD input for the frame to match.
     # @option options [Boolean] :omitDefault (false)
     #   a flag specifying that properties that are missing from the JSON-LD input should be omitted from the output.
-    # @option options [Boolean] :expanded Input is already expanded
     # @option options [Boolean] :pruneBlankNodeIdentifiers (true) removes blank node identifiers that are only used once.
     # @option options [Boolean] :omitGraph does not use `@graph` at top level unless necessary to describe multiple objects, defaults to `true` if processingMode is 1.1, otherwise `false`.
     # @yield jsonld
@@ -391,10 +405,13 @@ module JSON::LD
         end
 
         # Set omitGraph option, if not present, based on processingMode
-        unless options.has_key?(:omitGraph)
+        unless options.key?(:omitGraph)
           options[:omitGraph] = context.processingMode('json-ld-1.1')
         end
 
+        # Rename blank nodes recusively. Note that this does not create new blank node identifiers where none exist, which is performed in the node map generation algorithm.
+        @value = rename_bnodes(@value)
+
         # Get framing nodes from expanded input, replacing Blank Node identifiers as necessary
         create_node_map(value, framing_state[:graphMap], active_graph: '@default')
 
@@ -415,7 +432,7 @@ module JSON::LD
         frame(framing_state, framing_state[:subjects].keys.opt_sort(ordered: @options[:ordered]), (expanded_frame.first || {}), parent: result, **options)
 
         # Default to based on processinMode
-        if !options.has_key?(:pruneBlankNodeIdentifiers)
+        if !options.key?(:pruneBlankNodeIdentifiers)
           options[:pruneBlankNodeIdentifiers] = context.processingMode('json-ld-1.1')
         end
 
@@ -440,7 +457,7 @@ module JSON::LD
         result = if !compacted.is_a?(Array)
           compacted
         else
-          kwgraph = context.compact_iri('@graph')
+          kwgraph = context.compact_iri('@graph', vocab: true)
           {kwgraph => compacted}
         end
         # Only add context if one was provided
@@ -458,10 +475,10 @@ module JSON::LD
     #
     # @param [String, #read, Hash, Array] input
     #   The JSON-LD object to process when outputting statements.
+    # @param [Boolean] expanded (false) Input is already expanded
     # @option options (see #initialize)
     # @option options [Boolean] :produceGeneralizedRdf (false)
     #   If true, output will include statements having blank node predicates, otherwise they are dropped.
-    # @option options [Boolean] :expanded Input is already expanded
     # @raise [JsonLdError]
     # @yield statement
     # @yieldparam [RDF::Statement] statement
@@ -470,7 +487,7 @@ module JSON::LD
       unless block_given?
         results = []
         results.extend(RDF::Enumerable)
-        self.toRdf(input, **options) do |stmt|
+        self.toRdf(input, expanded: expanded, **options) do |stmt|
           results << stmt
         end
         return results
@@ -480,16 +497,16 @@ module JSON::LD
         extractAllScripts:  true,
       }.merge(options)
 
-      # Expand input to simplify processing
-      expanded_input = expanded ? input : API.expand(input, ordered: false, **options)
+      # Flatten input to simplify processing
+      flattened_input = API.flatten(input, nil, expanded: expanded, ordered: false, **options)
 
-      API.new(expanded_input, nil, **options) do
+      API.new(flattened_input, nil, **options) do
         # 1) Perform the Expansion Algorithm on the JSON-LD input.
         #    This removes any existing context to allow the given context to be cleanly applied.
-        log_debug(".toRdf") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
+        log_debug(".toRdf") {"flattened input: #{flattened_input.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Recurse through input
-        expanded_input.each do |node|
+        flattened_input.each do |node|
           item_to_rdf(node) do |statement|
             next if statement.predicate.node? && !options[:produceGeneralizedRdf]
 

data/lib/json/ld/compact.rb

@@ -64,7 +64,7 @@ module JSON::LD
           log_debug("prop-scoped", depth: log_depth.to_i) {"context: #{self.context.inspect}"}
         end
 
-        if element.key?('@id') || element.key?('@value')
+        if (element.key?('@id') || element.key?('@value')) && !element.key?('@annotation')
           result = context.compact_value(property, element, base: @options[:base])
           if !result.is_a?(Hash) || context.coerce(property) == '@json'
             log_debug("", depth: log_depth.to_i) {"=> scalar result: #{result.inspect}"}
@@ -98,8 +98,15 @@ module JSON::LD
           log_debug("", depth: log_depth.to_i) {"#{expanded_property}: #{expanded_value.inspect}"}
 
           if expanded_property == '@id'
-            compacted_value = Array(expanded_value).map do |expanded_id|
-              context.compact_iri(expanded_id, base: @options[:base])
+            compacted_value = as_array(expanded_value).map do |expanded_id|
+              if node?(expanded_id) && @options[:rdfstar]
+                # This can only really happen for valid RDF-star
+                compact(expanded_id, base: base,
+                        property: '@id',
+                        log_depth: log_depth.to_i + 1)
+              else
+                context.compact_iri(expanded_id, base: @options[:base])
+              end
             end
 
             kw_alias = context.compact_iri('@id', vocab: true)
@@ -138,7 +145,7 @@ module JSON::LD
             end
 
             unless compacted_value.empty?
-              al = context.compact_iri('@reverse')
+              al = context.compact_iri('@reverse', vocab: true)
               log_debug("", depth: log_depth.to_i) {"remainder: #{al} => #{compacted_value.inspect}"}
               result[al] = compacted_value
             end
@@ -224,7 +231,7 @@ module JSON::LD
               unless container.include?('@list')
                 al = context.compact_iri('@list', vocab: true)
                 compacted_item = {al => compacted_item}
-                if expanded_item.has_key?('@index')
+                if expanded_item.key?('@index')
                   key = context.compact_iri('@index', vocab: true)
                   compacted_item[key] = expanded_item['@index']
                 end
@@ -269,7 +276,7 @@ module JSON::LD
                   al = context.compact_iri('@id', vocab: true)
                   compacted_item[al] = context.compact_iri(expanded_item['@id'], vocab: false)
                 end
-                if expanded_item.has_key?('@index')
+                if expanded_item.key?('@index')
                   key = context.compact_iri('@index', vocab: true)
                   compacted_item[key] = expanded_item['@index']
                 end
@@ -290,6 +297,7 @@ module JSON::LD
                 if index_key == '@index'
                   map_key = expanded_item['@index']
                 else
+                  index_key = context.expand_iri(index_key, vocab: true)
                   container_key = context.compact_iri(index_key, vocab: true)
                   map_key, *others = Array(compacted_item[container_key])
                   if map_key.is_a?(String)