maremma 4.4 → 4.5

data/Gemfile.lock

@@ -1,29 +1,30 @@
 PATH
   remote: .
   specs:
-    maremma (4.4)
+    maremma (4.5)
       activesupport (>= 4.2.5, < 6)
       addressable (>= 2.3.6)
       builder (~> 3.2, >= 3.2.2)
-      excon (~> 0.67.0)
-      faraday (~> 0.17.0)
+      excon (~> 0.71.0)
+      faraday (= 0.17.0)
       faraday-encoding (~> 0.0.4)
       faraday_middleware (~> 0.13.1)
-      multi_json (~> 1.12)
       nokogiri (~> 1.10.4)
       oj (>= 2.8.3)
+      oj_mimic_json (~> 1.0, >= 1.0.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (5.2.3)
+    activesupport (5.2.4.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
     addressable (2.7.0)
       public_suffix (>= 2.0.2, < 5.0)
-    builder (3.2.3)
+    ast (2.4.0)
+    builder (3.2.4)
     codeclimate-test-reporter (1.0.9)
       simplecov (<= 0.13)
     concurrent-ruby (1.1.5)
@@ -31,7 +32,7 @@ GEM
       safe_yaml (~> 1.0.0)
     diff-lcs (1.3)
     docile (1.1.5)
-    excon (0.67.0)
+    excon (0.71.1)
     faraday (0.17.0)
       multipart-post (>= 1.2, < 3)
     faraday-encoding (0.0.5)
@@ -41,19 +42,24 @@ GEM
     hashdiff (1.0.0)
     i18n (1.7.0)
       concurrent-ruby (~> 1.0)
-    json (2.2.0)
+    jaro_winkler (1.5.4)
+    json (2.3.0)
     mini_portile2 (2.4.0)
-    minitest (5.12.2)
-    multi_json (1.13.1)
+    minitest (5.13.0)
     multipart-post (2.1.1)
-    nokogiri (1.10.4)
+    nokogiri (1.10.7)
       mini_portile2 (~> 2.4.0)
-    oj (3.9.2)
+    oj (3.10.0)
+    oj_mimic_json (1.0.1)
+    parallel (1.19.1)
+    parser (2.6.5.0)
+      ast (~> 2.4.0)
     public_suffix (4.0.1)
-    rack (2.0.7)
+    rack (2.0.8)
     rack-test (0.8.3)
       rack (>= 1.0, < 3)
-    rake (13.0.0)
+    rainbow (3.0.0)
+    rake (13.0.1)
     rspec (3.9.0)
       rspec-core (~> 3.9.0)
       rspec-expectations (~> 3.9.0)
@@ -67,6 +73,16 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-support (3.9.0)
+    rubocop (0.77.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.6)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 1.7)
+    rubocop-performance (1.5.1)
+      rubocop (>= 0.71.0)
+    ruby-progressbar (1.10.1)
     safe_yaml (1.0.5)
     simplecov (0.13.0)
       docile (~> 1.1.0)
@@ -76,6 +92,7 @@ GEM
     thread_safe (0.3.6)
     tzinfo (1.2.5)
       thread_safe (~> 0.1)
+    unicode-display_width (1.6.0)
     vcr (3.0.3)
     webmock (3.7.6)
       addressable (>= 2.3.6)
@@ -86,15 +103,17 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.0)
+  bundler (~> 2.0)
   codeclimate-test-reporter (~> 1.0)
   maremma!
   rack-test (~> 0)
   rake
   rspec (~> 3.4)
+  rubocop (~> 0.77.0)
+  rubocop-performance (~> 1.5, >= 1.5.1)
   simplecov
   vcr (~> 3.0, >= 3.0.3)
   webmock (~> 3.0, >= 3.0.1)
 
 BUNDLED WITH
-   1.17.3
+   2.0.2

