json-ld 1.1.7 → 1.1.8

data/spec/from_rdf_spec.rb

@@ -69,7 +69,7 @@ describe JSON::LD::API do
 
         it "integer" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1 .)
-          expect(serialize(input, :useNativeTypes => true)).to produce([{
+          expect(serialize(input, useNativeTypes: true)).to produce([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => 1}]
           }], @debug)
@@ -77,7 +77,7 @@ describe JSON::LD::API do
 
         it "integer (non-native)" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1 .)
-          expect(serialize(input, :useNativeTypes => false)).to produce([{
+          expect(serialize(input, useNativeTypes: false)).to produce([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => "1","@type" => "http://www.w3.org/2001/XMLSchema#integer"}]
           }], @debug)
@@ -85,7 +85,7 @@ describe JSON::LD::API do
 
         it "boolean" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b true .)
-          expect(serialize(input, :useNativeTypes => true)).to produce([{
+          expect(serialize(input, useNativeTypes: true)).to produce([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => true}]
           }], @debug)
@@ -93,7 +93,7 @@ describe JSON::LD::API do
 
         it "boolean (non-native)" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b true .)
-          expect(serialize(input, :useNativeTypes => false)).to produce([{
+          expect(serialize(input, useNativeTypes: false)).to produce([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => "true","@type" => "http://www.w3.org/2001/XMLSchema#boolean"}]
           }], @debug)
@@ -101,7 +101,7 @@ describe JSON::LD::API do
 
         it "decmal" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1.0 .)
-          expect(serialize(input, :useNativeTypes => true)).to produce([{
+          expect(serialize(input, useNativeTypes: true)).to produce([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => "1.0", "@type" => "http://www.w3.org/2001/XMLSchema#decimal"}]
           }], @debug)
@@ -109,7 +109,7 @@ describe JSON::LD::API do
 
         it "double" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1.0e0 .)
-          expect(serialize(input, :useNativeTypes => true)).to produce([{
+          expect(serialize(input, useNativeTypes: true)).to produce([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => 1.0E0}]
           }], @debug)
@@ -117,7 +117,7 @@ describe JSON::LD::API do
 
         it "double (non-native)" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1.0e0 .)
-          expect(serialize(input, :useNativeTypes => false)).to produce([{
+          expect(serialize(input, useNativeTypes: false)).to produce([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => "1.0E0","@type" => "http://www.w3.org/2001/XMLSchema#double"}]
           }], @debug)
@@ -126,12 +126,12 @@ describe JSON::LD::API do
 
       context "datatyped (non-native)" do
         {
-          :integer            => 1,
-          :unsignedInteger    => 1,
-          :nonNegativeInteger => 1,
-          :float              => 1,
-          :nonPositiveInteger => -1,
-          :negativeInteger    => -1,
+          integer:            1,
+          unsignedInteger:    1,
+          nonNegativeInteger: 1,
+          float:              1,
+          nonPositiveInteger: -1,
+          negativeInteger:    -1,
         }.each do |t, v|
           it "#{t}" do
             input = %(
@@ -139,7 +139,7 @@ describe JSON::LD::API do
               @prefix ex: <http://example.com/> .
               ex:a ex:b "#{v}"^^xsd:#{t} .
             )
