json-ld 2.2.1 → 3.0.0

data/spec/from_rdf_spec.rb

@@ -272,6 +272,105 @@ describe JSON::LD::API do
           }],
           RDF::NQuads::Reader
         ],
+        "multiple graphs with shared BNode (at head)" => [
+          %q(
+            <http://www.example.com/z> <http://www.example.com/q> _:z0 <http://www.example.com/G> .
+            _:z0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "cell-A" <http://www.example.com/G> .
+            _:z0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:z1 <http://www.example.com/G> .
+            _:z1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "cell-B" <http://www.example.com/G> .
+            _:z1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> <http://www.example.com/G> .
+            <http://www.example.com/z> <http://www.example.com/q> _:z0 <http://www.example.com/G1> .
+          ),
+          [{
+            "@id" => "http://www.example.com/G",
+            "@graph" => [{
+              "@id" => "_:z0",
+              "http://www.w3.org/1999/02/22-rdf-syntax-ns#first" => [{"@value" => "cell-A"}],
+              "http://www.w3.org/1999/02/22-rdf-syntax-ns#rest" => [{"@list" => [{ "@value" => "cell-B" }]}]
+            }, {
+              "@id" => "http://www.example.com/z",
+              "http://www.example.com/q" => [{"@id" => "_:z0"}]
+            }]
+          },
+          {
+            "@id" => "http://www.example.com/G1",
+            "@graph" => [{
+              "@id" => "http://www.example.com/z",
+              "http://www.example.com/q" => [{"@id" => "_:z0"}]
+            }]
+          }],
+          RDF::NQuads::Reader
+        ],
+        "@list containing empty @list" => [
+          %(
+            <http://example.com/a> <http://example.com/property> (()) .
+          ),
+          JSON.parse(%([{
+            "@id": "http://example.com/a",
+            "http://example.com/property": [{"@list": [{"@list": []}]}]
+          }])),
+          RDF::Turtle::Reader
+        ],
+        "@list containing multiple lists" => [
+          %(
+            <http://example.com/a> <http://example.com/property> (("a") ("b")) .
+          ),
+          JSON.parse(%([{
+            "@id": "http://example.com/a",
+            "http://example.com/property": [{"@list": [
+              {"@list": [{"@value": "a"}]},
+              {"@list": [{"@value": "b"}]}
+            ]}]
+          }])),
+          RDF::Turtle::Reader
+        ],
+        "0008a" => [
+          %(
+          <http://example.com> <http://example.com/property> _:outerlist .
+          _:outerlist <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> _:lista .
+          _:outerlist <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:b0 .
+
+          _:lista <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "a1" .
+          _:lista <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:a2 .
+          _:a2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "a2" .
+          _:a2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:a3 .
+          _:a3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "a3" .
+          _:a3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+
+          _:c0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> _:c1 .
+          _:c0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+          _:c1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "c1" .
+          _:c1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:c2 .
+          _:c2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "c2" .
+          _:c2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:c3 .
+          _:c3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "c3" .
+          _:c3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+
+          _:b0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> _:b1 .
+          _:b0 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:c0 .
+          _:b1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "b1" .
+          _:b1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:b2 .
+          _:b2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "b2" .
+          _:b2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:b3 .
+          _:b3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "b3" .
+          _:b3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
+          ),
+          JSON.parse(%([
+            {
+              "@id": "http://example.com",
+              "http://example.com/property": [
+                {
+                  "@list": [
+                    {"@list": [{"@value": "a1"}, {"@value": "a2"}, {"@value": "a3"}]},
+                    {"@list": [{"@value": "b1"}, {"@value": "b2"}, {"@value": "b3"}]},
+                    {"@list": [{"@value": "c1"}, {"@value": "c2"}, {"@value": "c3"}]}
+                  ]
+                }
+              ]
+            }
+          ])),
+          RDF::NQuads::Reader
+        ]
       }.each do |name, (input, output, reader)|
         it name do
           r = serialize(input, reader: reader)
@@ -398,17 +497,17 @@ describe JSON::LD::API do
     end
   end
 
