json-ld 3.2.0 → 3.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e157972b224a8cbe834defdf32656a0b9f090357760fab179076e728427d1639
-  data.tar.gz: a63cd584853e5a830c85a427d30711bc84999e958949c81bc7d236df20f14ee6
+  metadata.gz: ff11a49b52d7ca0faf6deaac7324f08530747b53ec857ebe007c027a1bf412b4
+  data.tar.gz: b0a808fc12be08ecaa47f399c0f20ff26120cc36820bf45d6c434ad1f31f53e3
 SHA512:
-  metadata.gz: 77a85aa85eea6844e1adb9107fe0b2d5a4ad82b877456adcdbbc56031f884da21cc992169232c326f255491d8aa6f607aacbeaeb386578fe8a1ac374cc795ff5
-  data.tar.gz: 2f8353dca7bb6ea9bed3ed7fbea3e0bf883bdec9a3687d3b084f936ae0171a21df1d55bda8cf44fc0ae6d6682d5235234792901fb2fc7ffed327d2956fec289f
+  metadata.gz: c3e17fbb3280f393ece72136d09182d1032982ca116d49577f03dc72ca35ebc8193495054a1944e525acdad8ae67ce6cb341f6859c5e97a7d2497ca047d7ee40
+  data.tar.gz: eef60e136ca7d86ac66cd0b74d5b01862b4f5c7039352c7d6e678b73ab783bf7bbf2f397f7fd928421bc52e332389cab1432e69175d6fa0d260dfcf7a315a66a

data/README.md

@@ -32,10 +32,10 @@ This gem also implements an optimized streaming writer used for generating JSON-
 * Each statement written as a separate node in expanded/flattened form.
 * `RDF List`s are written as separate nodes using `rdf:first` and `rdf:rest` properties.
 
-The order of triples retrieved from the `RDF::Enumerable` dataset determines the way that JSON-LD node objects are written; for best results, statements should be ordered by _graph name_, _subect_, _predicate_ and _object_.
+The order of triples retrieved from the `RDF::Enumerable` dataset determines the way that JSON-LD node objects are written; for best results, statements should be ordered by _graph name_, _subject_, _predicate_ and _object_.
 
 ### 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.
