json-ld 3.1.10 → 3.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0324a9e3b617b6dabe52c3f36c81e4b7fc4b78eaab9450510f45a760933064ba
-  data.tar.gz: 7cf759dd5940a052969477e50c50bb0dc31d7cac38a5ccc8e1bdc046e3994a43
+  metadata.gz: 63c237710b5f32fe8037a11969feaf712a79f68a4d1d568a89ece1a5d1d26ff2
+  data.tar.gz: cac81da94266cac30a7e31e5018477ef55e52b6b1701b048214947f266439236
 SHA512:
-  metadata.gz: 9d427823af59053d28e4999984f698cde37229fb9a3336a22f06517bcc65fbf80527a535b50dd28eaeca1e5d67e38d0d140dbace8854b9a62944f8ba149ea61c
-  data.tar.gz: 83ba9860d9b7fe72924c9469a26bd5337a051003396b02fdcf5ae9e4b2bbd13940c37d7b4d95c16b427248fda64fa799551c3dcf5c767436e804ea89fba03b4f
+  metadata.gz: 440da082cc1cbabcd69e8cb3d34858c4fe8fd96b116c0d67651d5ce7338d6e787f9d00451ff1f730d08982f0d8697d097f51d09d033ff7f8e290252006f96c78
+  data.tar.gz: 0b877d9d96857964a4913aef1790aa04dc98f83676ec0154c016ad05e7a9dc0a22b1b3bd31ae785cfb4447ac6914291ac56d42f5dc6781fc58c6687ccd4d15cd

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.
@@ -588,9 +588,9 @@ Note, the API method signatures differed in versions before 1.0, in that they al
   * {JSON::LD::Writer}
 
 ## Dependencies
-* [Ruby](https://ruby-lang.org/) (>= 2.4)
-* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.1)
-* [JSON](https://rubygems.org/gems/json) (>= 2.2)
+* [Ruby](https://ruby-lang.org/) (>= 2.6)
+* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.2)
+* [JSON](https://rubygems.org/gems/json) (>= 2.6)
 
 ## Installation
 The recommended installation method is via [RubyGems](https://rubygems.org/).
@@ -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.1.10
+3.2.2

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,27 @@ 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.
+    def self.serializer(object, *args, **options)
+      MultiJson.dump(object, JSON_STATE)
+    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.
@@ -1688,7 +1688,7 @@ module JSON::LD
       ec.default_direction = that.default_direction
       ec.default_language = that.default_language
       ec.previous_context = that.previous_context
-      ec.processingMode = that.processingMode if that.instance_variable_get(:@processingModee)
+      ec.processingMode = that.processingMode if that.instance_variable_get(:@processingMode)
       ec.vocab = that.vocab if that.vocab
 
       ec.instance_eval do

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/flatten.rb

@@ -202,7 +202,7 @@ module JSON::LD
     # * Deserialize the key into a map, and re-serialize the value of `@id`.
     # * If the map contains an entry with that value (after re-canonicalizing, as appropriate), and the associated antry has a item which matches the non-`@id` item from the map, the node is used to create an `@annotation` entry within that value.
     #
-    # @param [Hash{String => Hash}] input
+    # @param [Hash{String => Hash}] node_map
     # @return [Hash{String => Hash}]
     def create_annotations(node_map)
       node_map.keys.

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 }

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)

data/lib/json/ld/to_rdf.rb

@@ -11,10 +11,11 @@ module JSON::LD
     ##
     # @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, &block)
+    def item_to_rdf(item, graph_name: nil, quoted: false, &block)
       # Just return value object as Term
       return unless item
 
@@ -82,9 +83,9 @@ module JSON::LD
       when nil then node
       when String then as_resource(item['@id'])
       when Object
-        # Embedded statement
+        # Embedded/quoted statement
         # (No error checking, as this is done in expansion)
-        to_enum(:item_to_rdf, item['@id']).to_a.first
+        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'}"}
@@ -95,12 +96,12 @@ module JSON::LD
           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)
+            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, &block)
+            item_to_rdf(nd, graph_name: subject, quoted: quoted, &block)
           end
         when '@reverse'
           raise "Huh?" unless values.is_a?(Hash)
@@ -113,7 +114,7 @@ module JSON::LD
               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)
+              yield RDF::Statement(object, predicate, subject, graph_name: graph_name, quoted: quoted)
             end
           end
         when '@included'
