json-ld 2.2.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8da5138b7c0078bf7da59b61dfdc302c363c49ad
-  data.tar.gz: 512ae330ada362f55597cc3cc5d2d2fb14875d4b
+SHA256:
+  metadata.gz: 33d72fb295b05e075532454ade144d79cf15458946492639f9a941a62668c510
+  data.tar.gz: a382b3bdf08bc1b377d5d01f8d2bae93631e7f9077161fd6bbddfd7477a4c775
 SHA512:
-  metadata.gz: 7ef0402a7b79e8e9bd24195a5026659cf6e50dd714aeb154bbce0dab447e491be86eaa4a250ef2457e3eb1af0a811858226cd09d32c0107f2c75400873b5d805
-  data.tar.gz: 664a8bcff91f18cb804c8c69a7fc44e40219fdca8c619695e6a69ef6f6d4362e90e9e3cc6f4c33bab412f75ab87e6aee2a732ffc8eb632686df53c7a4afbb1f4
+  metadata.gz: fea935d4ce21a779b4d6eb2bd38eaf8f0859b4e312b8baa509e3325663597cffcef934e3210dda62e339b08d86dc689458fc331b5edf86e500b28ffbe4679548
+  data.tar.gz: 1d589f193efd2725ac4ac4d200de04fea6d13296fa7ad3989cf40cfed30424dd91dfb27ced0eda4ce88d0f5676e90b36e5b4cff8185afac9644fd3cc7edd7c0a

data/README.md

@@ -28,13 +28,13 @@ This gem implements an optimized streaming writer used for generating JSON-LD fr
 * RDF Lists are written as separate nodes using `rdf:first` and `rdf:rest` properties.
 
 ## Examples
-
-    require 'rubygems'
-    require 'json/ld'
-
+```ruby
+require 'rubygems'
+require 'json/ld'
+ ```
 ### Expand a Document
