maremma 4.7.2 → 4.9.3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    maremma (4.7.2)
+    maremma (4.9.3)
       activesupport (>= 4.2.5)
       addressable (>= 2.3.6)
       builder (~> 3.2, >= 3.2.2)
@@ -9,70 +9,71 @@ PATH
       faraday (~> 0.17.3)
       faraday-encoding (~> 0.0.4)
       faraday_middleware (~> 0.14.0)
-      nokogiri (~> 1.10.4)
+      nokogiri (~> 1.11.2)
       oj (>= 2.8.3)
       oj_mimic_json (~> 1.0, >= 1.0.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3.2)
+    activesupport (6.1.3.2)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2, >= 2.2.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
     addressable (2.7.0)
       public_suffix (>= 2.0.2, < 5.0)
-    ast (2.4.1)
-    bigdecimal (2.0.0)
+    ast (2.4.2)
     builder (3.2.4)
-    concurrent-ruby (1.1.7)
-    crack (0.4.3)
-      safe_yaml (~> 1.0.0)
+    concurrent-ruby (1.1.9)
+    crack (0.4.5)
+      rexml
     diff-lcs (1.4.4)
-    docile (1.3.2)
+    docile (1.4.0)
     excon (0.71.1)
-    faraday (0.17.3)
+    faraday (0.17.4)
       multipart-post (>= 1.2, < 3)
     faraday-encoding (0.0.5)
       faraday
     faraday_middleware (0.14.0)
       faraday (>= 0.7.4, < 1.0)
     hashdiff (1.0.1)
-    i18n (1.8.5)
+    i18n (1.8.10)
       concurrent-ruby (~> 1.0)
     jaro_winkler (1.5.4)
-    mini_portile2 (2.4.0)
-    minitest (5.14.1)
+    mini_portile2 (2.5.3)
+    minitest (5.14.4)
     multipart-post (2.1.1)
-    nokogiri (1.10.10)
-      mini_portile2 (~> 2.4.0)
-    oj (3.10.12)
-      bigdecimal (>= 1.0, < 3)
+    nokogiri (1.11.7)
+      mini_portile2 (~> 2.5.0)
+      racc (~> 1.4)
+    oj (3.11.5)
     oj_mimic_json (1.0.1)
-    parallel (1.19.2)
-    parser (2.7.1.4)
+    parallel (1.20.1)
+    parser (3.0.1.1)
       ast (~> 2.4.1)
-    public_suffix (4.0.5)
+    public_suffix (4.0.6)
+    racc (1.5.2)
     rack (2.2.3)
     rack-test (0.8.3)
       rack (>= 1.0, < 3)
     rainbow (3.0.0)
-    rake (13.0.1)
-    rspec (3.9.0)
-      rspec-core (~> 3.9.0)
-      rspec-expectations (~> 3.9.0)
-      rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.2)
-      rspec-support (~> 3.9.3)
-    rspec-expectations (3.9.2)
+    rake (13.0.3)
+    rexml (3.2.5)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-mocks (3.9.1)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-support (3.9.3)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
     rubocop (0.77.0)
       jaro_winkler (~> 1.5.1)
       parallel (~> 1.10)
@@ -82,22 +83,22 @@ GEM
       unicode-display_width (>= 1.4.0, < 1.7)
     rubocop-performance (1.6.1)
       rubocop (>= 0.71.0)
-    ruby-progressbar (1.10.1)
-    safe_yaml (1.0.5)
-    simplecov (0.19.0)
+    ruby-progressbar (1.11.0)
+    simplecov (0.21.2)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
-    simplecov-html (0.12.2)
-    thread_safe (0.3.6)
-    tzinfo (1.2.7)
-      thread_safe (~> 0.1)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.3)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
     unicode-display_width (1.6.1)
     vcr (3.0.3)
-    webmock (3.8.3)
+    webmock (3.13.0)
       addressable (>= 2.3.6)
       crack (>= 0.3.2)
       hashdiff (>= 0.4.0, < 2.0.0)
-    zeitwerk (2.4.0)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby
@@ -115,4 +116,4 @@ DEPENDENCIES
   webmock (~> 3.0, >= 3.0.1)
 
 BUNDLED WITH
-   2.1.4
+   2.2.19

data/lib/maremma.rb

@@ -14,7 +14,7 @@ require "maremma/version"
 
 module Maremma
   DEFAULT_TIMEOUT = 60
-  ALLOWED_CONTENT_TAGS = %w(strong em b i code pre sub sup br)
+  ALLOWED_CONTENT_TAGS = %w(strong em b i code pre sub sup br).freeze
   NETWORKABLE_EXCEPTIONS = [Faraday::ClientError,
                             Faraday::TimeoutError,
                             Faraday::ResourceNotFound,
@@ -24,35 +24,35 @@ module Maremma
                             Encoding::UndefinedConversionError,
                             ArgumentError,
                             NoMethodError,
-                            TypeError]
+                            TypeError].freeze
 
   # ActiveSupport::XmlMini.backend = "Nokogiri"
 
-  def self.post(url, options={})
-    self.method(url, options.merge(method: "post"))
+  def self.post(url, options = {})
+    method(url, options.merge(method: "post"))
   end
 
-  def self.put(url, options={})
-    self.method(url, options.merge(method: "put"))
+  def self.put(url, options = {})
+    method(url, options.merge(method: "put"))
   end
 
-  def self.patch(url, options={})
-    self.method(url, options.merge(method: "patch"))
+  def self.patch(url, options = {})
+    method(url, options.merge(method: "patch"))
   end
 
-  def self.delete(url, options={})
-    self.method(url, options.merge(method: "delete"))
+  def self.delete(url, options = {})
+    method(url, options.merge(method: "delete"))
   end
 
-  def self.get(url, options={})
-    self.method(url, options.merge(method: "get"))
+  def self.get(url, options = {})
+    method(url, options.merge(method: "get"))
   end
 
-  def self.head(url, options={})
-    self.method(url, options.merge(method: "head"))
+  def self.head(url, options = {})
+    method(url, options.merge(method: "head"))
   end
 
-  def self.method(url, options={})
+  def self.method(url, options = {})
     is_valid_url?(url)
 
     # normalize url
@@ -66,23 +66,29 @@ module Maremma
     conn.options[:timeout] = options[:timeout] || DEFAULT_TIMEOUT
 
     response = case options[:method]