@@ -136,13 +137,13 @@ module JSON::LD
               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)
+              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.
-              yield RDF::Statement(subject, predicate, object, graph_name: graph_name)
+              yield RDF::Statement(subject, predicate, object, graph_name: graph_name, quoted: quoted)
             end
           end
         end

data/lib/json/ld/writer.rb

@@ -71,7 +71,7 @@ module JSON::LD
 
     ##
     # JSON-LD Writer options
-    # @see http://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Writer#options-class_method
+    # @see https://ruby-rdf.github.io/rdf/RDF/Writer#options-class_method
     def self.options
       super + [
         RDF::CLI::Option.new(
@@ -186,10 +186,6 @@ module JSON::LD
       # @return [Boolean]
       # @see    http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
       def accept?(accept_params)
-        # Profiles that aren't specific IANA relations represent the URL
-        # of a context or frame that may be subject to black- or white-listing
-        profile = accept_params[:profile].to_s.split(/\s+/)
-
         if block_given?
           yield(accept_params)
         else
@@ -229,6 +225,8 @@ module JSON::LD
     #   frame to use when serializing.
     # @option options [Boolean]  :unique_bnodes   (false)
     #   Use unique bnode identifiers, defaults to using the identifier which the node was originall initialized with (if any).
+    # @option options [Proc] serializer (JSON::LD::API.serializer)
+    #   A Serializer method used for generating the JSON serialization of the result.
     # @option options [Boolean] :stream (false)
     #   Do not attempt to optimize graph presentation, suitable for streaming large graphs.
     # @yield  [writer] `self`
@@ -239,6 +237,7 @@ module JSON::LD
     def initialize(output = $stdout, **options, &block)
       options[:base_uri] ||= options[:base] if options.key?(:base)
       options[:base] ||= options[:base_uri] if options.key?(:base_uri)
+      @serializer = options.fetch(:serializer, JSON::LD::API.method(:serializer))
       super do
         @repo = RDF::Repository.new
 
@@ -300,7 +299,7 @@ module JSON::LD
       else
 
         log_debug("writer") { "serialize #{@repo.count} statements, #{@options.inspect}"}
-        result = API.fromRdf(@repo, **@options)
+        result = API.fromRdf(@repo, **@options.merge(serializer: nil))
 
         # Some options may be indicated from accept parameters
         profile = @options.fetch(:accept_params, {}).fetch(:profile, "").split(' ')
@@ -322,20 +321,20 @@ module JSON::LD
 
         # Rename BNodes to uniquify them, if necessary
         if options[:unique_bnodes]
-          result = API.flatten(result, context, **@options)
+          result = API.flatten(result, context, **@options.merge(serializer: nil))
         end
 
         if frame = @options[:frame]
           # Perform framing, if given a frame
           log_debug("writer") { "frame result"}
-          result = API.frame(result, frame, **@options)
+          result = API.frame(result, frame, **@options.merge(serializer: nil))
         elsif context
           # Perform compaction, if we have a context
           log_debug("writer") { "compact result"}
-          result = API.compact(result, context,  **@options)
+          result = API.compact(result, context,  **@options.merge(serializer: nil))
         end
 
-        @output.write(result.to_json(JSON_STATE))
+        @output.write(@serializer.call(result, **@options))
       end
 
       super

data/lib/json/ld.rb

@@ -46,6 +46,9 @@ module JSON
     # Default context when compacting without one being specified
     DEFAULT_CONTEXT = "http://schema.org"
 
+    # Acceptable MultiJson adapters
+    MUTLI_JSON_ADAPTERS = %i(oj json_gem json_pure ok_json yajl nsjsonseerialization)
+
     KEYWORDS = Set.new(%w(
       @annotation
       @base

data/spec/api_spec.rb

@@ -48,30 +48,78 @@ describe JSON::LD::API do
       context "with MultiJson adapter #{adapter.inspect}" do
         Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), 'test-files/*-input.*'))) do |filename|
           test = File.basename(filename).sub(/-input\..*$/, '')