+The [MultiJson](https://rubygems.org/gems/multi_json) gem is used for parsing and serializing JSON; this defaults to the native JSON parser/serializer, 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. Additionally, a custom serialilzer may be specified by passing the `:serializer` option to {JSON::LD::Writer} or methods of {JSON::LD::API}. See [MultiJson](https://rubygems.org/gems/multi_json) for more information.
 
 ### JSON-LD-star (RDFStar)
 
@@ -72,7 +72,7 @@ In the first case, the embedded node is not asserted, and only appears as the su
 
 #### Serializing a Graph containing embedded statements
 
-    require 'json-ld'
+    require 'json/ld'
     statement = RDF::Statement(RDF::URI('bob'), RDF::Vocab::FOAF.age, RDF::Literal(23))
     graph = RDF::Graph.new << [statement, RDF::URI("ex:certainty"), RDF::Literal(0.9)]
     graph.dump(:jsonld, validate: false, standard_prefixes: true)
@@ -565,7 +565,7 @@ The {JSON::LD::ContentNegotiation#call} method looks for a result which includes
 See [Rack::LinkedData][] to do the same thing with an RDF Graph or Dataset as the source, rather than Ruby objects.
 
 ## Documentation
-Full documentation available on [RubyDoc](https://rubydoc.info/gems/json-ld/file/README.md)
+Full documentation available on [RubyDoc](https://ruby-rdf.github.io/json-ld/file/README.md)
 
 ## Differences from [JSON-LD API][]
 The specified JSON-LD API is based on a WebIDL definition implementing [Promises][] intended for use within a browser.
@@ -624,8 +624,7 @@ To get a local working copy of the development repository, do:
   which you will be asked to agree to on the first commit to a repo within the organization.
   Note that the agreement applies to all repos in the [Ruby RDF](https://github.com/ruby-rdf/) organization.
 
-License
--------
+## License
 
 This is free and unencumbered public domain software. For more information,
 see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
@@ -641,7 +640,7 @@ see <https://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [Backports]:        https://rubygems.org/gems/backports
 [JSON-LD]:          https://www.w3.org/TR/json-ld11/ "JSON-LD 1.1"
 [JSON-LD API]:      https://www.w3.org/TR/json-ld11-api/ "JSON-LD 1.1 Processing Algorithms and API"
-[JSON-LD Framing]:  https://www.w3.org/TR/json-ld11-framing/ "JSON-LD Framing 1.1"
+[JSON-LD Framing]:  https://www.w3.org/TR/json-ld11-framing/ "JSON-LD 1.1 Framing"
 [Promises]:         https://dom.spec.whatwg.org/#promises
 [jsonlint]:         https://rubygems.org/gems/jsonlint
 [Sinatra]:          https://www.sinatrarb.com/

data/VERSION

@@ -1 +1 @@
-3.2.0
+3.2.3

data/lib/json/ld/api.rb

@@ -126,7 +126,8 @@ module JSON::LD
 
         case remote_doc.document
         when String
-          MultiJson.load(remote_doc.document, **options)
+          mj_opts = options.keep_if {|k,v| k != :adapter || MUTLI_JSON_ADAPTERS.include?(v)}
+          MultiJson.load(remote_doc.document, **mj_opts)
         else
           # Already parsed
           remote_doc.document
@@ -155,6 +156,9 @@ module JSON::LD
     #
     # @param [String, #read, Hash, Array] input
     #   The JSON-LD object to copy and perform the expansion upon.
+    # @param [Proc] serializer (nil)
+    #   A Serializer method used for generating the JSON serialization of the result. If absent, the internal Ruby objects are returned, which can be transformed to JSON externally via `#to_json`.
+    #   See {JSON::LD::API.serializer}.
     # @param  [Hash{Symbol => Object}] options
     # @option options (see #initialize)
     # @raise [JsonLdError]
@@ -167,7 +171,7 @@ 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 https://www.w3.org/TR/json-ld11-api/#expansion-algorithm
-    def self.expand(input, framing: false, **options, &block)
+    def self.expand(input, framing: false, serializer: nil, **options, &block)
       result = doc_base = nil
       API.new(input, options[:expandContext], **options) do
         result = self.expand(self.value, nil, self.context,
@@ -180,6 +184,7 @@ module JSON::LD
 
       # Finally, if element is a JSON object, it is wrapped into an array.
       result = [result].compact unless result.is_a?(Array)
+      result = serializer.call(result, **options) if serializer
 
       if block_given?
         case block.arity
@@ -204,6 +209,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 [Proc] serializer (nil)
+    #   A Serializer instance used for generating the JSON serialization of the result. If absent, the internal Ruby objects are returned, which can be transformed to JSON externally via `#to_json`.
+    #   See {JSON::LD::API.serializer}.
     # @param [Boolean] expanded (false) Input is already expanded
     # @param  [Hash{Symbol => Object}] options
     # @option options (see #initialize)
@@ -215,7 +223,7 @@ 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 https://www.w3.org/TR/json-ld11-api/#compaction-algorithm
-    def self.compact(input, context, expanded: false, **options)
+    def self.compact(input, context, expanded: false, serializer: nil, **options)
       result = nil
       options = {compactToRelative:  true}.merge(options)
 
@@ -238,6 +246,7 @@ module JSON::LD
         end
         result = ctx.merge(result) unless ctx.fetch('@context', {}).empty?
       end
+      result = serializer.call(result, **options) if serializer
       block_given? ? yield(result) : result
     end
 
@@ -251,6 +260,9 @@ module JSON::LD
     # @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 [Proc] serializer (nil)
+    #   A Serializer instance used for generating the JSON serialization of the result. If absent, the internal Ruby objects are returned, which can be transformed to JSON externally via `#to_json`.
+    #   See {JSON::LD::API.serializer}.
     # @param  [Hash{Symbol => Object}] options
     # @option options (see #initialize)
     # @option options [Boolean] :createAnnotations
@@ -262,7 +274,7 @@ 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 https://www.w3.org/TR/json-ld11-api/#framing-algorithm
-    def self.flatten(input, context, expanded: false, **options)
+    def self.flatten(input, context, expanded: false, serializer: nil, **options)
       flattened = []
       options = {
         compactToRelative:  true,
@@ -318,6 +330,7 @@ module JSON::LD
         end
       end
 
+      flattened = serializer.call(flattened, **options) if serializer
       block_given? ? yield(flattened) : flattened
     end
 
@@ -350,7 +363,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 https://www.w3.org/TR/json-ld11-api/#framing-algorithm
-    def self.frame(input, frame, expanded: false, **options)
+    def self.frame(input, frame, expanded: false, serializer: nil, **options)
       result = nil
       options = {
         base:                       (RDF::URI(input) if input.is_a?(String)),
@@ -379,7 +392,8 @@ module JSON::LD
                                         requestProfile: 'http://www.w3.org/ns/json-ld#frame',
                                         **options)
         if remote_doc.document.is_a?(String)
-          MultiJson.load(remote_doc.document)
+          mj_opts = options.keep_if {|k,v| k != :adapter || MUTLI_JSON_ADAPTERS.include?(v)}
+          MultiJson.load(remote_doc.document, **mj_opts)
         else
           remote_doc.document
         end
@@ -467,6 +481,7 @@ module JSON::LD
         result
       end
 
+      result = serializer.call(result, **options) if serializer
       block_given? ? yield(result) : result
     end
 
@@ -528,18 +543,21 @@ module JSON::LD
     # The resulting `Array` is either returned or yielded, if a block is given.
     #
     # @param [RDF::Enumerable] input
+    # @param [Boolean] useRdfType (false)
+    #   If set to `true`, the JSON-LD processor will treat `rdf:type` like a normal property instead of using `@type`.
+    # @param [Boolean] useNativeTypes (false) use native representations
+    # @param [Proc] serializer (nil)
+    #   A Serializer instance used for generating the JSON serialization of the result. If absent, the internal Ruby objects are returned, which can be transformed to JSON externally via `#to_json`.
+    #   See {JSON::LD::API.serializer}.
     # @param  [Hash{Symbol => Object}] options
     # @option options (see #initialize)
-    # @option options [Boolean] :useRdfType (false)
-    #   If set to `true`, the JSON-LD processor will treat `rdf:type` like a normal property instead of using `@type`.
-    # @option options [Boolean] :useNativeTypes (false) use native representations
     # @yield jsonld
     # @yieldparam [Hash] jsonld
     #   The JSON-LD document in expanded form
     # @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, useRdfType: false, useNativeTypes: false, **options, &block)
+    def self.fromRdf(input, useRdfType: false, useNativeTypes: false, serializer: nil, **options, &block)
       result = nil
 
       API.new(nil, nil, **options) do
@@ -548,6 +566,7 @@ module JSON::LD
           useNativeTypes: useNativeTypes)
       end
 
+      result = serializer.call(result, **options) if serializer
       block_given? ? yield(result) : result
     end
 
@@ -648,7 +667,8 @@ module JSON::LD
             end
           else
             validate_input(remote_doc.document, url: remote_doc.documentUrl) if validate
-            MultiJson.load(remote_doc.document, **options)
+            mj_opts = options.keep_if {|k,v| k != :adapter || MUTLI_JSON_ADAPTERS.include?(v)}
+            MultiJson.load(remote_doc.document, **mj_opts)
           end
         end
 
@@ -682,8 +702,8 @@ module JSON::LD
         base_uri ||= url.base_uri if url.respond_to?(:base_uri)
         content_type = options[:content_type]
         content_type ||= url.content_type if url.respond_to?(:content_type)
-        context_url = if url.respond_to?(:links) && url.links
-         (content_type == 'appliaction/json' || content_type.match?(%r(application/(^ld)+json)))
+        context_url = if url.respond_to?(:links) && url.links &&
+         (content_type == 'application/json' || content_type.match?(%r(application/(^ld)+json)))
           link = url.links.find_link(LINK_REL_CONTEXT)
           link.href if link
         end
@@ -759,7 +779,8 @@ module JSON::LD
         raise JSON::LD::JsonLdError::LoadingDocumentFailed, "Script tag has type=#{element.attributes['type']}" unless element.attributes['type'].to_s.start_with?('application/ld+json')
         content = element.inner_html
         validate_input(content, url: url) if options[:validate]
-        MultiJson.load(content, **options)
+        mj_opts = options.keep_if {|k,v| k != :adapter || MUTLI_JSON_ADAPTERS.include?(v)}
+        MultiJson.load(content, **mj_opts)
       elsif extractAllScripts
         res = []
         elements = if profile
@@ -773,7 +794,8 @@ module JSON::LD
         elements.each do |element|
           content = element.inner_html
           validate_input(content, url: url) if options[:validate]
-          r = MultiJson.load(content, **options)
+          mj_opts = options.keep_if {|k,v| k != :adapter || MUTLI_JSON_ADAPTERS.include?(v)}
+          r = MultiJson.load(content, **mj_opts)
           if r.is_a?(Hash)
             res << r
           elsif r.is_a?(Array)
@@ -788,12 +810,29 @@ module JSON::LD
         raise JSON::LD::JsonLdError::LoadingDocumentFailed, "No script tag found" unless element
         content = element.inner_html
         validate_input(content, url: url) if options[:validate]
-        MultiJson.load(content, **options)
+        mj_opts = options.keep_if {|k,v| k != :adapter || MUTLI_JSON_ADAPTERS.include?(v)}
+        MultiJson.load(content, **mj_opts)
       end
     rescue MultiJson::ParseError => e
       raise JSON::LD::JsonLdError::InvalidScriptElement, e.message
     end
 
+    ##
+    # The default serializer for serialzing Ruby Objects to JSON.
+    #
+    # Defaults to `MultiJson.dump`
+    #
+    # @param [Object] object
+    # @param [Array<Object>] args
+    #   other arguments that may be passed for some specific implementation.
+    # @param [Hash<Symbol, Object>] options
+    #   options passed from the invoking context.
+    # @option options [Object] :serializer_opts (JSON_STATE)
+    def self.serializer(object, *args, **options)
+      serializer_opts = options.fetch(:serializer_opts, JSON_STATE)
+      MultiJson.dump(object, serializer_opts)
+    end
+
     ##
     # Validate JSON using JsonLint, if loaded
     private

data/lib/json/ld/context.rb

@@ -5,13 +5,6 @@ require 'bigdecimal'
 require 'set'
 require 'rdf/util/cache'
 
-begin
-  # Attempt to load this to avoid unnecessary context fetches
-  require 'json-ld-preloaded'
-rescue LoadError
-  # Silently allow this to fail
-end
-
 module JSON::LD
   class Context
     include Utils
@@ -50,6 +43,13 @@ module JSON::LD
       end
     end
 
+    begin
+      # Attempt to load this to avoid unnecessary context fetches
+      require 'json/ld/preloaded'
+    rescue LoadError
+      # Silently allow this to fail
+    end
+
     # The base.
     #
     # @return [RDF::URI] Current base IRI, used for expanding relative IRIs.

data/lib/json/ld/expand.rb

@@ -88,7 +88,7 @@ module JSON::LD
 
         # If element contains the key @context, set active context to the result of the Context Processing algorithm, passing active context and the value of the @context key as local context.
         if input.key?('@context')
-          context = context.parse(input.delete('@context'), base: @options[:base])
+          context = context.parse(input['@context'], base: @options[:base])
           log_debug("expand", depth: log_depth.to_i) {"context: #{context.inspect}"}
         end
 
@@ -99,7 +99,7 @@ module JSON::LD
 
         # See if keys mapping to @type have terms with a local context
         type_key = nil
-        input.keys.sort.
+        (input.keys - %w(@context)).sort.
           select {|k| context.expand_iri(k, vocab: true, base: @options[:base]) == '@type'}.
           each do |tk|
 

data/lib/json/ld/format.rb

@@ -23,7 +23,8 @@ module JSON::LD
   class Format < RDF::Format
     content_type     'application/ld+json',
                      extension: :jsonld,
-                     alias: 'application/x-ld+json'
+                     alias: 'application/x-ld+json',
+                     uri: 'http://www.w3.org/ns/formats/JSON-LD'
     content_encoding 'utf-8'
 
     reader { JSON::LD::Reader }
@@ -44,8 +45,80 @@ module JSON::LD
         !sample.include?("http://www.w3.org/ns/csvw")
     end
 
+    # Specify how to execute CLI commands for each supported format.
+    # Derived formats (e.g., YAML-LD) define their own entrypoints.
+    LD_FORMATS = {
+      jsonld: {
+        expand: ->(input, **options) {
+          JSON::LD::API.expand(input,
+                               serializer: JSON::LD::API.method(:serializer),
+                               **options)
+        },
+        compact: ->(input, **options) {
+          JSON::LD::API.compact(input,
+                                options[:context],
+                                serializer: JSON::LD::API.method(:serializer),
+                                **options)
+        },
+        flatten: ->(input, **options) {
+          JSON::LD::API.flatten(input,
+                                options[:context],
+                                serializer: JSON::LD::API.method(:serializer),
+                                **options)
+        },
+        frame: ->(input, **options) {
+          JSON::LD::API.frame(input,
+                                options[:frame],
+                                serializer: JSON::LD::API.method(:serializer),
+                                **options)
+        },
+      }
+    }
+
+    # Execute the body of a CLI command, generic for each different API method based on definitions on {LD_FORMATS}.
+    #
+    # Expands the input, or transforms from an RDF format based on the `:format` option, and then executes the appropriate command based on `:output_format` and does appropriate output serialization.
+    # @private
+    def self.cli_exec(command, files, output: $stdin, **options)
+      output.set_encoding(Encoding::UTF_8) if output.respond_to?(:set_encoding) && RUBY_PLATFORM == "java"
+      options[:base] ||= options[:base_uri]
+
+      # Parse using input format, serialize using output format
+      in_fmt = LD_FORMATS[options.fetch(:format, :jsonld)]
+      out_fmt = LD_FORMATS[options.fetch(:output_format, :jsonld)]
+
+      if in_fmt
+        # Input is a JSON-LD based source (or derived)
+        if files.empty?
+          # If files are empty, either use options[:evaluate] or STDIN
+          input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
+          input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
+          expanded = in_fmt[:expand].call(input, serializer: nil, **options)
+          output.puts out_fmt[command].call(expanded, expanded: true, **options)
+        else
+          files.each do |file|
+            expanded = in_fmt[:expand].call(file, serializer: nil, **options)
+            output.puts out_fmt[command].call(expanded, expanded: true, **options)
+          end
+        end
+      else
+        # Turn RDF into JSON-LD first
+        RDF::CLI.parse(files, **options) do |reader|
+          JSON::LD::API.fromRdf(reader, serializer: nil, **options) do |expanded|
+            output.puts out_fmt[command].call(expanded, expanded: true, **options)
+          end
+        end
+      end
+    end
+
     ##
-    # Hash of CLI commands appropriate for this format
+    # Hash of CLI commands appropriate for this format:
+    #
+    # * `expand` => {JSON::LD::API.expand}
+    # * `compact` => {JSON::LD::API.compact}
+    # * `flatten` => {JSON::LD::API.flatten}
+    # * `frame` => {JSON::LD::API.frame}
+    #
     # @return [Hash{Symbol => Hash}]
     def self.cli_commands
       {
@@ -53,73 +126,21 @@ module JSON::LD
           description: "Expand JSON-LD or parsed RDF",
           parse: false,
           help: "expand [--context <context-file>] files ...",
-          filter: {output_format: :jsonld},  # Only shows output format set
+          filter: {output_format: LD_FORMATS.keys},  # Only shows output format set
           lambda: ->(files, **options) do
-            out = options[:output] || $stdout
-            out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
             options = options.merge(expandContext: options.delete(:context)) if options.key?(:context)
-            options[:base] ||= options[:base_uri]
-            if options[:format] == :jsonld
-              if files.empty?
-                # If files are empty, either use options[:evaluate] or STDIN
-                input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
-                input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
-                JSON::LD::API.expand(input, validate: false, **options) do |expanded|
-                  out.puts expanded.to_json(JSON::LD::JSON_STATE)
-                end
-              else
-                files.each do |file|
-                  JSON::LD::API.expand(file, validate: false, **options) do |expanded|
-                    out.puts expanded.to_json(JSON::LD::JSON_STATE)
-                  end
-                end
-              end
-            else
-              # Turn RDF into JSON-LD first
-              RDF::CLI.parse(files, **options) do |reader|
-                JSON::LD::API.fromRdf(reader) do |expanded|
-                  out.puts expanded.to_json(JSON::LD::JSON_STATE)
-                end
-              end
-            end
+            cli_exec(:expand, files, **options)
           end,
           option_use: {context: :removed}
         },
         compact: {
           description: "Compact JSON-LD or parsed RDF",
           parse: false,
-          filter: {output_format: :jsonld},  # Only shows output format set
+          filter: {output_format: LD_FORMATS.keys},  # Only shows output format set
           help: "compact --context <context-file> files ...",
           lambda: ->(files, **options) do
             raise ArgumentError, "Compacting requires a context" unless options[:context]
-            out = options[:output] || $stdout
-            out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
-            options[:base] ||= options[:base_uri]
-            if options[:format] == :jsonld
-              if files.empty?
-                # If files are empty, either use options[:evaluate] or STDIN
-                input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
-                input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
-                JSON::LD::API.compact(input, options[:context], **options) do |compacted|
-                  out.puts compacted.to_json(JSON::LD::JSON_STATE)
-                end
-              else
-                files.each do |file|
-                  JSON::LD::API.compact(file, options[:context], **options) do |compacted|
-                    out.puts compacted.to_json(JSON::LD::JSON_STATE)
-                  end
-                end
-              end
-            else
-              # Turn RDF into JSON-LD first
-              RDF::CLI.parse(files, **options) do |reader|
-                JSON::LD::API.fromRdf(reader) do |expanded|
-                  JSON::LD::API.compact(expanded, options[:context], **options) do |compacted|
-                    out.puts compacted.to_json(JSON::LD::JSON_STATE)
-                  end
-                end
-              end
-            end
+            cli_exec(:compact, files, **options)
           end,
           options: [
             RDF::CLI::Option.new(
@@ -135,36 +156,9 @@ module JSON::LD
           description: "Flatten JSON-LD or parsed RDF",
           parse: false,
           help: "flatten [--context <context-file>] files ...",
-          filter: {output_format: :jsonld},  # Only shows output format set
+          filter: {output_format: LD_FORMATS.keys},  # Only shows output format set
           lambda: ->(files, **options) do
-            out = options[:output] || $stdout
-            out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
-            options[:base] ||= options[:base_uri]
-            if options[:format] == :jsonld
-              if files.empty?
-                # If files are empty, either use options[:evaluate] or STDIN
-                input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
-                input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
-                JSON::LD::API.flatten(input, options[:context], **options) do |flattened|
-                  out.puts flattened.to_json(JSON::LD::JSON_STATE)
-                end
-              else
-                files.each do |file|
-                  JSON::LD::API.flatten(file, options[:context], **options) do |flattened|
-                    out.puts flattened.to_json(JSON::LD::JSON_STATE)
-                  end
-                end
-              end
-            else
-              # Turn RDF into JSON-LD first
-              RDF::CLI.parse(files, **options) do |reader|
-                JSON::LD::API.fromRdf(reader) do |expanded|
-                  JSON::LD::API.flatten(expanded, options[:context], **options) do |flattened|
-                    out.puts flattened.to_json(JSON::LD::JSON_STATE)
-                  end
-                end
-              end
-            end
+            cli_exec(:compact, files, **options)
           end,
           options: [
             RDF::CLI::Option.new(
@@ -187,37 +181,10 @@ module JSON::LD
           description: "Frame JSON-LD or parsed RDF",
           parse: false,
           help: "frame --frame <frame-file>  files ...",
-          filter: {output_format: :jsonld},  # Only shows output format set
+          filter: {output_format: LD_FORMATS.keys},  # Only shows output format set
           lambda: ->(files, **options) do
             raise ArgumentError, "Framing requires a frame" unless options[:frame]
-            out = options[:output] || $stdout
-            out.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
-            options[:base] ||= options[:base_uri]
-            if options[:format] == :jsonld
-              if files.empty?
-                # If files are empty, either use options[:evaluate] or STDIN
-                input = options[:evaluate] ? StringIO.new(options[:evaluate]) : STDIN
-                input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
-                JSON::LD::API.frame(input, options[:frame], **options) do |framed|
-                  out.puts framed.to_json(JSON::LD::JSON_STATE)
-                end
-              else
-                files.each do |file|
-                  JSON::LD::API.frame(file, options[:frame], **options) do |framed|
-                    out.puts framed.to_json(JSON::LD::JSON_STATE)
-                  end
-                end
-              end
-            else
-              # Turn RDF into JSON-LD first
-              RDF::CLI.parse(files, **options) do |reader|
-                JSON::LD::API.fromRdf(reader) do |expanded|
-                  JSON::LD::API.frame(expanded, options[:frame], **options) do |framed|
-                    out.puts framed.to_json(JSON::LD::JSON_STATE)
-                  end
-                end
-              end
-            end
+            cli_exec(:compact, files, **options)
           end,
           option_use: {context: :removed},
           options: [

data/lib/json/ld/reader.rb

@@ -12,7 +12,7 @@ module JSON::LD
 
     ##
     # JSON-LD Reader options
-    # @see http://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Reader#options-class_method
+    # @see https://ruby-rdf.github.io/rdf/RDF/Reader#options-class_method
     def self.options
       super + [
         RDF::CLI::Option.new(
@@ -57,7 +57,7 @@ module JSON::LD
     end
 
     ##
-    # Initializes the RDF/JSON reader instance.
+    # Initializes the JSON-LD reader instance.
     #
     # @param  [IO, File, String]       input
     # @param  [Hash{Symbol => Object}] options

data/lib/json/ld/streaming_reader.rb

@@ -26,7 +26,8 @@ module JSON::LD
       unique_bnodes, rename_bnodes = @options[:unique_bnodes], @options.fetch(:rename_bnodes, true)
       # FIXME: document loader doesn't stream
       @base = RDF::URI(@options[:base] || base_uri)
-      value = MultiJson.load(@doc, **@options)
+      mj_opts = @options.keep_if {|k,v| k != :adapter || MUTLI_JSON_ADAPTERS.include?(v)}
+      value = MultiJson.load(@doc, mj_opts)
       context_ref = @options[:expandContext]
       #context_ref = @options.fetch(:expandContext, remote_doc.contextUrl)
       context = Context.parse(context_ref, **@options)