-
-    input = JSON.parse %({
+```ruby
+   input = JSON.parse %({
       "@context": {
         "name": "http://xmlns.com/foaf/0.1/name",
         "homepage": "http://xmlns.com/foaf/0.1/homepage",
@@ -51,9 +51,9 @@ This gem implements an optimized streaming writer used for generating JSON-LD fr
         "http://xmlns.com/foaf/0.1/homepage": [{"@value"=>"http://manu.sporny.org/"}], 
         "http://xmlns.com/foaf/0.1/avatar": [{"@value": "http://twitter.com/account/profile_image/manusporny"}]
     }]
-
+```
 ### Compact a Document
-
+```ruby
     input = JSON.parse %([{
         "http://xmlns.com/foaf/0.1/name": ["Manu Sporny"],
         "http://xmlns.com/foaf/0.1/homepage": [{"@id": "http://manu.sporny.org/"}],
@@ -79,9 +79,9 @@ This gem implements an optimized streaming writer used for generating JSON-LD fr
         "homepage": "http://manu.sporny.org/",
         "name": "Manu Sporny"
     }
-
+```
 ### Frame a Document
-
+```ruby
     input = JSON.parse %({
       "@context": {
         "Book":         "http://example.org/vocab#Book",
@@ -162,9 +162,9 @@ This gem implements an optimized streaming writer used for generating JSON-LD fr
         }
       ]
     }
-
+```
 ### Turn JSON-LD into RDF (Turtle)
-
+```ruby
     input = JSON.parse %({
       "@context": {
         "":       "http://manu.sporny.org/",
@@ -185,9 +185,9 @@ This gem implements an optimized streaming writer used for generating JSON-LD fr
     <http://example.org/people#joebob> a foaf:Person;
        foaf:name "Joe Bob";
        foaf:nick ("joe" "bob" "jaybe") .
-
+```
 ### Turn RDF into JSON-LD
-
+```ruby
     require 'rdf/turtle'
     input = RDF::Graph.new << RDF::Turtle::Reader.new(%(
       @prefix foaf: <http://xmlns.com/foaf/0.1/> .
@@ -223,12 +223,12 @@ This gem implements an optimized streaming writer used for generating JSON-LD fr
           "http://xmlns.com/foaf/0.1/name": [{"@value": "Manu Sporny"}]
         }
       ]
-
+```
 ## Use a custom Document Loader
 In some cases, the built-in document loader {JSON::LD::API.documentLoader} is inadequate; for example, when using `http://schema.org` as a remote context, it will be re-loaded every time.
 
 All entries into the {JSON::LD::API} accept a `:documentLoader` option, which can be used to provide an alternative method to use when loading remote documents. For example:
-
+```ruby
     def load_document_local(url, options={}, &block)
       if RDF::URI(url, canonicalize: true) == RDF::URI('http://schema.org/')
         remote_document = JSON::LD::API::RemoteDocument.new(url, File.read("etc/schema.org.jsonld"))
@@ -237,28 +237,28 @@ All entries into the {JSON::LD::API} accept a `:documentLoader` option, which ca
         JSON::LD::API.documentLoader(url, options, &block)
       end
     end
-
+```
 Then, when performing something like expansion:
-
+```ruby
     JSON::LD::API.expand(input, documentLoader: load_document_local)
-
+```
 
 ## Preloading contexts
 In many cases, for small documents, processing time can be dominated by loading and parsing remote contexts. In particular, a small schema.org example may need to download a large context and turn it into an internal representation, before the actual document can be expanded for processing. Using {JSON::LD::Context.add_preloaded}, an implementation can perform this loading up-front, and make it available to the processor.
-
+```ruby
     ctx = JSON::LD::Context.new().parse('http://schema.org/')
     JSON::LD::Context.add_preloaded('http://schema.org/', ctx)
-
+ ```
 On lookup, URIs with an `https` prefix are normalized to `http`.
 
 A context may be serialized to Ruby to speed this process using `Context#to_rb`. When loaded, this generated file will add entries to the {JSON::LD::Context::PRELOADED}.
 
 ## RDF Reader and Writer
 {JSON::LD} also acts as a normal RDF reader and writer, using the standard RDF.rb reader/writer interfaces:
-
+```ruby
     graph = RDF::Graph.load("etc/doap.jsonld", format: :jsonld)
     graph.dump(:jsonld, standard_prefixes: true)
-
+```
 `RDF::GRAPH#dump` can also take a `:context` option to use a separately defined context
 
 As JSON-LD may come from many different sources, included as an embedded script tag within an HTML document, the RDF Reader will strip input before the leading `{` or `[` and after the trailing `}` or `]`.
@@ -268,7 +268,7 @@ This implementation is being used as a test-bed for features planned for an upco
 
 ### Scoped Contexts
 A term definition can include `@context`, which is applied to values of that object. This is also used when compacting. Taken together, this allows framing to effectively include context definitions more deeply within the framed structure.
-
+```ruby
     {
       "@context": {
         "ex": "http://example.com/",
@@ -283,10 +283,10 @@ A term definition can include `@context`, which is applied to values of that obj
       },
       "foo": "Bar"
     }
-
+```
 ### @id and @type maps
 The value of `@container` in a term definition can include `@id` or `@type`, in addition to `@set`, `@list`, `@language`, and `@index`. This allows value indexing based on either the `@id` or `@type` of associated objects.
-
+```ruby
     {
       "@context": {
         "@vocab": "http://example/",
@@ -297,10 +297,10 @@ The value of `@container` in a term definition can include `@id` or `@type`, in
         "_:bar": {"label": "Object with @id _:bar"}
       }
     }
-
+```
 ### @graph containers and maps
 A term can have `@container` set to include `@graph` optionally including `@id` or `@index` and `@set`. In the first form, with `@container` set to `@graph`, the value of a property is treated as a _simple graph object_, meaning that values treated as if they were contained in an object with `@graph`, creating _named graph_ with an anonymous name.
-
+```ruby
     {
       "@context": {
         "@vocab": "http://example.org/",
@@ -310,9 +310,9 @@ A term can have `@container` set to include `@graph` optionally including `@id`
         "value": "x"
       }
     }
-
+```
 which expands to the following:
-
+```ruby
     [{
       "http://example.org/input": [{
         "@graph": [{
@@ -320,18 +320,18 @@ which expands to the following:
         }]
       }]
     }]
-
+```
 Compaction reverses this process, optionally ensuring that a single value is contained within an array of `@container` also includes `@set`:
-
+```ruby
     {
       "@context": {
         "@vocab": "http://example.org/",
         "input": {"@container": ["@graph", "@set"]}
       }
     }
-
+```
 A graph map uses the map form already existing for `@index`, `@language`, `@type`, and `@id` where the index is either an index value or an id.
-
+```ruby
     {
       "@context": {
         "@vocab": "http://example.org/",
@@ -341,9 +341,9 @@ A graph map uses the map form already existing for `@index`, `@language`, `@type
         "g1": {"value": "x"}
       }
     }