data/lib/maremma.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require 'active_support/all'
-require 'json'
-require 'nokogiri'
-require 'faraday'
-require 'faraday_middleware'
-require 'faraday/encoding'
-require 'excon'
-require 'uri'
-require 'addressable/uri'
-require 'maremma/xml_converter'
-require 'maremma/version'
+require "active_support/all"
+require "json"
+require "nokogiri"
+require "faraday"
+require "faraday_middleware"
+require "faraday/encoding"
+require "excon"
+require "uri"
+require "addressable/uri"
+require "maremma/xml_converter"
+require "maremma/version"
 
 module Maremma
   DEFAULT_TIMEOUT = 60
@@ -26,7 +26,7 @@ module Maremma
                             NoMethodError,
                             TypeError]
 
-  # ActiveSupport::XmlMini.backend = 'Nokogiri'
+  # ActiveSupport::XmlMini.backend = "Nokogiri"
 
   def self.post(url, options={})
     self.method(url, options.merge(method: "post"))
@@ -63,18 +63,20 @@ module Maremma
     conn.options[:timeout] = options[:timeout] || DEFAULT_TIMEOUT
 
     response = case options[:method]
-               when "get" then conn.get url, {}, options[:headers]
+               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
+                 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
+                 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
+                 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]
@@ -82,7 +84,7 @@ module Maremma
 
     # return error if we are close to the rate limit, if supported in headers
     if get_rate_limit_remaining(response.headers) < 3