-  def parse(input, options = {})
+  def parse(input, **options)
     reader = options[:reader] || RDF::TriG::Reader
     reader.new(input, options, &:each_statement).to_a.extend(RDF::Enumerable)
   end
 
   # Serialize ntstr to a string and compare against regexps
-  def serialize(ntstr, options = {})
+  def serialize(ntstr, **options)
     logger.info ntstr if ntstr.is_a?(String)
     g = ntstr.is_a?(String) ? parse(ntstr, options) : ntstr
     logger.info g.dump(:trig)
     statements = g.each_statement.to_a
-    JSON::LD::API.fromRdf(statements, options.merge(logger: logger))
+    JSON::LD::API.fromRdf(statements, logger: logger, **options)
   end
 end

data/spec/streaming_writer_spec.rb

@@ -50,10 +50,10 @@ describe JSON::LD::StreamingWriter do
       )
       obj = serialize(input)
       expect(parse(obj.to_json, format: :jsonld)).to be_equivalent_graph(parse(input), logger: logger)
-      expect(obj).to contain_exactly *JSON.parse(%{[
+      expect(obj).to contain_exactly(*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
 
@@ -91,7 +91,7 @@ describe JSON::LD::StreamingWriter do
       context title do
         subject {serialize(input)}
         it "matches expected json" do
-          expect(subject).to contain_exactly *JSON.parse(matches)
+          expect(subject).to contain_exactly(*JSON.parse(matches))
         end
       end
     end
@@ -100,7 +100,7 @@ describe JSON::LD::StreamingWriter do
 
   context "Writes fromRdf tests to isomorphic graph" do
     require 'suite_helper'
-    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}tests/fromRdf-manifest.jsonld")
+    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}fromRdf-manifest.jsonld")
     [nil, {}].each do |ctx|
       context "with context #{ctx.inspect}" do
         describe m.name do
@@ -109,7 +109,7 @@ describe JSON::LD::StreamingWriter do
             t.logger = RDF::Spec.logger
             t.logger.info "test: #{t.inspect}"
             t.logger.info "source: #{t.input}"
-            specify "#{t.property('input')}: #{t.name}" do
+            specify "#{t.property('@id')}: #{t.name}" do
               repo = RDF::Repository.load(t.input_loc, format: :nquads)
               jsonld = JSON::LD::Writer.buffer(stream: true, context: ctx, logger: t.logger) do |writer|
                 writer << repo
@@ -125,18 +125,17 @@ describe JSON::LD::StreamingWriter do
     end
   end unless ENV['CI']
 
-  def parse(input, options = {})
-    format = options.fetch(:format, :trig)
+  def parse(input, format: :trig, **options)
     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 = {})
+  def serialize(ntstr, **options)
     g = ntstr.is_a?(String) ? parse(ntstr, options) : ntstr
     logger = RDF::Spec.logger
     logger.info(g.dump(:ttl))
-    result = JSON::LD::Writer.buffer(options.merge(logger: logger, stream: true)) do |writer|
+    result = JSON::LD::Writer.buffer(logger: logger, stream: true, **options) do |writer|
       writer << g
     end
     puts result if $verbose

data/spec/suite_compact_spec.rb

@@ -4,10 +4,10 @@ require_relative 'spec_helper'
 describe JSON::LD do
   describe "test suite" do
     require_relative 'suite_helper'
-    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}tests/compact-manifest.jsonld")
+    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}compact-manifest.jsonld")
     describe m.name do
       m.entries.each do |t|
-        specify "#{t.property('input')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
+        specify "#{t.property('@id')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
           t.run self
         end
       end

data/spec/suite_expand_spec.rb

@@ -4,10 +4,10 @@ require_relative 'spec_helper'
 describe JSON::LD do
   describe "test suite" do
     require_relative 'suite_helper'
-    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}tests/expand-manifest.jsonld")
+    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}expand-manifest.jsonld")
     describe m.name do
       m.entries.each do |t|
-        specify "#{t.property('input')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
+        specify "#{t.property('@id')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
           t.run self
         end
       end

data/spec/suite_flatten_spec.rb

@@ -4,10 +4,10 @@ require_relative 'spec_helper'
 describe JSON::LD do
   describe "test suite" do
     require_relative 'suite_helper'