-
+```
 treats "g1" as an index, and expands to the following:
-
+```ruby
     [{
       "http://example.org/input": [{
         "@index": "g1",
@@ -352,11 +352,11 @@ treats "g1" as an index, and expands to the following:
         }]
       }]
     }])
-
+```
 This can also include `@set` to ensure that, when compacting, a single value of an index will be in array form.
 
 The _id_ version is similar:
-
+```ruby
     {
       "@context": {
         "@vocab": "http://example.org/",
@@ -366,9 +366,9 @@ The _id_ version is similar:
         "http://example.com/g1": {"value": "x"}
       }
     }
-
+```
 which expands to:
-
+```ruby
     [{
       "http://example.org/input": [{
         "@id": "http://example.com/g1",
@@ -377,10 +377,10 @@ which expands to:
         }]
       }]
     }])
-
+```
 ### Transparent Nesting
 Many JSON APIs separate properties from their entities using an intermediate object. For example, a set of possible labels may be grouped under a common property:
-
+```json
     {
       "@context": {
         "skos": "http://www.w3.org/2004/02/skos/core#",
@@ -396,9 +396,9 @@ Many JSON APIs separate properties from their entities using an intermediate obj
          "other_label": "This is the other label"
       }
     }
- 
+ ```
  In this case, the `labels` property is semantically meaningless. Defining it as equivalent to `@nest` causes it to be ignored when expanding, making it equivalent to the following:
-
+```json
     {
       "@context": {
         "skos": "http://www.w3.org/2004/02/skos/core#",
@@ -412,9 +412,9 @@ Many JSON APIs separate properties from their entities using an intermediate obj
       "main_label": "This is the main label for my resource",
       "other_label": "This is the other label"
     }
- 
+ ```
  Similarly, properties may be marked with "@nest": "nest-term", to cause them to be nested. Note that the `@nest` keyword can also be aliased in the context.
-
+```json
      {
        "@context": {
          "skos": "http://www.w3.org/2004/02/skos/core#",
@@ -430,7 +430,7 @@ Many JSON APIs separate properties from their entities using an intermediate obj
           "other_label": "This is the other label"
        }
      }
-
+```
 In this way, nesting survives round-tripping through expansion, and framed output can include nested properties.
 
 ### Framing Updates
@@ -469,20 +469,20 @@ Note, the API method signatures differed in versions before 1.0, in that they al
 
 ## Dependencies
 * [Ruby](http://ruby-lang.org/) (>= 2.2.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.2)
-* [JSON](https://rubygems.org/gems/json) (>= 1.5)
+* [RDF.rb](http://rubygems.org/gems/rdf) (~> 3.0)
+* [JSON](https://rubygems.org/gems/json) (>= 2.1)
 
 ## Installation
 The recommended installation method is via [RubyGems](http://rubygems.org/).
 To install the latest official release of the `JSON-LD` gem, do:
-
-    % [sudo] gem install json-ld
-
+```bash
+ % [sudo] gem install json-ld
+```
 ## Download
 To get a local working copy of the development repository, do:
-
-    % git clone git://github.com/ruby-rdf/json-ld.git
-
+```bash
+ % git clone git://github.com/ruby-rdf/json-ld.git
+```
 ## Mailing List
 * <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
 

data/VERSION

@@ -1 +1 @@
-2.2.1
+3.0.0

data/lib/json/ld.rb

@@ -55,6 +55,7 @@ module JSON
       @language
       @list
       @nest
+      @none
       @omitDefault
       @requireAll
       @reverse
@@ -90,6 +91,8 @@ module JSON
       array_nl:     "\n"
     )
 
+    MAX_CONTEXTS_LOADED = 50
+
     class JsonLdError < StandardError
       def to_s
         "#{self.class.instance_variable_get :@code}: #{super}"
@@ -99,7 +102,6 @@ module JSON
       end
 
       class CollidingKeywords < JsonLdError; @code = "colliding keywords"; end
-      class CompactionToListOfLists < JsonLdError; @code = "compaction to list of lists"; end
       class ConflictingIndexes < JsonLdError; @code = "conflicting indexes"; end
       class CyclicIRIMapping < JsonLdError; @code = "cyclic IRI mapping"; end
       class InvalidBaseIRI < JsonLdError; @code = "invalid base IRI"; end
@@ -132,9 +134,9 @@ module JSON
       class InvalidValueObjectValue < JsonLdError; @code = "invalid value object value"; end
       class InvalidVocabMapping < JsonLdError; @code = "invalid vocab mapping"; end
       class KeywordRedefinition < JsonLdError; @code = "keyword redefinition"; end
-      class ListOfLists < JsonLdError; @code = "list of lists"; end
       class LoadingDocumentFailed < JsonLdError; @code = "loading document failed"; end
       class LoadingRemoteContextFailed < JsonLdError; @code = "loading remote context failed"; end
+      class ContextOverflow < JsonLdError; @code = "maximum number of @context URLs exceeded"; end
       class MultipleContextLinkHeaders < JsonLdError; @code = "multiple context link headers"; end
       class ProcessingModeConflict < JsonLdError; @code = "processing mode conflict"; end
       class RecursiveContextInclusion < JsonLdError; @code = "recursive context inclusion"; end

data/lib/json/ld/api.rb

@@ -72,10 +72,7 @@ module JSON::LD
     # @option options [Boolean, String, RDF::URI] :flatten
     #   If set to a value that is not `false`, the JSON-LD processor must modify the output of the Compaction Algorithm or the Expansion Algorithm by coalescing all properties associated with each subject via the Flattening Algorithm. The value of `flatten must` be either an _IRI_ value representing the name of the graph to flatten, or `true`. If the value is `true`, then the first graph encountered in the input document is selected and flattened.
     # @option options [String] :processingMode
-    #   Processing mode, json-ld-1.0 or json-ld-1.1. Also can have other values:
-    #
-    #   * json-ld-1.1-expand-frame – special frame expansion mode.
-    #
+    #   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] :rename_bnodes (true)
     #   Rename bnodes as part of expansion, or keep them the same.
@@ -86,16 +83,15 @@ module JSON::LD
     # @yield [api]
     # @yieldparam [API]
     # @raise [JsonLdError]
-    def initialize(input, context, options = {}, &block)
+    def initialize(input, context, rename_bnodes: true, unique_bnodes: false, **options, &block)
       @options = {
         compactArrays:      true,
-        rename_bnodes:      true,
         documentLoader:     self.class.method(:documentLoader)
       }.merge(options)
-      @namer = options[:unique_bnodes] ? BlankNodeUniqer.new : (@options[:rename_bnodes] ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
+      @namer = unique_bnodes ? BlankNodeUniqer.new : (rename_bnodes ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
 
       # For context via Link header
-      remote_base, context_ref = nil, nil
+      _, context_ref = nil, nil
 
       @value = case input
       when Array, Hash then input.dup
@@ -115,7 +111,6 @@ module JSON::LD
       when String
         remote_doc = @options[:documentLoader].call(input, @options)
 
-        remote_base = remote_doc.documentUrl
         context_ref = remote_doc.contextUrl
         @options = {base: remote_doc.documentUrl}.merge(@options) unless @options[:no_default_base]
 
@@ -166,10 +161,12 @@ module JSON::LD
     # @return [Object, Array<Hash>]
     #   If a block is given, the result of evaluating the block is returned, otherwise, the expanded JSON-LD document
     # @see http://json-ld.org/spec/latest/json-ld-api/#expansion-algorithm
-    def self.expand(input, options = {}, &block)
+    def self.expand(input, ordered: true, framing: false, **options, &block)
       result, doc_base = nil
       API.new(input, options[:expandContext], options) do
-        result = self.expand(self.value, nil, self.context, ordered: options.fetch(:ordered, true))
+        result = self.expand(self.value, nil, self.context,
+          ordered: ordered,
+          framing: framing)
         doc_base = @options[:base]
       end
 
@@ -213,18 +210,18 @@ module JSON::LD
     #   If a block is given, the result of evaluating the block is returned, otherwise, the compacted JSON-LD document
     # @raise [JsonLdError]
     # @see http://json-ld.org/spec/latest/json-ld-api/#compaction-algorithm
-    def self.compact(input, context, options = {})
+    def self.compact(input, context, expanded: false, **options)
       result = nil
       options = {compactToRelative:  true}.merge(options)
 
       # 1) Perform the Expansion Algorithm on the JSON-LD input.
       #    This removes any existing context to allow the given context to be cleanly applied.
-      expanded_input = options[:expanded] ? input : API.expand(input, options) do |result, base_iri|
+      expanded_input = expanded ? input : API.expand(input, options) do |res, base_iri|
         options[:base] ||= base_iri if options[:compactToRelative]
-        result
+        res
       end
 
-      API.new(expanded_input, context, options.merge(no_default_base: true)) do
+      API.new(expanded_input, context, no_default_base: true, **options) do
         log_debug(".compact") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
         result = compact(value)
 
@@ -258,18 +255,18 @@ module JSON::LD
     # @return [Object, Hash]
     #   If a block is given, the result of evaluating the block is returned, otherwise, the flattened JSON-LD document
     # @see http://json-ld.org/spec/latest/json-ld-api/#framing-algorithm
-    def self.flatten(input, context, options = {})
+    def self.flatten(input, context, expanded: false, **options)
       flattened = []
       options = {compactToRelative:  true}.merge(options)
 
       # Expand input to simplify processing
-      expanded_input = options[:expanded] ? input : API.expand(input, options) do |result, base_iri|
+      expanded_input = expanded ? input : API.expand(input, options) do |result, base_iri|
         options[:base] ||= base_iri if options[:compactToRelative]
         result
       end
 
       # Initialize input using
-      API.new(expanded_input, context, options.merge(no_default_base: true)) do
+      API.new(expanded_input, context, no_default_base: true, **options) do
         log_debug(".flatten") {"expanded input: #{value.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Initialize node map to a JSON object consisting of a single member whose key is @default and whose value is an empty JSON object.
@@ -277,24 +274,23 @@ module JSON::LD
         create_node_map(value, graph_maps)
 
         default_graph = graph_maps['@default']
-        graph_maps.keys.kw_sort.each do |graph_name|
+        graph_maps.keys.sort.each do |graph_name|
           next if graph_name == '@default'
 
           graph = graph_maps[graph_name]
           entry = default_graph[graph_name] ||= {'@id' => graph_name}
           nodes = entry['@graph'] ||= []
-          graph.keys.kw_sort.each do |id|
+          graph.keys.sort.each do |id|
             nodes << graph[id] unless node_reference?(graph[id])
           end
         end
-        default_graph.keys.kw_sort.each do |id|
+        default_graph.keys.sort.each do |id|
           flattened << default_graph[id] unless node_reference?(default_graph[id])
         end
 
         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 = compact(flattened)
-          compacted = [compacted] unless compacted.is_a?(Array)
+          compacted = as_array(compact(flattened))
           kwgraph = self.context.compact_iri('@graph', quiet: true)
           flattened = self.context.serialize.merge(kwgraph => compacted)
         end
@@ -322,7 +318,7 @@ module JSON::LD
     # @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
     # @yieldparam [Hash] jsonld
     #   The framed JSON-LD document
@@ -331,7 +327,7 @@ module JSON::LD
     #   If a block is given, the result of evaluating the block is returned, otherwise, the framed JSON-LD document
     # @raise [InvalidFrame]
     # @see http://json-ld.org/spec/latest/json-ld-api/#framing-algorithm
-    def self.frame(input, frame, options = {})
+    def self.frame(input, frame, expanded: false, **options)
       result = nil
       options = {
         base:                       (input if input.is_a?(String)),
@@ -341,7 +337,7 @@ module JSON::LD
         explicit:                   false,
         requireAll:                 true,
         omitDefault:                false,
-        pruneBlankNodeIdentifiers:  true,
+        omitGraph:                  false,
         documentLoader:             method(:documentLoader)
       }.merge(options)
 
@@ -365,20 +361,21 @@ module JSON::LD
       end
 
       # Expand input to simplify processing
-      expanded_input = options[:expanded] ? input : API.expand(input, options) do |result, base_iri|
+      expanded_input = expanded ? input : API.expand(input, options) do |res, base_iri|
         options[:base] ||= base_iri if options[:compactToRelative]
-        result
+        res
       end
 
       # Expand frame to simplify processing
-      expanded_frame = API.expand(frame, options.merge(processingMode: "json-ld-1.1-expand-frame"))
+      expanded_frame = API.expand(frame, framing: true, **options)
 
       # Initialize input using frame as context
-      API.new(expanded_input, nil, options.merge(no_default_base: true)) do
+      API.new(expanded_input, frame['@context'], no_default_base: true, **options) do
+        log_debug(".frame") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
         log_debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Get framing nodes from expanded input, replacing Blank Node identifiers as necessary
-        create_node_map(value, framing_state[:graphMap], graph: '@default')
+        create_node_map(value, framing_state[:graphMap], active_graph: '@default')
 
         frame_keys = frame.keys.map {|k| context.expand_iri(k, vocab: true, quiet: true)}
         if frame_keys.include?('@graph')
@@ -394,24 +391,29 @@ module JSON::LD
         framing_state[:subjects] = framing_state[:graphMap][framing_state[:graph]]
 
         result = []
-        frame(framing_state, framing_state[:subjects].keys.sort, (expanded_frame.first || {}), options.merge(parent: result))
+        frame(framing_state, framing_state[:subjects].keys.sort, (expanded_frame.first || {}), parent: result, **options)
 
         # Count blank node identifiers used in the document, if pruning
-        bnodes_to_clear = if options[:pruneBlankNodeIdentifiers]
-          count_blank_node_identifiers(result).collect {|k, v| k if v == 1}.compact
+        unless @options[:processingMode] == 'json-ld-1.0'
+          bnodes_to_clear = count_blank_node_identifiers(result).collect {|k, v| k if v == 1}.compact
+          result = prune_bnodes(result, bnodes_to_clear)
         end
 
         # Initalize context from frame
         @context = @context.parse(frame['@context'])
         # Compact result
         compacted = compact(result)
-        compacted = [compacted] unless compacted.is_a?(Array)
+        compacted = [compacted] unless options[:omitGraph] || compacted.is_a?(Array)
 
         # Add the given context to the output
-        kwgraph = context.compact_iri('@graph', quiet: true)
-        result = context.serialize.merge({kwgraph => compacted})
+        result = if !compacted.is_a?(Array)
+          context.serialize.merge(compacted)
+        else
+          kwgraph = context.compact_iri('@graph', quiet: true)
+          context.serialize.merge({kwgraph => compacted})
+        end
         log_debug(".frame") {"after compact: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
-        result = cleanup_preserve(result, bnodes_to_clear || [])
+        result = cleanup_preserve(result)
       end
 
       block_given? ? yield(result) : result
@@ -430,7 +432,7 @@ module JSON::LD
     # @yield statement
     # @yieldparam [RDF::Statement] statement
     # @return [RDF::Enumerable] set of statements, unless a block is given.
-    def self.toRdf(input, options = {}, &block)
+    def self.toRdf(input, expanded: false, **options, &block)
       unless block_given?
         results = []
         results.extend(RDF::Enumerable)
@@ -441,7 +443,7 @@ module JSON::LD
       end
 
       # Expand input to simplify processing
-      expanded_input = options[:expanded] ? input : API.expand(input, options.merge(ordered: false))
+      expanded_input = expanded ? input : API.expand(input, ordered: false, **options)
 
       API.new(expanded_input, nil, options) do
         # 1) Perform the Expansion Algorithm on the JSON-LD input.
@@ -453,19 +455,9 @@ module JSON::LD
           item_to_rdf(node) do |statement|
             next if statement.predicate.node? && !options[:produceGeneralizedRdf]
 
-            # Drop results with relative IRIs
-            relative = statement.to_a.any? do |r|
-              case r
-              when RDF::URI
-                r.relative?
-              when RDF::Literal
-                r.has_datatype? && r.datatype.relative?
-              else
-                false
-              end
-            end
-            if relative
-              log_debug(".toRdf") {"drop statement with relative IRIs: #{statement.to_ntriples}"}
+            # Drop invalid statements (other than IRIs)
+            unless statement.valid_extended?
+              log_debug(".toRdf") {"drop invalid statement: #{statement.to_nquads}"}
               next
             end
 
@@ -480,7 +472,7 @@ module JSON::LD
     #
     # The resulting `Array` is either returned or yielded, if a block is given.
     #
-    # @param [Array<RDF::Statement>] input
+    # @param [RDF::Enumerable] input
     # @param  [Hash{Symbol => Object}] options
     # @option options (see #initialize)
     # @option options [Boolean] :useRdfType (false)
@@ -492,9 +484,7 @@ module JSON::LD
     # @yieldreturn [Object] returned object
     # @return [Object, Hash]
     #   If a block is given, the result of evaluating the block is returned, otherwise, the expanded JSON-LD document
-    def self.fromRdf(input, options = {}, &block)
-      useRdfType = options.fetch(:useRdfType, false)
-      useNativeTypes = options.fetch(:useNativeTypes, false)
+    def self.fromRdf(input, useRdfType: false, useNativeTypes: false, **options, &block)
       result = nil
 
       API.new(nil, nil, options) do |api|
@@ -516,12 +506,12 @@ module JSON::LD
     # @return [Object, RemoteDocument]
     #   If a block is given, the result of evaluating the block is returned, otherwise, the retrieved remote document and context information unless block given
     # @raise [JsonLdError]
-    def self.documentLoader(url, options = {})
+    def self.documentLoader(url, validate: false, **options)
       options = OPEN_OPTS.merge(options)
       RDF::Util::File.open_file(url, options) do |remote_doc|
         content_type = remote_doc.content_type if remote_doc.respond_to?(:content_type)
         # If the passed input is a DOMString representing the IRI of a remote document, dereference it. If the retrieved document's content type is neither application/json, nor application/ld+json, nor any other media type using a +json suffix as defined in [RFC6839], reject the promise passing an loading document failed error.
-        if content_type && options[:validate]
+        if content_type && validate
           main, sub = content_type.split("/")
           raise JSON::LD::JsonLdError::LoadingDocumentFailed, "url: #{url}, content_type: #{content_type}" if
             main != 'application' ||