-      return OpenStruct.new(body: { "errors" => [{ 'status' => 429, 'title' => "Too many requests" }] },
+      return OpenStruct.new(body: { "errors" => [{ "status" => 429, "title" => "Too many requests" }] },
                             headers: response.headers,
                             status: response.status)
     end
@@ -115,12 +117,12 @@ module Maremma
     Faraday.new do |c|
       c.ssl.verify = false if options[:ssl_self_signed]
       c.options.params_encoder = Faraday::FlatParamsEncoder
-      c.headers['Content-type'] = options[:headers]['Content-type'] if options[:headers]['Content-type'].present?
-      c.headers['Accept'] = options[:headers]['Accept']
-      c.headers['User-Agent'] = options[:headers]['User-Agent']
+      c.headers["Content-type"] = options[:headers]["Content-type"] if options[:headers]["Content-type"].present?
+      c.headers["Accept"] = options[:headers]["Accept"]
+      c.headers["User-Agent"] = options[:headers]["User-Agent"]
       c.use      FaradayMiddleware::FollowRedirects, limit: limit, cookie: :all if limit > 0
       c.request  :multipart
-      c.request  :json if options[:headers]['Accept'] == 'application/json'
+      c.request  :json if options[:headers]["Accept"] == "application/json"
       c.response :encoding
       c.adapter  :excon
     end
@@ -132,30 +134,30 @@ module Maremma
   end
 
   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' }
+    header_options = { "html" => "text/html;charset=UTF-8",
+                       "xml" => "application/xml;charset=UTF-8",
+                       "json" => "application/json;charset=UTF-8" }
 
     headers = options[:headers] ||= {}
 
     # set useragent
-    headers['User-Agent'] = ENV['USER_AGENT'] || "Mozilla/5.0 (compatible; Maremma/#{Maremma::VERSION}; +https://github.com/datacite/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?
+    headers["Content-type"] = header_options.fetch(options[:content_type], options[:content_type]) if options[:content_type].present?
 
     if options[:accept].present?
-      headers['Accept'] = header_options.fetch(options[:accept], options[:accept])
+      headers["Accept"] = header_options.fetch(options[:accept], options[:accept])
     else
       # accept all content
-      headers['Accept'] ||= "text/html,application/json,application/xml;q=0.9, text/plain;q=0.8,image/png,*/*;q=0.5"
+      headers["Accept"] ||= "text/html,application/json,application/xml;q=0.9, text/plain;q=0.8,image/png,*/*;q=0.5"
     end
 
     if options[:bearer].present?
-      headers['Authorization'] = "Bearer #{options[:bearer]}"
+      headers["Authorization"] = "Bearer #{options[:bearer]}"
     elsif options[:token].present?
       headers["Authorization"] = "Token token=#{options[:token]}"
     elsif options[:github_token].present?
@@ -171,18 +173,18 @@ module Maremma
 
   def self.rescue_faraday_error(error, response)
     if error.is_a?(Faraday::ResourceNotFound)
-      { 'errors' => [{ 'status' => 404, 'title' => "Not found" }] }
+      { "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) }] }
+      { "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)
-      { 'errors' => [{ 'status' => status, 'title' => title }] }
+      { "errors" => [{ "status" => status, "title" => title }] }
     end
   end
 
@@ -193,9 +195,9 @@ module Maremma
 
     if string.blank?
       { "data" => nil }
-    elsif string.is_a?(Hash) && string['hash']
-      { "data" => string['hash'] }
-    elsif string.is_a?(Hash) && string['data']
+    elsif string.is_a?(Hash) && string["hash"]
+      { "data" => string["hash"] }
+    elsif string.is_a?(Hash) && string["data"]
       string
     else
       { "data" => string }
@@ -205,19 +207,19 @@ module Maremma
   def self.parse_error_response(string)
     string = parse_response(string)
 
-    string = string['hash'] if string.is_a?(Hash) && string['hash']
+    string = string["hash"] if string.is_a?(Hash) && string["hash"]
 
-    if string.is_a?(Hash) && string['error']
-      string['error']
-    elsif string.is_a?(Hash) && string['errors']
-      string.dig('errors', 0, "title")
+    if string.is_a?(Hash) && string["error"]
+      string["error"]
+    elsif string.is_a?(Hash) && string["errors"]
+      string.dig("errors", 0, "title")
     else
       string
     end
   end
 
   def self.parse_response(string, options={})
-    string = string.dup.force_encoding('UTF-8')
+    string = string.dup.force_encoding("UTF-8")
     return string if options[:raw]
 
     from_json(string) || from_xml(string) || from_string(string)
@@ -238,7 +240,7 @@ module Maremma
       string.gsub!("</#{tag}>", "&lt;/#{tag}&gt;")
     end
 
-    if Nokogiri::XML(string, nil, 'UTF-8').errors.empty?
+    if Nokogiri::XML(string, nil, "UTF-8").errors.empty?
       Hash.from_xml(string)
     else
       nil

data/lib/maremma/version.rb

@@ -1,3 +1,3 @@
 module Maremma
-  VERSION = "4.4"
+  VERSION = "4.5"
 end

data/maremma.gemspec

@@ -1,5 +1,5 @@
 require "date"
-require File.expand_path("../lib/maremma/version", __FILE__)
+require File.expand_path("lib/maremma/version", __dir__)
 
 Gem::Specification.new do |s|
   s.authors       = "Martin Fenner"
@@ -12,29 +12,31 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.version       = Maremma::VERSION
   s.extra_rdoc_files = ["README.md"]
-  s.license       = 'MIT'
+  s.license       = "MIT"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.require_paths = ["lib"]
 
   # Declary dependencies here, rather than in the Gemfile
-  s.add_dependency 'builder', '~> 3.2', '>= 3.2.2'
-  s.add_dependency 'excon', '~> 0.67.0'
-  s.add_dependency 'faraday', '~> 0.17.0'
-  s.add_dependency 'faraday-encoding', '~> 0.0.4'
-  s.add_dependency 'faraday_middleware', '~> 0.13.1'
-  s.add_dependency 'nokogiri', '~> 1.10.4'
-  s.add_dependency 'multi_json', '~> 1.12'
-  s.add_dependency 'oj', '>= 2.8.3'
-  s.add_dependency 'activesupport', '>= 4.2.5', '< 6'
-  s.add_dependency 'addressable', '>= 2.3.6'
-  s.add_development_dependency 'bundler', '~> 1.0'
-  s.add_development_dependency 'rspec', '~> 3.4'
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'rack-test', '~> 0'
-  s.add_development_dependency 'vcr', '~> 3.0', '>= 3.0.3'
-  s.add_development_dependency 'webmock', '~> 3.0', '>= 3.0.1'
-  s.add_development_dependency 'codeclimate-test-reporter', "~> 1.0"
-  s.add_development_dependency 'simplecov'
+  s.add_dependency "activesupport", ">= 4.2.5", "< 6"
+  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.0"
+  s.add_dependency "faraday-encoding", "~> 0.0.4"
+  s.add_dependency "faraday_middleware", "~> 0.13.1"
+  s.add_dependency "nokogiri", "~> 1.10.4"
+  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"
+  s.add_development_dependency "codeclimate-test-reporter", "~> 1.0"
+  s.add_development_dependency "rack-test", "~> 0"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~> 3.4"
+  s.add_development_dependency "rubocop", "~> 0.77.0"
+  s.add_development_dependency "rubocop-performance", "~> 1.5", ">= 1.5.1"
+  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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Maremma do
   subject { Maremma }
@@ -20,7 +20,7 @@ describe Maremma do
 
     it "get xml" do
       stub = stub_request(:get, url).to_return(:body => data.to_xml, :status => 200, :headers => { "Content-Type" => "application/xml" })
-      response = subject.get(url, accept: 'xml')
+      response = subject.get(url, accept: "xml")
       expect(response.body).to eq("data"=>data)
       expect(response.headers).to eq("Content-Type"=>"application/xml")
       expect(stub).to have_been_requested
@@ -28,7 +28,7 @@ describe Maremma do
 
     it "get html" do
       stub = stub_request(:get, url).to_return(:body => data.to_s, :status => 200, :headers => { "Content-Type" => "text/html" })
-      response = subject.get(url, accept: '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(stub).to have_been_requested
@@ -39,9 +39,9 @@ describe Maremma do
                  fl: "doi,title,description,publisher,publicationYear,resourceType,resourceTypeGeneral,rightsURI,datacentre_symbol,xml,minted,updated",
                  fq: %w(has_metadata:true is_active:true),
                  facet: "true",
-                 'facet.field' => %w(resourceType_facet publicationYear datacentre_facet),
-                 'facet.limit' => 10,
-                 'f.resourceType_facet.facet.limit' => 15,
+                 "facet.field" => %w(resourceType_facet publicationYear datacentre_facet),
+                 "facet.limit" => 10,
+                 "f.resourceType_facet.facet.limit" => 15,
                  wt: "json" }.compact
       url = "https://search.datacite.org/api?" + URI.encode_www_form(params)
       expect(url).to eq("https://search.datacite.org/api?q=*%3A*&fl=doi%2Ctitle%2Cdescription%2Cpublisher%2CpublicationYear%2CresourceType%2CresourceTypeGeneral%2CrightsURI%2Cdatacentre_symbol%2Cxml%2Cminted%2Cupdated&fq=has_metadata%3Atrue&fq=is_active%3Atrue&facet=true&facet.field=resourceType_facet&facet.field=publicationYear&facet.field=datacentre_facet&facet.limit=10&f.resourceType_facet.facet.limit=15&wt=json")
@@ -63,7 +63,7 @@ describe Maremma do
 
     it "get xml raw" do
       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)
+      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(stub).to have_been_requested
@@ -73,7 +73,7 @@ describe Maremma do
   context "head" do
     it "head html" do
       stub = stub_request(:head, url).to_return(:status => 200, :headers => { "Content-Type" => "text/html" })
-      response = subject.head(url, accept: 'html')
+      response = subject.head(url, accept: "html")
       expect(response.body).to be_nil
       expect(response.headers).to eq("Content-Type"=>"text/html")
       expect(stub).to have_been_requested
@@ -83,13 +83,13 @@ describe Maremma do
   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" })
-      subject.post(url, content_type: 'json', data: post_data.to_json) { |response| expect(response.body).to eq(2) }
+      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" })
-      subject.post(url, content_type: 'xml', data: post_data.to_xml) { |response| expect(Hash.from_xml(response.body.to_s)["hash"]).to eq(data) }
+      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
   end
@@ -97,13 +97,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" })
-      subject.put(url, content_type: 'json', data: post_data.to_json) { |response| expect(JSON.parse(response.body.to_s)).to eq(data) }
+      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" })
-      subject.put(url, content_type: 'xml', data: post_data.to_xml) { |response| expect(Hash.from_xml(response.body.to_s)["hash"]).to eq(data) }
+      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
   end
@@ -111,13 +111,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" })
-      subject.patch(url, content_type: 'json', data: post_data.to_json) { |response| expect(JSON.parse(response.body.to_s)).to eq(data) }
+      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" })
-      subject.patch(url, content_type: 'xml', data: post_data.to_xml) { |response| expect(Hash.from_xml(response.body.to_s)["hash"]).to eq(data) }
+      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
   end
@@ -133,7 +133,7 @@ describe Maremma do
 
     it "get xml" do
       stub = stub_request(:get, url).to_return(:body => nil, :status => 200, :headers => { "Content-Type" => "application/xml" })
-      response = subject.get(url, accept: 'xml')
+      response = subject.get(url, accept: "xml")
       expect(response.body).to eq("data"=>nil)
       expect(response.headers).to eq("Content-Type"=>"application/xml")
       expect(stub).to have_been_requested
@@ -141,7 +141,7 @@ describe Maremma do
 
     it "get html" do
       stub = stub_request(:get, url).to_return(:body => nil, :status => 200, :headers => { "Content-Type" => "text/html" })
-      response = subject.get(url, accept: 'html')
+      response = subject.get(url, accept: "html")
       expect(response.body).to eq("data" => nil)
       expect(response.headers).to eq("Content-Type"=>"text/html")
       expect(stub).to have_been_requested
@@ -149,13 +149,13 @@ describe Maremma do
 
     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" })
-      subject.post(url, accept: 'xml', data: post_data.to_xml) { |response| expect(response.body).to eq("data" => nil) }
+      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" })
-      subject.put(url, accept: 'xml', data: post_data.to_xml) { |response| expect(response.body).to eq("data" => nil) }
+      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
@@ -165,41 +165,41 @@ describe Maremma do
 
     it "get json" do
       stub = stub_request(:get, url).to_return(:body => error.to_json, :status => [404], :headers => { "Content-Type" => "application/json" })
-      response = subject.get(url, accept: '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" })
-      response = subject.get(url, accept: '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" })
-      response = subject.get(url, accept: '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" })
-      response = subject.head(url, accept: '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" })
-      subject.post(url, accept: 'xml', data: post_data.to_xml) { |response| expect(Hash.from_xml(response.to_s)["hash"]).to eq(error) }
+      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" })
-      subject.put(url, accept: 'xml', data: post_data.to_xml) { |response| expect(Hash.from_xml(response.to_s)["hash"]).to eq(error) }
+      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
@@ -209,41 +209,41 @@ describe Maremma do
 
     it "get json" do
       stub = stub_request(:get, url).to_return(:body => error.to_json, :status => [405], :headers => { "Content-Type" => "application/json" })
-      response = subject.get(url, accept: '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" })
-      response = subject.get(url, accept: '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" })
-      response = subject.get(url, accept: '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" })
-      response = subject.head(url, accept: '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" })
-      subject.post(url, accept: 'xml', data: post_data.to_xml) { |response| expect(Hash.from_xml(response.to_s)["hash"]).to eq(error) }
+      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" })
-      subject.put(url, accept: 'xml', data: post_data.to_xml) { |response| expect(Hash.from_xml(response.to_s)["hash"]).to eq(error) }
+      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
@@ -258,34 +258,34 @@ describe Maremma do
 
     it "get xml" do
       stub = stub_request(:get, url).to_return(:status => [408])
-      response = subject.get(url, accept: 'xml')
+      response = subject.get(url, accept: "xml")
       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])
-      response = subject.get(url, accept: 'html')
+      response = subject.get(url, accept: "html")
       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])
-      response = subject.head(url, accept: 'html')
+      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])
-      subject.post(url, accept: 'xml', data: post_data.to_xml) { |response| expect(response.body).to be_nil }
+      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])
-      subject.put(url, accept: 'xml', data: post_data.to_xml) { |response| expect(response.body).to be_nil }
+      subject.put(url, accept: "xml", data: post_data.to_xml) { |response| expect(response.body).to be_nil }
       expect(stub).to have_been_requested
     end
   end
@@ -311,27 +311,27 @@ describe Maremma do
 
     it "get xml" do
       stub = stub_request(:get, url).to_raise(Faraday::ConnectionFailed.new("Connection refused - connect(2)"))
-      response = subject.get(url, accept: 'xml')
+      response = subject.get(url, accept: "xml")
       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')
+      response = subject.get(url, accept: "html")
       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)"))
-      subject.post(url, accept: 'xml', data: post_data.to_xml) { |response| expect(response.body).to be_nil }
+      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)"))
-      subject.put(url, accept: 'xml', data: post_data.to_xml) { |response| expect(response.body).to be_nil }
+      subject.put(url, accept: "xml", data: post_data.to_xml) { |response| expect(response.body).to be_nil }
       expect(stub).to have_been_requested
     end
   end