-               when "get" then conn.get url, {}, options[:headers] do |request|
-                 request.headers["Host"] = URI.parse(url.to_s).host
-               end
-               when "post" then conn.post url, {}, options[:headers] do |request|
-                 request.body = options[:data]
-                 request.headers["Host"] = URI.parse(url.to_s).host
-               end
-               when "put" then conn.put url, {}, options[:headers] do |request|
-                 request.body = options[:data]
-                 request.headers["Host"] = URI.parse(url.to_s).host
-               end
-               when "patch" then conn.patch url, {}, options[:headers] do |request|
-                 request.body = options[:data]
-                 request.headers["Host"] = URI.parse(url.to_s).host
-               end
-               when "delete" then conn.delete url, {}, options[:headers]
-               when "head" then conn.head url, {}, options[:headers]
+               when "get"
+                 conn.get url, {}, options[:headers] do |request|
+                   request.headers["Host"] = URI.parse(url.to_s).host
+                 end
+               when "post"
+                 conn.post url, {}, options[:headers] do |request|
+                   request.body = options[:data]
+                   request.headers["Host"] = URI.parse(url.to_s).host
+                 end
+               when "put"
+                 conn.put url, {}, options[:headers] do |request|
+                   request.body = options[:data]
+                   request.headers["Host"] = URI.parse(url.to_s).host
+                 end
+               when "patch"
+                 conn.patch url, {}, options[:headers] do |request|
+                   request.body = options[:data]
+                   request.headers["Host"] = URI.parse(url.to_s).host
+                 end
+               when "delete"
+                 conn.delete url, {}, options[:headers]
+               when "head"
+                 conn.head url, {}, options[:headers]
                end
 
     # return error if we are close to the rate limit, if supported in headers
@@ -102,8 +108,8 @@ module Maremma
                    headers: response.headers,
                    status: response.status,
                    url: response.env[:url].to_s)