-            expect(serialize(input, :useNativeTypes => false)).to produce([{
+            expect(serialize(input, useNativeTypes: false)).to produce([{
               '@id'   => "http://example.com/a",
               "http://example.com/b"    => [{"@value" => "#{v}","@type" => "http://www.w3.org/2001/XMLSchema##{t}"}]
             }], @debug)
@@ -273,7 +273,7 @@ describe JSON::LD::API do
         ],
       }.each do |name, (input, output, reader)|
         it name do
-          r = serialize(input, :reader => reader)
+          r = serialize(input, reader: reader)
           expect(r).to produce(output, @debug)
         end
       end
@@ -282,10 +282,10 @@ describe JSON::LD::API do
     context "quads" do
       {
         "simple named graph" => {
-          :input => %(
+          input: %(
             <http://example.com/a> <http://example.com/b> <http://example.com/c> <http://example.com/U> .
           ),
-          :output => [
+          output: [
             {
               "@id" => "http://example.com/U",
               "@graph" => [{
@@ -296,11 +296,11 @@ describe JSON::LD::API do
           ]
         },
         "with properties" => {
-          :input => %(
+          input: %(
             <http://example.com/a> <http://example.com/b> <http://example.com/c> <http://example.com/U> .
             <http://example.com/U> <http://example.com/d> <http://example.com/e> .
           ),
-          :output => [
+          output: [
             {
               "@id" => "http://example.com/U",
               "@graph" => [{
@@ -312,7 +312,7 @@ describe JSON::LD::API do
           ]
         },
         "with lists" => {
-          :input => %(
+          input: %(
             <http://example.com/a> <http://example.com/b> _:a <http://example.com/U> .
             _:a <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://example.com/c> <http://example.com/U> .
             _:a <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> <http://example.com/U> .
@@ -320,7 +320,7 @@ describe JSON::LD::API do
             _:b <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://example.com/e> .
             _:b <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
           ),
-          :output => [
+          output: [
             {
               "@id" => "http://example.com/U",
               "@graph" => [{
@@ -332,7 +332,7 @@ describe JSON::LD::API do
           ]
         },
         "Two Graphs with same subject and lists" => {
-          :input => %(
+          input: %(
             <http://example.com/a> <http://example.com/b> _:a <http://example.com/U> .
             _:a <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://example.com/c> <http://example.com/U> .
             _:a <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> <http://example.com/U> .
@@ -340,7 +340,7 @@ describe JSON::LD::API do
             _:b <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://example.com/e> <http://example.com/V> .
             _:b <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> <http://example.com/V> .
           ),
-          :output => [
+          output: [
             {
               "@id" => "http://example.com/U",
               "@graph" => [
@@ -367,7 +367,7 @@ describe JSON::LD::API do
         },
       }.each_pair do |name, properties|
         it name do
-          r = serialize(properties[:input], :reader => RDF::NQuads::Reader)
+          r = serialize(properties[:input], reader: RDF::NQuads::Reader)
           expect(r).to produce(properties[:output], @debug)
         end
       end
@@ -409,6 +409,6 @@ describe JSON::LD::API do
     g = ntstr.is_a?(String) ? parse(ntstr, options) : ntstr
     @debug << g.dump(:trig)
     statements = g.each_statement.to_a
-    JSON::LD::API.fromRdf(statements, options.merge(:debug => @debug))
+    JSON::LD::API.fromRdf(statements, options.merge(debug: @debug))
   end
 end

data/spec/matchers.rb

@@ -8,22 +8,22 @@ def normalize(graph)
   case graph
   when RDF::Enumerable then graph
   when IO, StringIO
-    RDF::Graph.new.load(graph, :base => @info.about)
+    RDF::Graph.new.load(graph, base: @info.about)
   else
     # Figure out which parser to use
     g = RDF::Repository.new
     reader_class = detect_format(graph)
-    reader_class.new(graph, :base => @info.about).each {|s| g << s}
+    reader_class.new(graph, base: @info.about).each {|s| g << s}
     g
   end
 end
 
 RSpec::Matchers.define :be_equivalent_graph do |expected, info|
   match do |actual|
-    @info = if info.respond_to?(:about)
+    @info = if info.respond_to?(:input)
       info
     elsif info.is_a?(Hash)
-      identifier = info[:identifier] || expected.is_a?(RDF::Graph) ? expected.context : info[:about]
+      identifier = info[:identifier] || info[:about]
       trace = info[:trace]
       trace = trace.join("\n") if trace.is_a?(Array)
       Info.new(identifier, info[:information] || "", trace, info[:inputDocument])
@@ -45,8 +45,8 @@ RSpec::Matchers.define :be_equivalent_graph do |expected, info|
       "Graph differs"
     end +
     "\n#{info + "\n" unless info.empty?}" +
-    "Unsorted Expected:\n#{@expected.dump(:nquads, :standard_prefixes => true)}" +
-    "Unsorted Results:\n#{@actual.dump(:nquads, :standard_prefixes => true)}" +
+    "Unsorted Expected:\n#{@expected.dump(:nquads, standard_prefixes: true)}" +
+    "Unsorted Results:\n#{@actual.dump(:nquads, standard_prefixes: true)}" +
     (@info.inputDocument ? "Input file: #{@info.inputDocument}\n" : "") +
     (@info.outputDocument ? "Output file: #{@info.outputDocument}\n" : "") +
     (@info.trace ? "\nDebug:\n#{@info.trace}" : "")
@@ -59,9 +59,9 @@ RSpec::Matchers.define :produce do |expected, info|
   end
   
   failure_message do |actual|
-    "Expected: #{expected.is_a?(String) ? expected : expected.to_json(JSON_STATE)}\n" +
-    "Actual  : #{actual.is_a?(String) ? actual : actual.to_json(JSON_STATE)}\n" +
-    #(expected.is_a?(Hash) && actual.is_a?(Hash) ? "Diff: #{expected.diff(actual).to_json(JSON_STATE)}\n" : "") +
+    "Expected: #{expected.is_a?(String) ? expected : expected.to_json(JSON_STATE) rescue 'malformed json'}\n" +
+    "Actual  : #{actual.is_a?(String) ? actual : actual.to_json(JSON_STATE) rescue 'malformed json'}\n" +
+    #(expected.is_a?(Hash) && actual.is_a?(Hash) ? "Diff: #{expected.diff(actual).to_json(JSON_STATE) rescue 'malformed json'}\n" : "") +
     "Processing results:\n#{info.join("\n")}"
   end
 end

data/spec/reader_spec.rb

@@ -23,10 +23,10 @@ describe JSON::LD::Reader do
     formats = [
       :jsonld,
       "etc/doap.jsonld",
-      {:file_name      => 'etc/doap.jsonld'},
-      {:file_extension => 'jsonld'},
-      {:content_type   => 'application/ld+json'},
-      {:content_type   => 'application/x-ld+json'},
+      {file_name:      'etc/doap.jsonld'},
+      {file_extension: 'jsonld'},
+      {content_type:   'application/ld+json'},
+      {content_type:   'application/x-ld+json'},
     ].each do |arg|
       it "discovers with #{arg.inspect}" do
         expect(RDF::Reader.for(arg)).to eq JSON::LD::Reader

data/spec/resource_spec.rb

@@ -18,7 +18,7 @@ describe JSON::LD::Resource do
     end
 
     describe "compacted with context" do
-      subject {JSON::LD::Resource.new({'@id' => '_:foo', "http://schema.org/name" => "foo"}, :compact => true, :context => {"@vocab" => "http://schema.org/"})}
+      subject {JSON::LD::Resource.new({'@id' => '_:foo', "http://schema.org/name" => "foo"}, compact: true, context: {"@vocab" => "http://schema.org/"})}
       specify {expect(subject).not_to be_nil}
       specify {expect(subject).to be_a(JSON::LD::Resource)}
       specify {expect(subject).not_to be_clean}

data/spec/spec_helper.rb

@@ -12,27 +12,32 @@ require 'rdf/trig'
 require 'rdf/spec'
 require 'rdf/spec/matchers'
 require 'yaml'
-require 'open-uri/cached'
+require 'restclient/components'
+require 'rack/cache'
 require 'matchers'
 
 JSON_STATE = JSON::State.new(
-  :indent       => "  ",
-  :space        => " ",
-  :space_before => "",
-  :object_nl    => "\n",
-  :array_nl     => "\n"
+  indent:       "  ",
+  space:        " ",
+  space_before: "",
+  object_nl:    "\n",
+  array_nl:     "\n"
 )
 
 # Create and maintain a cache of downloaded URIs
 URI_CACHE = File.expand_path(File.join(File.dirname(__FILE__), "uri-cache"))
 Dir.mkdir(URI_CACHE) unless File.directory?(URI_CACHE)
-OpenURI::Cache.class_eval { @cache_path = URI_CACHE }
+# Cache client requests
+RestClient.enable Rack::Cache,
+  verbose:      false, 
+  metastore:   "file:" + ::File.expand_path("../uri-cache/meta", __FILE__),
+  entitystore: "file:" + ::File.expand_path("../uri-cache/body", __FILE__)
 
 ::RSpec.configure do |c|
-  c.filter_run :focus => true
+  c.filter_run focus: true
   c.run_all_when_everything_filtered = true
   c.exclusion_filter = {
-    :ruby => lambda { |version| !(RUBY_VERSION.to_s =~ /^#{version.to_s}/) },
+    ruby: lambda { |version| !(RUBY_VERSION.to_s =~ /^#{version.to_s}/) },
   }
   c.include(RDF::Spec::Matchers)
 end

data/spec/streaming_writer_spec.rb

@@ -0,0 +1,142 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+require 'rdf/spec/writer'
+require 'json/ld/streaming_writer'
+
+describe JSON::LD::StreamingWriter do
+  before :each do
+    @writer = JSON::LD::Writer.new(StringIO.new(""), stream: true)
+  end
+
+  include RDF_Writer
+
+  context "simple tests" do
+    it "should use full URIs without base" do
+      input = %(<http://a/b> <http://a/c> <http://a/d> .)
+      obj = serialize(input)
+      expect(parse(obj.to_json, format: :jsonld)).to be_equivalent_graph(parse input)
+      expect(obj).to produce([{
+        '@id'         => "http://a/b",
+        "http://a/c"  => [{"@id" => "http://a/d"}]
+      }], @debug)
+    end
+
+    it "writes multiple kinds of statements" do
+      input = %(
+        <https://senet.org/gm> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://vocab.org/frbr/core#Work> .
+        <https://senet.org/gm> <http://purl.org/dc/terms/title> "Rhythm Paradise"@en .
+        <https://senet.org/gm> <https://senet.org/ns#unofficialTitle> "Rhythm Tengoku"@en .
+        <https://senet.org/gm> <https://senet.org/ns#urlkey> "rhythm-tengoku" .
+      )
+      obj = serialize(input)
+      expect(parse(obj.to_json, format: :jsonld)).to be_equivalent_graph(parse input)
+      expect(obj).to eql JSON.parse(%{[{
+        "@id": "https://senet.org/gm",
+        "@type": ["http://vocab.org/frbr/core#Work"],
+        "http://purl.org/dc/terms/title": [{"@value": "Rhythm Paradise", "@language": "en"}],
+        "https://senet.org/ns#unofficialTitle": [{"@value": "Rhythm Tengoku", "@language": "en"}],
+        "https://senet.org/ns#urlkey": [{"@value": "rhythm-tengoku"}]
+      }]})
+    end
+
+    it "serializes multiple subjects" do
+      input = %q(
+        @prefix : <http://www.w3.org/2006/03/test-description#> .
+        @prefix dc: <http://purl.org/dc/terms/> .
+        <http://example.com/test-cases/0001> a :TestCase .
+        <http://example.com/test-cases/0002> a :TestCase .
+      )
+      obj = serialize(input)
+      expect(parse(obj.to_json, format: :jsonld)).to be_equivalent_graph(parse input)
+      expect(obj).to eql JSON.parse(%{[
+        {"@id": "http://example.com/test-cases/0001", "@type": ["http://www.w3.org/2006/03/test-description#TestCase"]},
+        {"@id": "http://example.com/test-cases/0002", "@type": ["http://www.w3.org/2006/03/test-description#TestCase"]}
+      ]})
+    end
+  end
+
+  context "Named Graphs" do
+    {
+      "default" => [
+        %q({<a> <b> <c> .}),
+        %q([{"@id": "a", "b": [{"@id": "c"}]}])
+      ],
+      "named" => [
+        %q(<C> {<a> <b> <c> .}),
+        %q([{"@id" :  "C", "@graph" :  [{"@id": "a", "b": [{"@id": "c"}]}]}])
+      ],
+      "combo" => [
+        %q(
+          <a> <b> <c> .
+          <C> {<A> <b> <c> .}
+        ),
+        %q([
+          {"@id": "a", "b": [{"@id": "c"}]},
+          {"@id": "C", "@graph": [{"@id": "A", "b": [{"@id": "c"}]}]}
+        ])
+      ],
+      "combo with duplicated statement" => [
+        %q(
+          <a> <b> <c> .
+          <C> {<a> <b> <c> .}
+        ),
+        %q([
+          {"@id": "a", "b": [{"@id": "c"}]},
+          {"@id": "C", "@graph": [{"@id": "a", "b": [{"@id": "c"}]}]}
+        ])
+      ],
+    }.each_pair do |title, (input, matches)|
+      context title do
+        subject {serialize(input)}
+        it "matches expected json" do
+          expect(subject).to produce(JSON.parse(matches), @debug)
+        end
+      end
+    end
+  end
+
+
+  context "Writes fromRdf tests to isomorphic graph", skip: ENV['CI'] do
+    require 'suite_helper'
+    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}tests/fromRdf-manifest.jsonld")
+    [nil, {}].each do |ctx|
+      context "with context #{ctx.inspect}" do
+        describe m.name do
+          m.entries.each do |t|
+            next unless t.positiveTest? && !t.property('input').include?('0016')
+            t.debug = ["test: #{t.inspect}", "source: #{t.input}"]
+            specify "#{t.property('input')}: #{t.name}" do
+              repo = RDF::Repository.load(t.input_loc, format: :nquads)
+              jsonld = JSON::LD::Writer.buffer(stream: true, context: ctx, debug: t.debug) do |writer|
+                writer << repo
+              end
+              t.debug << "Generated: #{jsonld}"
+
+              # And then, re-generate jsonld as RDF
+              expect(parse(jsonld, format: :jsonld)).to be_equivalent_graph(repo, t)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def parse(input, options = {})
+    format = options.fetch(:format, :trig)
+    reader = RDF::Reader.for(format)
+    RDF::Repository.new << reader.new(input, options)
+  end
+
+  # Serialize ntstr to a string and compare against regexps
+  def serialize(ntstr, options = {})
+    g = ntstr.is_a?(String) ? parse(ntstr, options) : ntstr
+    @debug = [] << g.dump(:ttl)
+    result = JSON::LD::Writer.buffer(options.merge(debug: @debug, stream: true)) do |writer|
+      writer << g
+    end
+    puts result if $verbose
+    
+    JSON.parse(result)
+  end
+end

data/spec/suite_helper.rb

@@ -1,5 +1,4 @@
 require 'json/ld'
-require 'open-uri'
 require 'support/extensions'
 
 module Fixtures
@@ -44,7 +43,7 @@ module Fixtures
 
       def options
         @options ||= begin
-          opts = {:documentLoader => Fixtures::SuiteTest.method(:documentLoader)}
+          opts = {documentLoader: Fixtures::SuiteTest.method(:documentLoader)}
           {'processingMode' => "json-ld-1.0"}.merge(property('option') || {}).each do |k, v|
             opts[k.to_sym] = v
           end
@@ -57,7 +56,7 @@ module Fixtures
         define_method(m.to_sym) do
           return nil unless property(m)
           res = nil
-          Fixtures::SuiteTest.documentLoader("#{SUITE}tests/#{property(m)}", :safe => true) do |remote_doc|
+          Fixtures::SuiteTest.documentLoader("#{SUITE}tests/#{property(m)}", safe: true) do |remote_doc|
             res = remote_doc.document
           end
           res
@@ -86,13 +85,13 @@ module Fixtures
 
       # Execute the test
       def run(rspec_example = nil)
-        debug = ["test: #{inspect}", "source: #{input}"]
-        debug << "context: #{context}" if context_loc
-        debug << "options: #{options.inspect}" unless options.empty?
-        debug << "frame: #{frame}" if frame_loc
+        @debug = ["test: #{inspect}", "source: #{input}"]
+        @debug << "context: #{context}" if context_loc
+        @debug << "options: #{options.inspect}" unless options.empty?
+        @debug << "frame: #{frame}" if frame_loc
 
         options = if self.options[:useDocumentLoader]
-          self.options.merge(:documentLoader => Fixtures::SuiteTest.method(:documentLoader))
+          self.options.merge(documentLoader: Fixtures::SuiteTest.method(:documentLoader))
         else
           self.options.dup
         end
@@ -102,19 +101,19 @@ module Fixtures
           begin
             result = case testType
             when "jld:ExpandTest"
-              JSON::LD::API.expand(input_loc, options.merge(:debug => debug))
+              JSON::LD::API.expand(input_loc, options.merge(debug: @debug))
             when "jld:CompactTest"
-              JSON::LD::API.compact(input_loc, context_json['@context'], options.merge(:debug => debug))
+              JSON::LD::API.compact(input_loc, context_json['@context'], options.merge(debug: @debug))
             when "jld:FlattenTest"
-              JSON::LD::API.flatten(input_loc, context_loc, options.merge(:debug => debug))
+              JSON::LD::API.flatten(input_loc, context_loc, options.merge(debug: @debug))
             when "jld:FrameTest"
-              JSON::LD::API.frame(input_loc, frame_loc, options.merge(:debug => debug))
+              JSON::LD::API.frame(input_loc, frame_loc, options.merge(debug: @debug))
             when "jld:FromRDFTest"
-              repo = RDF::Repository.load(input_loc, :format => :nquads)
-              debug << "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
-              JSON::LD::API.fromRdf(repo, options.merge(:debug => debug))
+              repo = RDF::Repository.load(input_loc, format: :nquads)
+              @debug << "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
+              JSON::LD::API.fromRdf(repo, options.merge(debug: @debug))
             when "jld:ToRDFTest"
-              JSON::LD::API.toRdf(input_loc, options.merge(:debug => debug)).map do |statement|
+              JSON::LD::API.toRdf(input_loc, options.merge(debug: @debug)).map do |statement|
                 to_quad(statement)
               end
             else
@@ -124,12 +123,12 @@ module Fixtures
               if testType == "jld:ToRDFTest"
                 expected = expect
                 rspec_example.instance_eval {
-                  expect(result.sort.join("")).to produce(expected, debug)
+                  expect(result.sort.join("")).to produce(expected, @debug)
                 }
               else
                 expected = JSON.load(expect)
                 rspec_example.instance_eval {
-                  expect(result).to produce(expected, debug)
+                  expect(result).to produce(expected, @debug)
                 }
               end
             else
@@ -143,26 +142,26 @@ module Fixtures
             fail("Invalid Frame: #{e.message}")
           end
         else
-          debug << "expected: #{property('expect')}" if property('expect')
+          @debug << "expected: #{property('expect')}" if property('expect')
           t = self
           rspec_example.instance_eval do
             if t.evaluationTest?
               expect do
                 case t.testType
                 when "jld:ExpandTest"
-                  JSON::LD::API.expand(t.input_loc, options.merge(:debug => debug))
+                  JSON::LD::API.expand(t.input_loc, options.merge(debug: @debug))
                 when "jld:CompactTest"
-                  JSON::LD::API.compact(t.input_loc, t.context_json['@context'], options.merge(:debug => debug))
+                  JSON::LD::API.compact(t.input_loc, t.context_json['@context'], options.merge(debug: @debug))
                 when "jld:FlattenTest"
-                  JSON::LD::API.flatten(t.input_loc, t.context_loc, options.merge(:debug => debug))
+                  JSON::LD::API.flatten(t.input_loc, t.context_loc, options.merge(debug: @debug))
                 when "jld:FrameTest"
-                  JSON::LD::API.frame(t.input_loc, t.frame_loc, options.merge(:debug => debug))
+                  JSON::LD::API.frame(t.input_loc, t.frame_loc, options.merge(debug: @debug))
                 when "jld:FromRDFTest"
                   repo = RDF::Repository.load(t.input_loc)
-                  debug << "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
-                  JSON::LD::API.fromRdf(repo, options.merge(:debug => debug))
+                  @debug << "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
+                  JSON::LD::API.fromRdf(repo, options.merge(debug: @debug))
                 when "jld:ToRDFTest"
-                  JSON::LD::API.toRdf(t.input_loc, options.merge(:debug => debug)).map do |statement|
+                  JSON::LD::API.toRdf(t.input_loc, options.merge(debug: @debug)).map do |statement|
                     t.to_quad(statement)
                   end
                 else
@@ -229,8 +228,7 @@ module Fixtures
     # @yield remote_document
     # @yieldparam [RemoteDocument] remote_document
     # @raise [JsonLdError]
-    def documentLoader(url, options = {})
-      require 'net/http' unless defined?(Net::HTTP)
+    def documentLoader(url, options = {}, &block)
       remote_document = nil
       options[:headers] ||= JSON::LD::API::OPEN_OPTS[:headers]
 
@@ -247,66 +245,9 @@ module Fixtures
         end
       end
 
-      case url.to_s
-      when /^http/
-        parsed_url = ::URI.parse(url.to_s)
-        until remote_document do
-          Net::HTTP::start(parsed_url.host, parsed_url.port) do |http|
-            request = Net::HTTP::Get.new(parsed_url.request_uri, options[:headers])
-            http.request(request) do |response|
-              case response
-              when Net::HTTPSuccess
-                # found object
-                content_type, ct_param = response.content_type.to_s.downcase.split(";")
-                if content_type && options[:validate]
-                  main, sub = content_type.split("/")
-                  raise JSON::LD::JsonLdError::LoadingDocumentFailed, "content_type: #{content_type}" if
-                    main != 'application' ||
-                    sub !~ /^(.*\+)?json$/
-                end
-
-                remote_document = JSON::LD::API::RemoteDocument.new(parsed_url.to_s, response.body)
-
-                unless content_type.to_s.start_with?("application/ld+json")
-                  links = response["link"].to_s.
-                    split(",").
-                    map(&:strip).
-                    select {|h| h =~ %r{rel=\"http://www.w3.org/ns/json-ld#context\"}}
-                  case links.length
-                  when 0  then #nothing to do
-                  when 1
-                    remote_document.contextUrl = links.first.match(/<([^>]*)>/) && $1
-                  else
-                    raise JSON::LD::JsonLdError::MultipleContextLinkHeaders,
-                      "expected at most 1 Link header with rel=jsonld:context, got #{links.length}"
-                  end
-                end
-                return block_given? ? yield(remote_document) : remote_document
-              when Net::HTTPRedirection
-                # Follow redirection
-                parsed_url = ::URI.parse(response["Location"])
-              else
-                raise JSON::LD::JsonLdError::LoadingDocumentFailed,
-                  "<#{parsed_url}>: #{response.msg}(#{response.code})"
-              end
-            end
-          end
-        end
-      else
-        # Use regular open
-        RDF::Util::File.open_file(url, options) do |f|
-          remote_document = JSON::LD::API::RemoteDocument.new(url, f.read)
-          content_type, ct_param = f.content_type.to_s.downcase.split(";") if f.respond_to?(:content_type)
-          if content_type && options[:validate]
-            main, sub = content_type.split("/")
-            raise JSON::LD::JsonLdError::LoadingDocumentFailed, "content_type: #{content_type}" if
-              main != 'application' ||
-              sub !~ /^(.*\+)?json$/
-          end
-
-          return block_given? ? yield(remote_document) : remote_document
-        end
-      end
+      # don't cache for these specs
+      options = options.merge(use_net_http: true) if url.to_s =~ /remote-doc/
+      JSON::LD::API.documentLoader(url, options, &block)
     rescue JSON::LD::JsonLdError::LoadingDocumentFailed, JSON::LD::JsonLdError::MultipleContextLinkHeaders
       raise unless options[:safe]
       "don't raise error"