@@ -346,21 +346,21 @@ describe Maremma do
 
     it "get xml" do
       stub = stub_request(:get, url).to_raise(Faraday::Error::ClientError.new("the server responded with status 401"))
-      response = subject.get(url, accept: 'xml')
+      response = subject.get(url, accept: "xml")
       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::Error::ClientError.new("the server responded with status 401"))
-      response = subject.get(url, accept: 'html')
+      response = subject.get(url, accept: "html")
       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::Error::ClientError.new("the server responded with status 401"))
-      subject.post(url, accept: 'xml', data: post_data.to_xml) do |response|
+      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"}])
       end
@@ -369,7 +369,7 @@ describe Maremma do
 
     it "put xml" do
       stub = stub_request(:put, url).with(:body => post_data.to_xml).to_raise(Faraday::Error::ClientError.new("the server responded with status 401"))
-      subject.put(url, accept: 'xml', data: post_data.to_xml) do |response|
+      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"}])
       end
@@ -387,64 +387,64 @@ describe Maremma do
 
     it "get xml" do
       stub = stub_request(:get, url).to_timeout
-      response = subject.get(url, accept: 'xml')
+      response = subject.get(url, accept: "xml")
       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')
+      response = subject.get(url, accept: "html")
       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
-      subject.post(url, accept: 'xml', data: post_data.to_xml) { |response| expect(response.body).to be_nil }
+      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
-      subject.put(url, accept: 'xml', data: post_data.to_xml) { |response| expect(response.body).to be_nil }
+      subject.put(url, accept: "xml", data: post_data.to_xml) { |response| expect(response.body).to be_nil }
       expect(stub).to have_been_requested
     end
   end
 
   context "rate limit exceeded" do
     it "get json" do