-    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}tests/flatten-manifest.jsonld")
+    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}flatten-manifest.jsonld")
     describe m.name do
       m.entries.each do |t|
-        specify "#{t.property('input')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
+        specify "#{t.property('@id')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
           pending "context corner-case" if t.input_loc.end_with?('flatten-0044-in.jsonld')
           t.run self
         end

data/spec/suite_frame_spec.rb

@@ -4,7 +4,7 @@ require_relative 'spec_helper'
 describe JSON::LD do
   describe "test suite" do
     require_relative 'suite_helper'
-    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}tests/frame-manifest.jsonld")
+    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::FRAME_SUITE}frame-manifest.jsonld")
     describe m.name do
       m.entries.each do |t|
         specify "#{t.property('input')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
@@ -13,4 +13,4 @@ describe JSON::LD do
       end
     end
   end
-end unless ENV['CI']
+end unless ENV['CI'] || true

data/spec/suite_from_rdf_spec.rb

@@ -4,11 +4,10 @@ require_relative 'spec_helper'
 describe JSON::LD do
   describe "test suite" do
     require_relative 'suite_helper'
-    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}tests/fromRdf-manifest.jsonld")
+    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}fromRdf-manifest.jsonld")
     describe m.name do
       m.entries.each do |t|
-        specify "#{t.property('input')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
-          pending "Shared list BNode in different graphs" if t.property('input').include?("fromRdf-0021")
+        specify "#{t.property('@id')}: #{t.name}#{' (negative test)' unless t.positiveTest?}" do
           t.run self
         end
       end

data/spec/suite_helper.rb

@@ -4,8 +4,11 @@ require_relative 'support/extensions'
 # For now, override RDF::Utils::File.open_file to look for the file locally before attempting to retrieve it
 module RDF::Util
   module File
-    REMOTE_PATH = "https://json-ld.org/test-suite/"
-    LOCAL_PATH = ::File.expand_path("../json-ld.org/test-suite", __FILE__) + '/'
+    LOCAL_PATHS = {
+      "https://w3c.github.io/json-ld-api/tests/" => ::File.expand_path("../json-ld-api/tests", __FILE__) + '/',
+      "https://w3c.github.io/json-ld-framing/tests/" => ::File.expand_path("../json-ld-framing/tests", __FILE__) + '/',
+      "file:" => ""
+    }
 
     class << self
       alias_method :original_open_file, :open_file
@@ -20,32 +23,29 @@ module RDF::Util
     #   HTTP Request headers.
     # @return [IO] File stream
     # @yield [IO] File stream
