Don't serialize when API methods are used internally.

Author: gkellogg

README.md

@@ -46,6 +46,9 @@ module LD
     # 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

lib/json/ld.rb

@@ -126,7 +126,8 @@ def initialize(input, context, **options, &block)
 
         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
@@ -391,7 +392,8 @@ def self.frame(input, frame, expanded: false, serializer: nil, **options)
                                         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
@@ -665,7 +667,8 @@ def self.loadRemoteDocument(url,
             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
 
@@ -699,8 +702,8 @@ def self.documentLoader(url, extractAllScripts: false, profile: nil, requestProf
         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
@@ -776,7 +779,8 @@ def self.load_html(input, url:,
         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
@@ -790,7 +794,8 @@ def self.load_html(input, url:,
         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)
@@ -805,7 +810,8 @@ def self.load_html(input, url:,
         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

lib/json/ld/api.rb

@@ -57,7 +57,7 @@ def self.options
     end
 
     ##
-    # Initializes the RDF/JSON reader instance.
+    # Initializes the JSON-LD reader instance.
     #
     # @param  [IO, File, String]       input
     # @param  [Hash{Symbol => Object}] options

lib/json/ld/reader.rb

@@ -26,7 +26,8 @@ def stream_statement(&block)
       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)

lib/json/ld/streaming_reader.rb

@@ -186,10 +186,6 @@ class << self
       # @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
@@ -303,7 +299,7 @@ def write_epilogue
       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(' ')
@@ -325,17 +321,17 @@ def write_epilogue
 
         # 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(@serializer.call(result))

lib/json/ld/writer.rb

@@ -48,77 +48,75 @@
       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
+            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}
-                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
+                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}
-                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
+                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
 
             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
+                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
-                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
+                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
 
             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
+                  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|
-                  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
+                  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

spec/api_spec.rb

@@ -73,8 +73,8 @@
   describe ".cli_commands", skip: Gem.win_platform? do
     require 'rdf/cli'
     let(:ttl) {File.expand_path("../test-files/test-1-rdf.ttl", __FILE__)}
-    let(:json) {File.expand_path("../test-files/test-1-input.json", __FILE__)}
-    let(:context) {File.expand_path("../test-files/test-1-context.json", __FILE__)}
+    let(:json) {File.expand_path("../test-files/test-1-input.jsonld", __FILE__)}
+    let(:context) {File.expand_path("../test-files/test-1-context.jsonld", __FILE__)}
 
     describe "#expand" do
       it "expands RDF" do