-      stub = stub_request(:get, url).to_return(status: 200, headers: { 'X-Rate-Limit-Remaining' => 2 })
+      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(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')
+      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(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')
+      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(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 })
-      subject.post(url, accept: 'xml', data: post_data.to_xml) { |response| expect(response.body).to be_nil }
+        .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 })
-      subject.put(url, accept: 'xml', data: post_data.to_xml) { |response| expect(response.body).to be_nil }
+        .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
   end
@@ -530,159 +530,159 @@ describe Maremma do
     end
   end
 
-  context 'parse_error_response' do
-    it 'json' do
-      string = '{ "error": "An error occured." }'
+  context "parse_error_response" do
+    it "json" do
+      string = "{ \"error\": \"An error occured.\" }"
       expect(subject.parse_error_response(string)).to eq("An error occured.")
     end
 
-    it 'json not error' do
-      string = '{ "customError": "An error occured." }'
+    it "json not error" do
+      string = "{ \"customError\": \"An error occured.\" }"
       expect(subject.parse_error_response(string)).to eq("customError"=>"An error occured.")
     end
 
-    it 'xml' do
-      string = '<error>An error occured.</error>'
+    it "xml" do
+      string = "<error>An error occured.</error>"
       expect(subject.parse_error_response(string)).to eq("An error occured.")
     end
   end
 