-          frame = filename.sub(/-input\..*$/, '-frame.json')
-          framed = filename.sub(/-input\..*$/, '-framed.json')
-          compacted = filename.sub(/-input\..*$/, '-compacted.json')
-          context = filename.sub(/-input\..*$/, '-context.json')
-          expanded = filename.sub(/-input\..*$/, '-expanded.json')
+          frame = filename.sub(/-input\..*$/, '-frame.jsonld')
+          framed = filename.sub(/-input\..*$/, '-framed.jsonld')
+          compacted = filename.sub(/-input\..*$/, '-compacted.jsonld')
+          context = filename.sub(/-input\..*$/, '-context.jsonld')
+          expanded = filename.sub(/-input\..*$/, '-expanded.jsonld')
           ttl = filename.sub(/-input\..*$/, '-rdf.ttl')
       
           context test, skip: ("Not supported in JRuby" if RUBY_ENGINE == "jruby" && %w(oj yajl).include?(adapter.to_s)) do
-            it "expands" do
-              options = {logger: logger, adapter: adapter}
-              options[:expandContext] = File.open(context) if context
-              jld = described_class.expand(File.open(filename), **options)
-              expect(jld).to produce_jsonld(JSON.load(File.open(expanded)), logger)
-            end if File.exist?(expanded)
+            around do |example|
+              @file = File.open(filename)
+              case filename
+              when /.jsonld$/
+                @file.define_singleton_method(:content_type) {'application/ld+json'}
+              end
+              if context
+                @ctx_io = File.open(context)
+                case context
+                when /.jsonld$/
+                  @ctx_io.define_singleton_method(:content_type) {'application/ld+json'}
+                end
+              end
+              example.run
+              @file.close
+              @ctx_io.close if @ctx_io
+            end
+
+            if File.exist?(expanded)
+              it "expands" do
+                options = {logger: logger, adapter: adapter}
+                options[:expandContext] = @ctx_io if context
+                jld = described_class.expand(@file, **options)
+                expect(jld).to produce_jsonld(JSON.parse(File.read(expanded)), logger)
+              end
+
+              it "expands with serializer" do
+                options = {logger: logger, adapter: adapter}
+                options[:expandContext] = @ctx_io if context
+                jld = described_class.expand(@file, serializer: JSON::LD::API.method(:serializer), **options)
+                expect(jld).to be_a(String)
+                expect(JSON.load(jld)).to produce_jsonld(JSON.parse(File.read(expanded)), logger)
+              end
+            end
         
-            it "compacts" do
-              jld = described_class.compact(File.open(filename), File.open(context), adapter: adapter, logger: logger)
-              expect(jld).to produce_jsonld(JSON.load(File.open(compacted)), logger)
-            end if File.exist?(compacted) && File.exist?(context)
+            if File.exist?(compacted) && File.exist?(context)
+              it "compacts" do
+                jld = described_class.compact(@file, @ctx_io, adapter: adapter, logger: logger)
+                expect(jld).to produce_jsonld(JSON.parse(File.read(compacted)), logger)
+              end
+
+              it "compacts with serializer" do
+                jld = described_class.compact(@file, @ctx_io, serializer: JSON::LD::API.method(:serializer), adapter: adapter, logger: logger)
+                expect(jld).to be_a(String)
+                expect(JSON.load(jld)).to produce_jsonld(JSON.parse(File.read(compacted)), logger)
+              end
+            end
         
-            it "frame" do
-              jld = described_class.frame(File.open(filename), File.open(frame), adapter: adapter, logger: logger)
-              expect(jld).to produce_jsonld(JSON.load(File.open(framed)), logger)
-            end if File.exist?(framed) && File.exist?(frame)
+            if File.exist?(framed) && File.exist?(frame)
+              it "frames" do
+                File.open(frame) do |frame_io|
+                  jld = described_class.frame(@file, frame_io, adapter: adapter, logger: logger)
+                  expect(jld).to produce_jsonld(JSON.parse(File.read(framed)), logger)
+                end
+              end
+
+              it "frames with serializer" do
+                File.open(frame) do |frame_io|
+                  jld = described_class.frame(@file, frame_io, serializer: JSON::LD::API.method(:serializer), adapter: adapter, logger: logger)
+                  expect(jld).to be_a(String)
+                  expect(JSON.load(jld)).to produce_jsonld(JSON.parse(File.read(framed)), logger)
+                end
+              end
+            end
 
             it "toRdf" do
               expect(RDF::Repository.load(filename, format: :jsonld, adapter: adapter, logger: logger)).to be_equivalent_graph(RDF::Repository.load(ttl), logger: logger)