Add serializer option to API methods and Writer to be able to specify the proc to use when serializing to JSON.

Author: gkellogg

lib/json/ld/api.rb

@@ -155,6 +155,9 @@ def initialize(input, context, **options, &block)
     #
     # @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 +170,7 @@ def initialize(input, context, **options, &block)
     # @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 +183,7 @@ def self.expand(input, framing: false, **options, &block)
 
       # 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) if serializer
 
       if block_given?
         case block.arity
@@ -204,6 +208,9 @@ def self.expand(input, framing: false, **options, &block)
     #   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 +222,7 @@ def self.expand(input, framing: false, **options, &block)
     #   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 +245,7 @@ def self.compact(input, context, expanded: false, **options)
         end
         result = ctx.merge(result) unless ctx.fetch('@context', {}).empty?
       end
+      result = serializer.call(result) if serializer
       block_given? ? yield(result) : result
     end
 
@@ -251,6 +259,9 @@ def self.compact(input, context, expanded: false, **options)
     # @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 +273,7 @@ def self.compact(input, context, expanded: false, **options)
     # @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 +329,7 @@ def self.flatten(input, context, expanded: false, **options)
         end
       end
 
+      flattened = serializer.call(flattened) if serializer
       block_given? ? yield(flattened) : flattened
     end
 
@@ -350,7 +362,7 @@ def self.flatten(input, context, expanded: false, **options)
     #   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)),
@@ -467,6 +479,7 @@ def self.frame(input, frame, expanded: false, **options)
         result
       end
 
+      result = serializer.call(result) if serializer
       block_given? ? yield(result) : result
     end
 
@@ -528,18 +541,21 @@ def self.toRdf(input, expanded: false, **options, &block)
     # 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 +564,7 @@ def self.fromRdf(input, useRdfType: false, useNativeTypes: false, **options, &bl
           useNativeTypes: useNativeTypes)
       end
 
+      result = serializer.call(result) if serializer
       block_given? ? yield(result) : result
     end
 
@@ -794,6 +811,16 @@ def self.load_html(input, url:,
       raise JSON::LD::JsonLdError::InvalidScriptElement, e.message
     end
 
+    ##
+    # The default serializer for serialzing Ruby Objects to JSON.
+    #
+    # Defaults to `MultiJson.dump`
+    #
+    # @param [Object] object
+    def self.serializer(object)
+      MultiJson.dump(object, JSON_STATE)
+    end
+
     ##
     # Validate JSON using JsonLint, if loaded
     private

lib/json/ld/to_rdf.rb

@@ -11,7 +11,7 @@ module ToRDF
     ##
     # @param [Hash{String => Object}] item
     # @param [RDF::Resource] graph_name
-    # @param [Boolean] emitted triples are quoted triples.
+    # @param [Boolean] quoted emitted triples are quoted triples.
     # @yield statement
     # @yieldparam [RDF::Statement] statement
     # @return RDF::Resource the subject of this item

lib/json/ld/writer.rb

@@ -229,6 +229,8 @@ def default_context=(url); @default_context = url; end
     #   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 +241,7 @@ def default_context=(url); @default_context = url; end
     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
 
@@ -335,7 +338,7 @@ def write_epilogue
           result = API.compact(result, context,  **@options)
         end
 
-        @output.write(result.to_json(JSON_STATE))
+        @output.write(@serializer.call(result))
       end
 
       super

spec/api_spec.rb

@@ -56,22 +56,72 @@
           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)
+            if File.exist?(expanded)
+              it "expands" do
+                options = {logger: logger, adapter: adapter}
+                File.open(context) do |ctx_io|
+                  File.open(filename) do |file|
+                    options[:expandContext] = ctx_io if context
+                    jld = described_class.expand(file, **options)
+                    expect(jld).to produce_jsonld(JSON.parse(File.read(expanded)), logger)
+                  end
+                end
+              end
+
+              it "expands with serializer" do
+                options = {logger: logger, adapter: adapter}
+                File.open(context) do |ctx_io|
+                  File.open(filename) do |file|
+                    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
+              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
+                File.open(context) do |ctx_io|
+                  File.open(filename) do |file|
+                    jld = described_class.compact(file, ctx_io, adapter: adapter, logger: logger)
+                    expect(jld).to produce_jsonld(JSON.parse(File.read(compacted)), logger)
+                  end
+                end
+              end
+
+              it "compacts with serializer" do
+                File.open(context) do |ctx_io|
+                  File.open(filename) do |file|
+                    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
+              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|
+                  File.open(filename) do |file|
+                    jld = described_class.frame(file, frame_io, adapter: adapter, logger: logger)
+                    expect(jld).to produce_jsonld(JSON.parse(File.read(framed)), logger)
+                  end
+                end
+              end
+
+              it "frames with serializer" do
+                File.open(frame) do |frame_io|
+                  File.open(filename) do |file|
+                    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
+            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)

spec/suite_helper.rb

@@ -60,6 +60,7 @@ def self.open_file(filename_or_url, **options, &block)
         document_options[:headers][:content_type] = options[:contentType] if options[:contentType]
 
         remote_document = RDF::Util::File::RemoteDocument.new(response.read, **document_options)
+        response.close
         if block_given?
           return yield remote_document
         else