-  context 'parse_success_response' do
-    it 'from_json' do
-      string = '{ "word": "abc" }'
-      expect(subject.parse_success_response(string)).to eq({"data"=>{"word"=>"abc"}})
+  context "parse_success_response" do
+    it "from_json" do
+      string = "{ \"word\": \"abc\" }"
+      expect(subject.parse_success_response(string)).to eq({ "data" => { "word"=>"abc" }})
     end
 
-    it 'from_json with data' do
-      string = '{ "data": { "word": "abc" }}'
+    it "from_json with data" do
+      string = "{ \"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 }}'
+    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}})
     end
 
-    it 'from_xml' do
+    it "from_xml" do
       string = "<word>abc</word>"
       expect(subject.parse_success_response(string)).to eq("data"=>{"word"=>"abc"})
     end
 
-    it 'from_xml with attribute' do
-      string = '<word type="small">abc</word>'
+    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"}})
     end
 
-    # it 'from_xml with allowed content attributes' do
-    #   string = '<title>Sexual conflict and correlated evolution between male persistence and female resistance traits in the seed beetle <i>Callosobruchus maculatus</i></title>'
+    # it "from_xml with allowed content attributes" do
+    #   string = "<title>Sexual conflict and correlated evolution between male persistence and female resistance traits in the seed beetle <i>Callosobruchus maculatus</i></title>"
     #   expect(subject.parse_success_response(string)).to eq("data"=>{"title"=>"Sexual conflict and correlated evolution between male persistence and female resistance traits in the seed beetle <i>Callosobruchus maculatus</i>"})
     # end
 