-    def self.open_file(filename_or_url, options = {}, &block)
-      case 
-      when filename_or_url.to_s =~ /^file:/
-        path = filename_or_url[5..-1]
-        Kernel.open(path.to_s, options, &block)
-      when Dir.exist?(LOCAL_PATH) &&
-           !filename_or_url.to_s.include?('remote-doc') &&
-           filename_or_url.to_s =~ %r{^#{REMOTE_PATH}}
+    def self.open_file(filename_or_url, **options, &block)
+      LOCAL_PATHS.each do |r, l|
+        next unless Dir.exist?(l) && filename_or_url.start_with?(r)
         #puts "attempt to open #{filename_or_url} locally"
-        localpath = filename_or_url.to_s.sub(REMOTE_PATH, LOCAL_PATH)
+        localpath = filename_or_url.to_s.sub(r, l)
         response = begin
           ::File.open(localpath)
         rescue Errno::ENOENT => e
           raise IOError, e.message
         end
+
         document_options = {
           base_uri:     RDF::URI(filename_or_url),
           charset:      Encoding::UTF_8,
           code:         200,
-          headers:      {}
+          headers:      options.fetch(:headers, {})
         }
         #puts "use #{filename_or_url} locally"
         document_options[:headers][:content_type] = case filename_or_url.to_s
         when /\.ttl$/    then 'text/turtle'
         when /\.nt$/     then 'application/n-triples'
         when /\.jsonld$/ then 'application/ld+json'
+        when /\.json$/   then 'application/json'
         else                  'unknown'
         end
 
@@ -55,25 +55,26 @@ module RDF::Util
 
         remote_document = RDF::Util::File::RemoteDocument.new(response.read, document_options)
         if block_given?
-          yield remote_document
+          return yield remote_document
         else
-          remote_document
+          return remote_document
         end
-      else
-        original_open_file(filename_or_url, options, &block)
       end
+
+      original_open_file(filename_or_url, options, &block)
     end
   end
 end
 
 module Fixtures
   module SuiteTest
-    SUITE = RDF::URI("https://json-ld.org/test-suite/")
+    SUITE = RDF::URI("https://w3c.github.io/json-ld-api/tests/")
+    FRAME_SUITE = RDF::URI("https://w3c.github.io/json-ld-framing/tests/")
 
     class Manifest < JSON::LD::Resource
       def self.open(file)
-        Fixtures::SuiteTest.documentLoader(file) do |remote|
-          json = JSON.parse(remote.document)
+        RDF::Util::File.open_file(file) do |remote|
+          json = JSON.parse(remote.read)
           if block_given?
             yield self.from_jsonld(json)
           else
@@ -101,12 +102,13 @@ module Fixtures
 
       # Base is expanded input file
       def base
-        options.fetch('base', "#{SUITE}tests/#{property('input')}")
+        options.fetch('base', "#{SUITE}#{property('input')}")
       end
 
       def options
         @options ||= begin
           opts = {documentLoader: Fixtures::SuiteTest.method(:documentLoader)}
+          opts = {}
           {'specVersion' => "json-ld-1.1"}.merge(property('option') || {}).each do |k, v|
             opts[k.to_sym] = v
           end
@@ -119,13 +121,25 @@ 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|
-            res = remote_doc.document
+          file = self.send("#{m}_loc".to_sym)
+
+          dl_opts = {safe: true}
+          RDF::Util::File.open_file(file, dl_opts) do |remote_doc|
+            res = remote_doc.read
           end
           res
         end
 
-        define_method("#{m}_loc".to_sym) {property(m) && "#{SUITE}tests/#{property(m)}"}
+        define_method("#{m}_loc".to_sym) do
+          file = property(m)
+
+          # Handle redirection internally
+          if m == "input" && options[:redirectTo]
+            file = options[:redirectTo]
+          end
+
+          property(m) && "#{SUITE}#{file}"
+        end
 
         define_method("#{m}_json".to_sym) do
           JSON.parse(self.send(m)) if property(m)
@@ -149,16 +163,13 @@ module Fixtures
       def run(rspec_example = nil)
         logger = @logger = RDF::Spec.logger
         logger.info "test: #{inspect}"
-        logger.info "source: #{input}"
+        logger.info "purpose: #{purpose}"
+        logger.info "source: #{input rescue nil}"
         logger.info "context: #{context}" if context_loc
         logger.info "options: #{options.inspect}" unless options.empty?
         logger.info "frame: #{frame}" if frame_loc
 
-        options = if self.options[:useDocumentLoader]
-          self.options.merge(documentLoader: Fixtures::SuiteTest.method(:documentLoader))
-        else
-          self.options.dup
-        end
+        options = self.options.merge(documentLoader: Fixtures::SuiteTest.method(:documentLoader))
         options = {validate: true}.merge(options)
 
         unless options[:specVersion] == "json-ld-1.1"
@@ -171,25 +182,26 @@ module Fixtures
           begin
             result = case testType
             when "jld:ExpandTest"
-              JSON::LD::API.expand(input_loc, options.merge(logger: logger))
+              JSON::LD::API.expand(input_loc, logger: logger, **options)
             when "jld:CompactTest"
-              JSON::LD::API.compact(input_loc, context_json['@context'], options.merge(logger: logger))
+              JSON::LD::API.compact(input_loc, context_json['@context'], logger: logger, **options)
             when "jld:FlattenTest"
-              JSON::LD::API.flatten(input_loc, context_loc, options.merge(logger: logger))
+              JSON::LD::API.flatten(input_loc, (context_json['@context'] if context_loc), logger: logger, **options)
             when "jld:FrameTest"
-              JSON::LD::API.frame(input_loc, frame_loc, options.merge(logger: logger))
+              JSON::LD::API.frame(input_loc, frame_loc, logger: logger, **options)
             when "jld:FromRDFTest"
               # Use an array, to preserve input order
               repo = RDF::NQuads::Reader.open(input_loc) do |reader|
                 reader.each_statement.to_a
-              end.extend(RDF::Enumerable)
+              end.uniq.extend(RDF::Enumerable)
               logger.info "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
-              JSON::LD::API.fromRdf(repo, options.merge(logger: logger))
+              JSON::LD::API.fromRdf(repo, logger: logger, **options)
             when "jld:ToRDFTest"
               repo = RDF::Repository.new
-              JSON::LD::API.toRdf(input_loc, options.merge(logger: logger)) do |statement|
+              JSON::LD::API.toRdf(input_loc, logger: logger, **options) do |statement|
                 repo << statement
               end
+              logger.info "nq: #{repo.to_nquads}"
               repo
             else
               fail("Unknown test type: #{testType}")
@@ -222,19 +234,19 @@ module Fixtures
               expect do
                 case t.testType
                 when "jld:ExpandTest"
-                  JSON::LD::API.expand(t.input_loc, options.merge(logger: logger))
+                  JSON::LD::API.expand(t.input_loc, logger: logger, **options)
                 when "jld:CompactTest"
-                  JSON::LD::API.compact(t.input_loc, t.context_json['@context'], options.merge(logger: logger))
+                  JSON::LD::API.compact(t.input_loc, t.context_json['@context'], logger: logger, **options)
                 when "jld:FlattenTest"
-                  JSON::LD::API.flatten(t.input_loc, t.context_loc, options.merge(logger: logger))
+                  JSON::LD::API.flatten(t.input_loc, t.context_loc, logger: logger, **options)
                 when "jld:FrameTest"
-                  JSON::LD::API.frame(t.input_loc, t.frame_loc, options.merge(logger: logger))
+                  JSON::LD::API.frame(t.input_loc, t.frame_loc, logger: logger, **options)
                 when "jld:FromRDFTest"
                   repo = RDF::Repository.load(t.input_loc)
                   logger.info "repo: #{repo.dump(id == '#t0012' ? :nquads : :trig)}"
-                  JSON::LD::API.fromRdf(repo, options.merge(logger: logger))
+                  JSON::LD::API.fromRdf(repo, logger: logger, **options)
                 when "jld:ToRDFTest"
-                  JSON::LD::API.toRdf(t.input_loc, options.merge(logger: logger)) {}
+                  JSON::LD::API.toRdf(t.input_loc, logger: logger, **options) {}
                 else
                   success("Unknown test type: #{testType}")
                 end
@@ -286,8 +298,6 @@ module Fixtures
       end
     end
 
-    REMOTE_PATH = "https://json-ld.org/test-suite/"
-    LOCAL_PATH = ::File.expand_path("../json-ld.org/test-suite", __FILE__) + '/'
     ##
     # Document loader to use for tests having `useDocumentLoader` option
     #
@@ -299,25 +309,11 @@ module Fixtures
     # @yield remote_document
     # @yieldparam [RemoteDocument] remote_document
     # @raise [JsonLdError]
-    def documentLoader(url, options = {}, &block)
-      remote_document = nil
+    def documentLoader(url, **options, &block)
       options[:headers] ||= JSON::LD::API::OPEN_OPTS[:headers]
-
+      options[:headers][:link] = Array(options[:httpLink]).join(',') if options[:httpLink]
+    
       url = url.to_s[5..-1] if url.to_s.start_with?("file:")
-
-      if url.to_s.start_with?(REMOTE_PATH) && ::File.exist?(LOCAL_PATH) && url.to_s !~ /remote-doc/
-        #puts "attempt to open #{filename_or_url} locally"
-        local_filename = url.to_s.sub(REMOTE_PATH, LOCAL_PATH)
-        if ::File.exist?(local_filename)
-          remote_document = JSON::LD::API::RemoteDocument.new(url.to_s, ::File.read(local_filename))
-          return block_given? ? yield(remote_document) : remote_document
-        else
-          raise JSON::LD::JsonLdError::LoadingDocumentFailed, "no such file #{local_filename}"
-        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]