-  rescue *NETWORKABLE_EXCEPTIONS => error
-    error_response = rescue_faraday_error(error, response)
+  rescue *NETWORKABLE_EXCEPTIONS => e
+    error_response = rescue_faraday_error(e, response)
     OpenStruct.new(body: error_response,
                    status: error_response.fetch("errors", {}).first.fetch("status", 400),
                    headers: response ? response.headers : nil,
@@ -137,7 +143,7 @@ module Maremma
     raise TypeError, "Invalid URL: #{url}" unless %w(http https).include?(parsed.scheme)
   end
 
-  def self.set_request_headers(url, options={})
+  def self.set_request_headers(_url, options = {})
     header_options = { "html" => "text/html;charset=UTF-8",
                        "xml" => "application/xml;charset=UTF-8",
                        "json" => "application/json;charset=UTF-8" }
@@ -148,7 +154,7 @@ module Maremma
     headers["User-Agent"] = ENV["USER_AGENT"] || "Mozilla/5.0 (compatible; Maremma/#{Maremma::VERSION}; +https://github.com/datacite/maremma)"
 
     # set host, needed for some services behind proxy
-    #headers["Host"] = URI.parse(url).host #if options[:host]
+    # headers["Host"] = URI.parse(url).host #if options[:host]
 
     # set Content-Type
     headers["Content-type"] = header_options.fetch(options[:content_type], options[:content_type]) if options[:content_type].present?
@@ -179,12 +185,12 @@ module Maremma
     if error.is_a?(Faraday::ResourceNotFound)
       { "errors" => [{ "status" => 404, "title" => "Not found" }] }
     elsif error.message == "the server responded with status 401" || error.try(:response) && error.response[:status] == 401
-      { "errors" => [{ "status" => 401, "title" =>"Unauthorized" }] }
+      { "errors" => [{ "status" => 401, "title" => "Unauthorized" }] }
     elsif error.is_a?(Faraday::ConnectionFailed)
       { "errors" => [{ "status" => 403, "title" => parse_error_response(error.message) }] }
 
     elsif error.is_a?(Faraday::TimeoutError) || (error.try(:response) && error.response[:status] == 408)
-      { "errors" => [{ "status" => 408, "title" =>"Request timeout" }] }
+      { "errors" => [{ "status" => 408, "title" => "Request timeout" }] }
     else
       status = response ? response.status : 400
       title = response ? parse_error_response(response.body) : parse_error_response(error.message)
@@ -192,7 +198,7 @@ module Maremma
     end
   end
 
-  def self.parse_success_response(string, options={})
+  def self.parse_success_response(string, options = {})
     return nil if options[:method] == "head"
 
     string = parse_response(string, options)
@@ -222,8 +228,10 @@ module Maremma
     end
   end
 
-  def self.parse_response(string, options={})
-    string = string.dup.force_encoding("UTF-8")
+  def self.parse_response(string, options = {})
+    string = string.dup.encode(Encoding.find("UTF-8"), invalid: :replace,
+                                                       undef: :replace,
+                                                       replace: "?")
     return string if options[:raw]
 
     from_json(string) || from_xml(string) || from_string(string)
@@ -239,15 +247,13 @@ module Maremma
   # keep XML attributes, http://stackoverflow.com/a/10794044
   # escape tags allowed in content
   def self.from_xml(string)
-    ALLOWED_CONTENT_TAGS.each do |tag| 
+    ALLOWED_CONTENT_TAGS.each do |tag|
       string.gsub!("<#{tag}>", "&lt;#{tag}&gt;")
       string.gsub!("</#{tag}>", "&lt;/#{tag}&gt;")
     end
 
     if Nokogiri::XML(string, nil, "UTF-8").errors.empty?
       Hash.from_xml(string)
-    else
-      nil
     end
   end
 

data/lib/maremma/version.rb

@@ -1,3 +1,3 @@
 module Maremma
-  VERSION = "4.7.2"
+  VERSION = "4.9.3".freeze
 end

data/maremma.gemspec

@@ -22,10 +22,10 @@ Gem::Specification.new do |s|
   s.add_dependency "addressable", ">= 2.3.6"
   s.add_dependency "builder", "~> 3.2", ">= 3.2.2"
   s.add_dependency "excon", "~> 0.71.0"
-  s.add_dependency 'faraday', "~> 0.17.3"
+  s.add_dependency "faraday", "~> 0.17.3"
   s.add_dependency "faraday-encoding", "~> 0.0.4"
   s.add_dependency "faraday_middleware", "~> 0.14.0"
-  s.add_dependency "nokogiri", "~> 1.10.4"
+  s.add_dependency "nokogiri", "~> 1.11.2"
   s.add_dependency "oj", ">= 2.8.3"
   s.add_dependency "oj_mimic_json", "~> 1.0", ">= 1.0.1"
   s.add_development_dependency "bundler", "~> 2.0"
@@ -37,5 +37,4 @@ Gem::Specification.new do |s|
   s.add_development_dependency "simplecov"
   s.add_development_dependency "vcr", "~> 3.0", ">= 3.0.3"
   s.add_development_dependency "webmock", "~> 3.0", ">= 3.0.1"
-
 end

data/spec/maremma_spec.rb

@@ -11,26 +11,26 @@ describe Maremma do
 
   context "get" do
     it "get json" do
-      stub = stub_request(:get, url).to_return(:body => data.to_json, :status => 200, :headers => { "Content-Type" => "application/json" })
+      stub = stub_request(:get, url).to_return(body: data.to_json, status: 200, headers: { "Content-Type" => "application/json" })
       response = subject.get(url)
       expect(response.body).to eq("data" => data)
-      expect(response.headers).to eq("Content-Type"=>"application/json")
+      expect(response.headers).to eq("Content-Type" => "application/json")
       expect(stub).to have_been_requested
     end
 
     it "get xml" do
-      stub = stub_request(:get, url).to_return(:body => data.to_xml, :status => 200, :headers => { "Content-Type" => "application/xml" })
+      stub = stub_request(:get, url).to_return(body: data.to_xml, status: 200, headers: { "Content-Type" => "application/xml" })
       response = subject.get(url, accept: "xml")
-      expect(response.body).to eq("data"=>data)
-      expect(response.headers).to eq("Content-Type"=>"application/xml")
+      expect(response.body).to eq("data" => data)
+      expect(response.headers).to eq("Content-Type" => "application/xml")
       expect(stub).to have_been_requested
     end
 
     it "get html" do
-      stub = stub_request(:get, url).to_return(:body => data.to_s, :status => 200, :headers => { "Content-Type" => "text/html" })
+      stub = stub_request(:get, url).to_return(body: data.to_s, status: 200, headers: { "Content-Type" => "text/html" })
       response = subject.get(url, accept: "html")
       expect(response.body).to eq("data" => data.to_s)
-      expect(response.headers).to eq("Content-Type"=>"text/html")
+      expect(response.headers).to eq("Content-Type" => "text/html")
       expect(stub).to have_been_requested
     end
 
@@ -53,28 +53,28 @@ describe Maremma do
     end
 
     it "get json with meta hash" do
-      data = { "data" => { "name" => "Jack" }, "meta" => { "count" => 12 }}
-      stub = stub_request(:get, url).to_return(:body => data.to_json, :status => 200, :headers => { "Content-Type" => "application/json" })
+      data = { "data" => { "name" => "Jack" }, "meta" => { "count" => 12 } }
+      stub = stub_request(:get, url).to_return(body: data.to_json, status: 200, headers: { "Content-Type" => "application/json" })
       response = subject.get(url)
-      expect(response.body).to eq("data"=>{"name"=>"Jack"}, "meta"=>{"count"=>12})
-      expect(response.headers).to eq("Content-Type"=>"application/json")
+      expect(response.body).to eq("data" => { "name" => "Jack" }, "meta" => { "count" => 12 })
+      expect(response.headers).to eq("Content-Type" => "application/json")
       expect(stub).to have_been_requested
     end
 
     it "get json with umlaut" do
       url = "https://api.ror.org/organizations?page=1&query=münster"
-      stub = stub_request(:get, url).to_return(:body => data.to_json, :status => 200, :headers => { "Content-Type" => "application/json" })
+      stub = stub_request(:get, url).to_return(body: data.to_json, status: 200, headers: { "Content-Type" => "application/json" })
       response = subject.get(url)
       expect(response.body).to eq("data" => data)
-      expect(response.headers).to eq("Content-Type"=>"application/json")
+      expect(response.headers).to eq("Content-Type" => "application/json")
       expect(stub).to have_been_requested
     end
 
     it "get xml raw" do
-      stub = stub_request(:get, url).to_return(:body => data.to_xml, :status => 200, :headers => { "Content-Type" => "application/xml" })
+      stub = stub_request(:get, url).to_return(body: data.to_xml, status: 200, headers: { "Content-Type" => "application/xml" })
       response = subject.get(url, accept: "xml", raw: true)
-      expect(response.body).to eq("data"=>data.to_xml)
-      expect(response.headers).to eq("Content-Type"=>"application/xml")
+      expect(response.body).to eq("data" => data.to_xml)
+      expect(response.headers).to eq("Content-Type" => "application/xml")
       expect(stub).to have_been_requested
     end
 
@@ -96,23 +96,23 @@ describe Maremma do
 
   context "head" do
     it "head html" do
-      stub = stub_request(:head, url).to_return(:status => 200, :headers => { "Content-Type" => "text/html" })
+      stub = stub_request(:head, url).to_return(status: 200, headers: { "Content-Type" => "text/html" })
       response = subject.head(url, accept: "html")
       expect(response.body).to be_nil
-      expect(response.headers).to eq("Content-Type"=>"text/html")
+      expect(response.headers).to eq("Content-Type" => "text/html")
       expect(stub).to have_been_requested
     end
   end
 
   context "post" do
     it "post json" do
-      stub = stub_request(:post, url).with(:body => post_data.to_json).to_return(:body => data.to_json, :status => 200, :headers => { "Content-Type" => "application/json" })
+      stub = stub_request(:post, url).with(body: post_data.to_json).to_return(body: data.to_json, status: 200, headers: { "Content-Type" => "application/json" })
       subject.post(url, content_type: "json", data: post_data.to_json) { |response| expect(response.body).to eq(2) }
       expect(stub).to have_been_requested
     end
 
     it "post xml" do
-      stub = stub_request(:post, url).with(:body => post_data.to_xml).to_return(:body => data.to_xml, :status => 200, :headers => { "Content-Type" => "text/html" })
+      stub = stub_request(:post, url).with(body: post_data.to_xml).to_return(body: data.to_xml, status: 200, headers: { "Content-Type" => "text/html" })
       subject.post(url, content_type: "xml", data: post_data.to_xml) { |response| expect(Hash.from_xml(response.body.to_s)["hash"]).to eq(data) }
       expect(stub).to have_been_requested
     end
@@ -120,13 +120,13 @@ describe Maremma do
 
   context "put" do
     it "put json" do
-      stub = stub_request(:put, url).with(:body => post_data.to_json).to_return(:body => data.to_json, :status => 200, :headers => { "Content-Type" => "application/json" })
+      stub = stub_request(:put, url).with(body: post_data.to_json).to_return(body: data.to_json, status: 200, headers: { "Content-Type" => "application/json" })
       subject.put(url, content_type: "json", data: post_data.to_json) { |response| expect(JSON.parse(response.body.to_s)).to eq(data) }
       expect(stub).to have_been_requested
     end
 
     it "put xml" do
-      stub = stub_request(:put, url).with(:body => post_data.to_xml).to_return(:body => data.to_xml, :status => 200, :headers => { "Content-Type" => "text/html" })
+      stub = stub_request(:put, url).with(body: post_data.to_xml).to_return(body: data.to_xml, status: 200, headers: { "Content-Type" => "text/html" })
       subject.put(url, content_type: "xml", data: post_data.to_xml) { |response| expect(Hash.from_xml(response.body.to_s)["hash"]).to eq(data) }
       expect(stub).to have_been_requested
     end
@@ -134,13 +134,13 @@ describe Maremma do
 
   context "patch" do
     it "patch json" do
-      stub = stub_request(:patch, url).with(:body => post_data.to_json).to_return(:body => data.to_json, :status => 200, :headers => { "Content-Type" => "application/json" })
+      stub = stub_request(:patch, url).with(body: post_data.to_json).to_return(body: data.to_json, status: 200, headers: { "Content-Type" => "application/json" })
       subject.patch(url, content_type: "json", data: post_data.to_json) { |response| expect(JSON.parse(response.body.to_s)).to eq(data) }
       expect(stub).to have_been_requested
     end
 
     it "patch xml" do
-      stub = stub_request(:patch, url).with(:body => post_data.to_xml).to_return(:body => data.to_xml, :status => 200, :headers => { "Content-Type" => "text/html" })
+      stub = stub_request(:patch, url).with(body: post_data.to_xml).to_return(body: data.to_xml, status: 200, headers: { "Content-Type" => "text/html" })
       subject.patch(url, content_type: "xml", data: post_data.to_xml) { |response| expect(Hash.from_xml(response.body.to_s)["hash"]).to eq(data) }
       expect(stub).to have_been_requested
     end
@@ -148,125 +148,125 @@ describe Maremma do
 
   context "empty response" do
     it "get json" do
-      stub = stub_request(:get, url).to_return(:body => nil, :status => 200, :headers => { "Content-Type" => "application/json" })
+      stub = stub_request(:get, url).to_return(body: nil, status: 200, headers: { "Content-Type" => "application/json" })
       response = subject.get(url)
-      expect(response.body).to eq("data"=>nil)
-      expect(response.headers).to eq("Content-Type"=>"application/json")
+      expect(response.body).to eq("data" => nil)
+      expect(response.headers).to eq("Content-Type" => "application/json")
       expect(stub).to have_been_requested
     end
 
     it "get xml" do
-      stub = stub_request(:get, url).to_return(:body => nil, :status => 200, :headers => { "Content-Type" => "application/xml" })
+      stub = stub_request(:get, url).to_return(body: nil, status: 200, headers: { "Content-Type" => "application/xml" })
       response = subject.get(url, accept: "xml")
-      expect(response.body).to eq("data"=>nil)
-      expect(response.headers).to eq("Content-Type"=>"application/xml")
+      expect(response.body).to eq("data" => nil)
+      expect(response.headers).to eq("Content-Type" => "application/xml")
       expect(stub).to have_been_requested
     end
 
     it "get html" do
-      stub = stub_request(:get, url).to_return(:body => nil, :status => 200, :headers => { "Content-Type" => "text/html" })
+      stub = stub_request(:get, url).to_return(body: nil, status: 200, headers: { "Content-Type" => "text/html" })
       response = subject.get(url, accept: "html")
       expect(response.body).to eq("data" => nil)
-      expect(response.headers).to eq("Content-Type"=>"text/html")
+      expect(response.headers).to eq("Content-Type" => "text/html")
       expect(stub).to have_been_requested
     end
 
     it "post xml" do
-      stub = stub_request(:post, url).with(:body => post_data.to_xml).to_return(:body => nil, :status => 200, :headers => { "Content-Type" => "application/xml" })
+      stub = stub_request(:post, url).with(body: post_data.to_xml).to_return(body: nil, status: 200, headers: { "Content-Type" => "application/xml" })
       subject.post(url, accept: "xml", data: post_data.to_xml) { |response| expect(response.body).to eq("data" => nil) }
       expect(stub).to have_been_requested
     end
 
     it "put xml" do
-      stub = stub_request(:put, url).with(:body => post_data.to_xml).to_return(:body => nil, :status => 200, :headers => { "Content-Type" => "application/xml" })
+      stub = stub_request(:put, url).with(body: post_data.to_xml).to_return(body: nil, status: 200, headers: { "Content-Type" => "application/xml" })
       subject.put(url, accept: "xml", data: post_data.to_xml) { |response| expect(response.body).to eq("data" => nil) }
       expect(stub).to have_been_requested
     end
   end
 
   context "not found" do
-    let(:error) { { "errors" => [{ "status" => 404, "title" => "Not found" }]} }
+    let(:error) { { "errors" => [{ "status" => 404, "title" => "Not found" }] } }
 
     it "get json" do
-      stub = stub_request(:get, url).to_return(:body => error.to_json, :status => [404], :headers => { "Content-Type" => "application/json" })
+      stub = stub_request(:get, url).to_return(body: error.to_json, status: [404], headers: { "Content-Type" => "application/json" })
       response = subject.get(url, accept: "json")
       expect(response.body).to eq(error)
       expect(stub).to have_been_requested
     end
 
     it "get xml" do
-      stub = stub_request(:get, url).to_return(:body => error.to_xml, :status => [404], :headers => { "Content-Type" => "application/xml" })
+      stub = stub_request(:get, url).to_return(body: error.to_xml, status: [404], headers: { "Content-Type" => "application/xml" })
       response = subject.get(url, accept: "xml")
       expect(response.body).to eq(error)
       expect(stub).to have_been_requested
     end
 
     it "get html" do
-      stub = stub_request(:get, url).to_return(:body => error.to_s, :status => [404], :headers => { "Content-Type" => "text/html" })
+      stub = stub_request(:get, url).to_return(body: error.to_s, status: [404], headers: { "Content-Type" => "text/html" })
       response = subject.get(url, accept: "html")
       expect(response.body).to eq(error)
       expect(stub).to have_been_requested
     end
 
     it "head html" do
-      stub = stub_request(:head, url).to_return(:body => error.to_s, :status => [404], :headers => { "Content-Type" => "text/html" })
+      stub = stub_request(:head, url).to_return(body: error.to_s, status: [404], headers: { "Content-Type" => "text/html" })
       response = subject.head(url, accept: "html")
       expect(response.status).to eq(404)
       expect(stub).to have_been_requested
     end
 
     it "post xml" do
-      stub = stub_request(:post, url).with(:body => post_data.to_xml).to_return(:body => error.to_xml, :status => [404], :headers => { "Content-Type" => "application/xml" })
+      stub = stub_request(:post, url).with(body: post_data.to_xml).to_return(body: error.to_xml, status: [404], headers: { "Content-Type" => "application/xml" })
       subject.post(url, accept: "xml", data: post_data.to_xml) { |response| expect(Hash.from_xml(response.to_s)["hash"]).to eq(error) }
       expect(stub).to have_been_requested
     end
 
     it "put xml" do
-      stub = stub_request(:put, url).with(:body => post_data.to_xml).to_return(:body => error.to_xml, :status => [404], :headers => { "Content-Type" => "application/xml" })
+      stub = stub_request(:put, url).with(body: post_data.to_xml).to_return(body: error.to_xml, status: [404], headers: { "Content-Type" => "application/xml" })
       subject.put(url, accept: "xml", data: post_data.to_xml) { |response| expect(Hash.from_xml(response.to_s)["hash"]).to eq(error) }
       expect(stub).to have_been_requested
     end
   end
 
   context "method not allowed" do
-    let(:error) { { "errors" => [{ "status" => 405, "title" => "Method not allowed" }]} }
+    let(:error) { { "errors" => [{ "status" => 405, "title" => "Method not allowed" }] } }
 
     it "get json" do
-      stub = stub_request(:get, url).to_return(:body => error.to_json, :status => [405], :headers => { "Content-Type" => "application/json" })
+      stub = stub_request(:get, url).to_return(body: error.to_json, status: [405], headers: { "Content-Type" => "application/json" })
       response = subject.get(url, accept: "json")
       expect(response.body).to eq(error)
       expect(stub).to have_been_requested
     end
 
     it "get xml" do
-      stub = stub_request(:get, url).to_return(:body => error.to_xml, :status => [405], :headers => { "Content-Type" => "application/xml" })
+      stub = stub_request(:get, url).to_return(body: error.to_xml, status: [405], headers: { "Content-Type" => "application/xml" })
       response = subject.get(url, accept: "xml")
       expect(response.body).to eq(error)
       expect(stub).to have_been_requested
     end
 
     it "get html" do
-      stub = stub_request(:get, url).to_return(:body => error.dig("errors", 0, "title"), :status => [405], :headers => { "Content-Type" => "text/html" })
+      stub = stub_request(:get, url).to_return(body: error.dig("errors", 0, "title"), status: [405], headers: { "Content-Type" => "text/html" })
       response = subject.get(url, accept: "html")
       expect(response.body).to eq(error)
       expect(stub).to have_been_requested
     end
 
     it "head html" do
-      stub = stub_request(:head, url).to_return(:body => error.to_s, :status => [405], :headers => { "Content-Type" => "text/html" })
+      stub = stub_request(:head, url).to_return(body: error.to_s, status: [405], headers: { "Content-Type" => "text/html" })
       response = subject.head(url, accept: "html")
       expect(response.status).to eq(405)
       expect(stub).to have_been_requested
     end
 
     it "post xml" do
-      stub = stub_request(:post, url).with(:body => post_data.to_xml).to_return(:body => error.to_xml, :status => [405], :headers => { "Content-Type" => "application/xml" })
+      stub = stub_request(:post, url).with(body: post_data.to_xml).to_return(body: error.to_xml, status: [405], headers: { "Content-Type" => "application/xml" })
       subject.post(url, accept: "xml", data: post_data.to_xml) { |response| expect(Hash.from_xml(response.to_s)["hash"]).to eq(error) }
       expect(stub).to have_been_requested
     end
 
     it "put xml" do
-      stub = stub_request(:put, url).with(:body => post_data.to_xml).to_return(:body => error.to_xml, :status => [405], :headers => { "Content-Type" => "application/xml" })
+      stub = stub_request(:put, url).with(body: post_data.to_xml).to_return(body: error.to_xml, status: [405], headers: { "Content-Type" => "application/xml" })
       subject.put(url, accept: "xml", data: post_data.to_xml) { |response| expect(Hash.from_xml(response.to_s)["hash"]).to eq(error) }
       expect(stub).to have_been_requested
     end
@@ -274,41 +274,41 @@ describe Maremma do
 
   context "request timeout" do
     it "get json" do
-      stub = stub_request(:get, url).to_return(:status => [408])
+      stub = stub_request(:get, url).to_return(status: [408])
       response = subject.get(url)
-      expect(response.body).to eq("errors"=>[{"status"=>408, "title"=>"Request timeout"}])
+      expect(response.body).to eq("errors" => [{ "status" => 408, "title" => "Request timeout" }])
       expect(stub).to have_been_requested
     end
 
     it "get xml" do
-      stub = stub_request(:get, url).to_return(:status => [408])
+      stub = stub_request(:get, url).to_return(status: [408])
       response = subject.get(url, accept: "xml")
-      expect(response.body).to eq("errors"=>[{"status"=>408, "title"=>"Request timeout"}])
+      expect(response.body).to eq("errors" => [{ "status" => 408, "title" => "Request timeout" }])
       expect(stub).to have_been_requested
     end
 
     it "get html" do
-      stub = stub_request(:get, url).to_return(:status => [408])
+      stub = stub_request(:get, url).to_return(status: [408])
       response = subject.get(url, accept: "html")
-      expect(response.body).to eq("errors"=>[{"status"=>408, "title"=>"Request timeout"}])
+      expect(response.body).to eq("errors" => [{ "status" => 408, "title" => "Request timeout" }])
       expect(stub).to have_been_requested
     end
 
     it "head html" do
-      stub = stub_request(:head, url).to_return(:status => [408])
+      stub = stub_request(:head, url).to_return(status: [408])
       response = subject.head(url, accept: "html")
       expect(response.status).to eq(408)
       expect(stub).to have_been_requested
     end
 
     it "post xml" do
-      stub = stub_request(:post, url).with(:body => post_data.to_xml).to_return(:status => [408])
+      stub = stub_request(:post, url).with(body: post_data.to_xml).to_return(status: [408])
       subject.post(url, accept: "xml", data: post_data.to_xml) { |response| expect(response.body).to be_nil }
       expect(stub).to have_been_requested
     end
 
     it "put xml" do
-      stub = stub_request(:put, url).with(:body => post_data.to_xml).to_return(:status => [408])
+      stub = stub_request(:put, url).with(body: post_data.to_xml).to_return(status: [408])
       subject.put(url, accept: "xml", data: post_data.to_xml) { |response| expect(response.body).to be_nil }
       expect(stub).to have_been_requested
     end
@@ -316,10 +316,10 @@ describe Maremma do
 
   context "delete" do
     it "delete" do
-      stub = stub_request(:delete, url).to_return(:status => 204, :headers => { "Content-Type" => "text/html" })
+      stub = stub_request(:delete, url).to_return(status: 204, headers: { "Content-Type" => "text/html" })
       response = subject.delete(url)
-      expect(response.body).to eq("data"=>nil)
-      expect(response.headers).to eq("Content-Type"=>"text/html")
+      expect(response.body).to eq("data" => nil)
+      expect(response.headers).to eq("Content-Type" => "text/html")
       expect(response.status).to eq(204)
       expect(stub).to have_been_requested
     end
@@ -329,32 +329,32 @@ describe Maremma do
     it "get json" do
       stub = stub_request(:get, url).to_raise(Faraday::ConnectionFailed.new("Connection refused - connect(2)"))
       response = subject.get(url)
-      expect(response.body).to eq("errors"=>[{"status"=>403, "title"=>"Connection refused - connect(2)"}])
+      expect(response.body).to eq("errors" => [{ "status" => 403, "title" => "Connection refused - connect(2)" }])
       expect(stub).to have_been_requested
     end
 
     it "get xml" do
       stub = stub_request(:get, url).to_raise(Faraday::ConnectionFailed.new("Connection refused - connect(2)"))
       response = subject.get(url, accept: "xml")
-      expect(response.body).to eq("errors"=>[{"status"=>403, "title"=>"Connection refused - connect(2)"}])
+      expect(response.body).to eq("errors" => [{ "status" => 403, "title" => "Connection refused - connect(2)" }])
       expect(stub).to have_been_requested
     end
 
     it "get html" do
       stub = stub_request(:get, url).to_raise(Faraday::ConnectionFailed.new("Connection refused - connect(2)"))
       response = subject.get(url, accept: "html")
-      expect(response.body).to eq("errors"=>[{"status"=>403, "title"=>"Connection refused - connect(2)"}])
+      expect(response.body).to eq("errors" => [{ "status" => 403, "title" => "Connection refused - connect(2)" }])
       expect(stub).to have_been_requested
     end
 
     it "post xml" do
-      stub = stub_request(:post, url).with(:body => post_data.to_xml).to_raise(Faraday::ConnectionFailed.new("Connection refused - connect(2)"))
+      stub = stub_request(:post, url).with(body: post_data.to_xml).to_raise(Faraday::ConnectionFailed.new("Connection refused - connect(2)"))
       subject.post(url, accept: "xml", data: post_data.to_xml) { |response| expect(response.body).to be_nil }
       expect(stub).to have_been_requested
     end
 
     it "put xml" do
-      stub = stub_request(:put, url).with(:body => post_data.to_xml).to_raise(Faraday::ConnectionFailed.new("Connection refused - connect(2)"))
+      stub = stub_request(:put, url).with(body: post_data.to_xml).to_raise(Faraday::ConnectionFailed.new("Connection refused - connect(2)"))
       subject.put(url, accept: "xml", data: post_data.to_xml) { |response| expect(response.body).to be_nil }
       expect(stub).to have_been_requested
     end
@@ -364,38 +364,38 @@ describe Maremma do
     it "get json" do
       stub = stub_request(:get, url).to_raise(Faraday::ClientError.new("the server responded with status 401"))
       response = subject.get(url)
-      expect(response.body).to eq("errors"=>[{"status"=>401, "title"=>"Unauthorized"}])
+      expect(response.body).to eq("errors" => [{ "status" => 401, "title" => "Unauthorized" }])
       expect(stub).to have_been_requested
     end
 
     it "get xml" do
       stub = stub_request(:get, url).to_raise(Faraday::ClientError.new("the server responded with status 401"))
       response = subject.get(url, accept: "xml")
-      expect(response.body).to eq("errors"=>[{"status"=>401, "title"=>"Unauthorized"}])
+      expect(response.body).to eq("errors" => [{ "status" => 401, "title" => "Unauthorized" }])
       expect(stub).to have_been_requested
     end
 
     it "get html" do
       stub = stub_request(:get, url).to_raise(Faraday::ClientError.new("the server responded with status 401"))
       response = subject.get(url, accept: "html")
-      expect(response.body).to eq("errors"=>[{"status"=>401, "title"=>"Unauthorized"}])
+      expect(response.body).to eq("errors" => [{ "status" => 401, "title" => "Unauthorized" }])
       expect(stub).to have_been_requested
     end
 
     it "post xml" do
-      stub = stub_request(:post, url).with(:body => post_data.to_xml).to_raise(Faraday::ClientError.new("the server responded with status 401"))
+      stub = stub_request(:post, url).with(body: post_data.to_xml).to_raise(Faraday::ClientError.new("the server responded with status 401"))
       subject.post(url, accept: "xml", data: post_data.to_xml) do |response|
         expect(response.body).to be_nil
-        expect(response.status).to eq("errors"=>[{"status"=>401, "title"=>"Unauthorized"}])
+        expect(response.status).to eq("errors" => [{ "status" => 401, "title" => "Unauthorized" }])
       end
       expect(stub).to have_been_requested
     end
 
     it "put xml" do
-      stub = stub_request(:put, url).with(:body => post_data.to_xml).to_raise(Faraday::ClientError.new("the server responded with status 401"))
+      stub = stub_request(:put, url).with(body: post_data.to_xml).to_raise(Faraday::ClientError.new("the server responded with status 401"))
       subject.put(url, accept: "xml", data: post_data.to_xml) do |response|
         expect(response.body).to be_nil
-        expect(response.status).to eq("errors"=>[{"status"=>401, "title"=>"Unauthorized"}])
+        expect(response.status).to eq("errors" => [{ "status" => 401, "title" => "Unauthorized" }])
       end
       expect(stub).to have_been_requested
     end
@@ -405,32 +405,32 @@ describe Maremma do
     it "get json" do
       stub = stub_request(:get, url).to_timeout
       response = subject.get(url)
-      expect(response.body).to eq("errors"=>[{"status"=>408, "title"=>"Request timeout"}])
+      expect(response.body).to eq("errors" => [{ "status" => 408, "title" => "Request timeout" }])
       expect(stub).to have_been_requested
     end
 
     it "get xml" do
       stub = stub_request(:get, url).to_timeout
       response = subject.get(url, accept: "xml")
-      expect(response.body).to eq("errors"=>[{"status"=>408, "title"=>"Request timeout"}])
+      expect(response.body).to eq("errors" => [{ "status" => 408, "title" => "Request timeout" }])
       expect(stub).to have_been_requested
     end
 
     it "get html" do
       stub = stub_request(:get, url).to_timeout
       response = subject.get(url, accept: "html")
-      expect(response.body).to eq("errors"=>[{"status"=>408, "title"=>"Request timeout"}])
+      expect(response.body).to eq("errors" => [{ "status" => 408, "title" => "Request timeout" }])
       expect(stub).to have_been_requested
     end
 
     it "post xml" do
-      stub = stub_request(:post, url).with(:body => post_data.to_xml).to_timeout
+      stub = stub_request(:post, url).with(body: post_data.to_xml).to_timeout
       subject.post(url, accept: "xml", data: post_data.to_xml) { |response| expect(response.body).to be_nil }
       expect(stub).to have_been_requested
     end
 
     it "put xml" do
-      stub = stub_request(:put, url).with(:body => post_data.to_xml).to_timeout
+      stub = stub_request(:put, url).with(body: post_data.to_xml).to_timeout
       subject.put(url, accept: "xml", data: post_data.to_xml) { |response| expect(response.body).to be_nil }
       expect(stub).to have_been_requested
     end
@@ -440,34 +440,34 @@ describe Maremma do
     it "get json" do
       stub = stub_request(:get, url).to_return(status: 200, headers: { "X-Rate-Limit-Remaining" => 2 })
       response = subject.get(url)
-      expect(response.body).to eq("errors"=>[{"status"=>429, "title"=>"Too many requests"}])
+      expect(response.body).to eq("errors" => [{ "status" => 429, "title" => "Too many requests" }])
       expect(stub).to have_been_requested
     end
 
     it "get xml" do
       stub = stub_request(:get, url).to_return(status: 200, headers: { "X-Rate-Limit-Remaining" => 2 })
       response = subject.get(url, accept: "xml")
-      expect(response.body).to eq("errors"=>[{"status"=>429, "title"=>"Too many requests"}])
+      expect(response.body).to eq("errors" => [{ "status" => 429, "title" => "Too many requests" }])
       expect(stub).to have_been_requested
     end
 
     it "get html" do
       stub = stub_request(:get, url).to_return(status: 200, headers: { "X-Rate-Limit-Remaining" => 2 })
       response = subject.get(url, accept: "html")
-      expect(response.body).to eq("errors"=>[{"status"=>429, "title"=>"Too many requests"}])
+      expect(response.body).to eq("errors" => [{ "status" => 429, "title" => "Too many requests" }])
       expect(stub).to have_been_requested
     end
 
     it "post xml" do
-      stub = stub_request(:post, url).with(:body => post_data.to_xml)
-        .to_return(status: 200, headers: { "X-Rate-Limit-Remaining" => 3 })
+      stub = stub_request(:post, url).with(body: post_data.to_xml).
+        to_return(status: 200, headers: { "X-Rate-Limit-Remaining" => 3 })
       subject.post(url, accept: "xml", data: post_data.to_xml) { |response| expect(response.body).to be_nil }
       expect(stub).to have_been_requested
     end
 
     it "put xml" do
-      stub = stub_request(:put, url).with(:body => post_data.to_xml)
-        .to_return(status: 200, headers: { "X-Rate-Limit-Remaining" => 3 })
+      stub = stub_request(:put, url).with(body: post_data.to_xml).
+        to_return(status: 200, headers: { "X-Rate-Limit-Remaining" => 3 })
       subject.put(url, accept: "xml", data: post_data.to_xml) { |response| expect(response.body).to be_nil }
       expect(stub).to have_been_requested
     end
@@ -480,26 +480,26 @@ describe Maremma do
       stub_request(:get, url).to_return(status: 301, headers: { location: redirect_url })
       stub_request(:get, redirect_url).to_return(status: 200, body: "Test")
       response = subject.get(url)
-      expect(response.body).to eq("data"=>"Test")
+      expect(response.body).to eq("data" => "Test")
       expect(response.url).to eq("http://www.example.org/redirect")
     end
 
     it "redirect four times" do
       stub_request(:get, url).to_return(status: 301, headers: { location: redirect_url })
       stub_request(:get, redirect_url).to_return(status: 301, headers: { location: redirect_url + "/x" })
-      stub_request(:get, redirect_url+ "/x").to_return(status: 301, headers: { location: redirect_url + "/y" })
-      stub_request(:get, redirect_url+ "/y").to_return(status: 301, headers: { location: redirect_url + "/z" })
+      stub_request(:get, redirect_url + "/x").to_return(status: 301, headers: { location: redirect_url + "/y" })
+      stub_request(:get, redirect_url + "/y").to_return(status: 301, headers: { location: redirect_url + "/z" })
       stub_request(:get, redirect_url + "/z").to_return(status: 200, body: "Test")
       response = subject.get(url)
-      expect(response.body).to eq("data"=>"Test")
+      expect(response.body).to eq("data" => "Test")
     end
 
     it "redirect limit 1" do
       stub_request(:get, url).to_return(status: 301, headers: { location: redirect_url })
       stub_request(:get, redirect_url).to_return(status: 301, headers: { location: redirect_url + "/x" })
-      stub_request(:get, redirect_url+ "/x").to_return(status: 301, headers: { location: redirect_url + "/y" })
+      stub_request(:get, redirect_url + "/x").to_return(status: 301, headers: { location: redirect_url + "/y" })
       response = subject.get(url, limit: 1)
-      expect(response.body).to eq("errors"=>[{"status"=>400, "title"=>"too many redirects; last one to: http://www.example.org/redirect/x"}])
+      expect(response.body).to eq("errors" => [{ "status" => 400, "title" => "too many redirects; last one to: http://www.example.org/redirect/x" }])
     end
 
     it "redirect limit 0" do
@@ -562,7 +562,7 @@ describe Maremma do
 
     it "json not error" do
       string = "{ \"customError\": \"An error occured.\" }"
-      expect(subject.parse_error_response(string)).to eq("customError"=>"An error occured.")
+      expect(subject.parse_error_response(string)).to eq("customError" => "An error occured.")
     end
 
     it "xml" do
@@ -574,27 +574,27 @@ describe Maremma do
   context "parse_success_response" do
     it "from_json" do
       string = "{ \"word\": \"abc\" }"
-      expect(subject.parse_success_response(string)).to eq({ "data" => { "word"=>"abc" }})
+      expect(subject.parse_success_response(string)).to eq("data" => { "word" => "abc" })
     end
 
     it "from_json with data" do
       string = "{ \"data\": { \"word\": \"abc\" }}"
-      expect(subject.parse_success_response(string)).to eq({"data"=>{"word"=>"abc"}})
+      expect(subject.parse_success_response(string)).to eq("data" => { "word" => "abc" })
     end
 
     it "from_json with data and meta" do
       string = "{ \"data\": { \"word\": \"abc\" }, \"meta\": { \"total\": 12 }}"
-      expect(subject.parse_success_response(string)).to eq({"data"=>{"word"=>"abc"},"meta"=>{"total"=>12}})
+      expect(subject.parse_success_response(string)).to eq("data" => { "word" => "abc" }, "meta" => { "total" => 12 })
     end
 
     it "from_xml" do
       string = "<word>abc</word>"
-      expect(subject.parse_success_response(string)).to eq("data"=>{"word"=>"abc"})
+      expect(subject.parse_success_response(string)).to eq("data" => { "word" => "abc" })
     end
 
     it "from_xml with attribute" do
       string = "<word type='small'>abc</word>"
-      expect(subject.parse_success_response(string)).to eq("data"=>{"word"=>{"type"=>"small", "__content__"=>"abc"}})
+      expect(subject.parse_success_response(string)).to eq("data" => { "word" => { "type" => "small", "__content__" => "abc" } })
     end
 
     # it "from_xml with allowed content attributes" do
@@ -604,22 +604,22 @@ describe Maremma do
 
     it "from_xml with attribute type string" do
       string = "<crm-item name='publisher-name' type='string'>eLife Sciences Publications, Ltd</crm-item>"
-      expect(subject.parse_success_response(string)).to eq("data"=>{"crm_item"=>"eLife Sciences Publications, Ltd"})
+      expect(subject.parse_success_response(string)).to eq("data" => { "crm_item" => "eLife Sciences Publications, Ltd" })
     end
 
     it "from_xml with mixed attribute" do
       string = "<word type='small'>abc<footnote>1</footnote></word>"
-      expect(subject.parse_success_response(string)).to eq("data"=>{"word"=>{"type"=>"small", "footnote"=>"1", "__content__"=>"abc"}})
+      expect(subject.parse_success_response(string)).to eq("data" => { "word" => { "type" => "small", "footnote" => "1", "__content__" => "abc" } })
     end
 
     it "from_string" do
       string = "abc"
-      expect(subject.parse_success_response(string)).to eq("data"=>"abc")
+      expect(subject.parse_success_response(string)).to eq("data" => "abc")
     end
 
     it "from_string with utf-8" do
       string = "fön  "
-      expect(subject.parse_success_response(string)).to eq("data"=>"fön")
+      expect(subject.parse_success_response(string)).to eq("data" => "fön")
     end
   end
 
@@ -673,7 +673,7 @@ describe Maremma do
 
     it "github_token" do
       options = { github_token: "12345" }
-      expect(subject.set_request_headers(url, options)).to eq("User-Agent"=>"Mozilla/5.0 (compatible; Maremma/#{Maremma::VERSION}; +https://github.com/datacite/maremma)", "Accept"=>accept_header, "Authorization"=>"Token 12345")
+      expect(subject.set_request_headers(url, options)).to eq("User-Agent" => "Mozilla/5.0 (compatible; Maremma/#{Maremma::VERSION}; +https://github.com/datacite/maremma)", "Accept" => accept_header, "Authorization" => "Token 12345")
     end
 
     it "basic" do
@@ -697,7 +697,7 @@ describe Maremma do
       expect(response.status).to eq(200)
       doc = Nokogiri::XML(response.body.fetch("data", nil), nil, "UTF-8")
       nodeset = doc.css("script")
-      string = nodeset.find { |element| element["type"] == "application/ld+json" }
+      string = nodeset.detect { |element| element["type"] == "application/ld+json" }
       json = JSON.parse(string)
       expect(json["@id"]).to eq("https://doi.org/10.3334/ORNLDAAC/1339")
     end
@@ -708,10 +708,10 @@ describe Maremma do
       expect(response.status).to eq(200)
       doc = Nokogiri::XML(response.body.fetch("data", nil), nil, "UTF-8")
       nodeset = doc.css("script")
-      string = nodeset.find { |element| element["type"] == "application/ld+json" }
+      string = nodeset.detect { |element| element["type"] == "application/ld+json" }
       json = JSON.parse(string)
       expect(json["@id"]).to eq("https://doi.org/10.3334/ORNLDAAC/1339")
-    end  
+    end
   end
 
   context "ssl verify", vcr: true do
@@ -723,7 +723,7 @@ describe Maremma do
 
     it "self-signed" do
       url = "https://38.100.138.135:8000/api/handles/10.5281/ZENODO.21430?index=1"
-      options = { ssl_self_signed: true}
+      options = { ssl_self_signed: true }
       response = subject.get(url, options)
       expect(response.status).to eq(200)
       expect(response.body.dig("data", "values", 0, "data", "value")).to eq("https://zenodo.org/record/21430")