-    it 'from_xml with attribute type string' do
-      string = '<crm-item name="publisher-name" type="string">eLife Sciences Publications, Ltd</crm-item>'
+    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"})
     end
 
-    it 'from_xml with mixed attribute' do
-      string = '<word type="small">abc<footnote>1</footnote></word>'
+    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"}})
     end
 
-    it 'from_string' do
+    it "from_string" do
       string = "abc"
       expect(subject.parse_success_response(string)).to eq("data"=>"abc")
     end
 
-    it 'from_string with utf-8' do
+    it "from_string with utf-8" do
       string = "fön  "
       expect(subject.parse_success_response(string)).to eq("data"=>"fön")
     end
   end
 
-  context 'accept headers' do
-    it 'default' do
+  context "accept headers" do
+    it "default" do
       headers = subject.set_request_headers(url)
       expect(headers["Accept"]).to eq("text/html,application/json,application/xml;q=0.9, text/plain;q=0.8,image/png,*/*;q=0.5")
     end
 
-    it 'json' do
-      headers = subject.set_request_headers(url, accept: 'json')
+    it "json" do
+      headers = subject.set_request_headers(url, accept: "json")
       expect(headers["Accept"]).to eq("application/json;charset=UTF-8")
     end
 
-    it 'xml' do
-      headers = subject.set_request_headers(url, accept: 'xml')
+    it "xml" do
+      headers = subject.set_request_headers(url, accept: "xml")
       expect(headers["Accept"]).to eq("application/xml;charset=UTF-8")
     end
 
-    it 'html' do
-      headers = subject.set_request_headers(url, accept: 'html')
+    it "html" do
+      headers = subject.set_request_headers(url, accept: "html")
       expect(headers["Accept"]).to eq("text/html;charset=UTF-8")
     end
 
-    it 'other' do
-      headers = subject.set_request_headers(url, accept: 'application/x-bibtex')
+    it "other" do
+      headers = subject.set_request_headers(url, accept: "application/x-bibtex")
       expect(headers["Accept"]).to eq("application/x-bibtex")
     end
   end
 
-  context 'authentication' do
-    it 'no auth' do
+  context "authentication" do
+    it "no auth" do
       options = {}
       expect(subject.set_request_headers(url, options)["Authorization"]).to be nil
     end
 
-    it 'bearer' do
-      options = { bearer: 'mF_9.B5f-4.1JqM' }
+    it "bearer" do
+      options = { bearer: "mF_9.B5f-4.1JqM" }
       expect(subject.set_request_headers(url, options)["Authorization"]).to eq("Bearer mF_9.B5f-4.1JqM")
     end
 
-    it 'token' do
-      options = { token: '12345' }
+    it "token" do
+      options = { token: "12345" }
       expect(subject.set_request_headers(url, options)["Authorization"]).to eq("Token token=12345")
     end
 
-    it 'github_token' do
-      options = { github_token: '12345' }
+    it "github_token" do
+      options = { github_token: "12345" }
       expect(subject.set_request_headers(url, options)["Authorization"]).to eq("Token 12345")
     end
 
-    it 'github_token' do
-      options = { github_token: '12345' }
+    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")
     end
 
-    it 'basic' do
-      options = { username: 'foo', password: '12345' }
+    it "basic" do
+      options = { username: "foo", password: "12345" }
       basic = Base64.strict_encode64("foo:12345")
       expect(subject.set_request_headers(url, options)["Authorization"]).to eq("Basic #{basic}")
     end
   end
 
-  context 'set host' do
-    it 'crossref', vcr: true do
+  context "set host" do
+    it "crossref", vcr: true do
       url = "https://api.eventdata.crossref.org/v1/events?mailto=info@datacite.org&rows=0&source=crossref"
       response = subject.get(url)
       expect(response.status).to eq(200)
       expect(response.body.dig("data", "message", "total-results")).to eq(57969)
     end
 
-    it 'ornl.gov', vcr: true do
+    it "ornl.gov", vcr: true do
       url = "https://daac.ornl.gov/cgi-bin/dsviewer.pl?ds_id=1339"
       response = subject.get(url)
       expect(response.status).to eq(200)
-      doc = Nokogiri::XML(response.body.fetch("data", nil), nil, 'UTF-8')
+      doc = Nokogiri::XML(response.body.fetch("data", nil), nil, "UTF-8")
       nodeset = doc.css("script")
       string = nodeset.find { |element| element["type"] == "application/ld+json" }
       json = JSON.parse(string)
       expect(json["@id"]).to eq("https://doi.org/10.3334/ORNLDAAC/1339")
     end
 
-    it 'redirection', vcr: true do
+    it "redirection", vcr: true do
       url = "https://doi.org/10.3334/ornldaac/1339"
       response = subject.get(url)
       expect(response.status).to eq(200)
-      doc = Nokogiri::XML(response.body.fetch("data", nil), nil, 'UTF-8')
+      doc = Nokogiri::XML(response.body.fetch("data", nil), nil, "UTF-8")
       nodeset = doc.css("script")
       string = nodeset.find { |element| element["type"] == "application/ld+json" }
       json = JSON.parse(string)
@@ -690,14 +690,14 @@ describe Maremma do
     end  
   end
 
-  context 'ssl verify', vcr: true do
-    it 'default' do
+  context "ssl verify", vcr: true do
+    it "default" do
       url = "https://doi.org/10.5281/ZENODO.21430"
       response = subject.get(url)
       expect(response.status).to eq(200)
     end
 
-    it 'self-signed' 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}
       response = subject.get(url, options)