trino-client 1.0.2 → 2.0.0

data/spec/statement_client_spec.rb

@@ -32,14 +32,14 @@ describe Trino::Client::StatementClient do
   it "sets headers" do
     stub_request(:post, "localhost/v1/statement").
       with(body: query,
-           headers: {
-              "User-Agent" => "trino-ruby/#{VERSION}",
-              "X-Trino-Catalog" => options[:catalog],
-              "X-Trino-Schema" => options[:schema],
-              "X-Trino-User" => options[:user],
-              "X-Trino-Language" => options[:language],
-              "X-Trino-Time-Zone" => options[:time_zone],
-    }).to_return(body: response_json.to_json)
+        headers: {
+           "User-Agent" => "trino-ruby/#{VERSION}",
+           "X-Trino-Catalog" => options[:catalog],
+           "X-Trino-Schema" => options[:schema],
+           "X-Trino-User" => options[:user],
+           "X-Trino-Language" => options[:language],
+           "X-Trino-Time-Zone" => options[:time_zone],
+ }).to_return(body: response_json.to_json)
 
     StatementClient.new(faraday, query, options)
   end
@@ -56,14 +56,14 @@ describe Trino::Client::StatementClient do
     retry_p = false
     stub_request(:post, "localhost/v1/statement").
       with(body: query,
-           headers: {
-              "User-Agent" => "trino-ruby/#{VERSION}",
-              "X-Trino-Catalog" => options[:catalog],
-              "X-Trino-Schema" => options[:schema],
-              "X-Trino-User" => options[:user],
-              "X-Trino-Language" => options[:language],
-              "X-Trino-Time-Zone" => options[:time_zone],
-    }).to_return(body: response_json2.to_json)
+        headers: {
+           "User-Agent" => "trino-ruby/#{VERSION}",
+           "X-Trino-Catalog" => options[:catalog],
+           "X-Trino-Schema" => options[:schema],
+           "X-Trino-User" => options[:user],
+           "X-Trino-Language" => options[:language],
+           "X-Trino-Time-Zone" => options[:time_zone],
+ }).to_return(body: response_json2.to_json)
 
     stub_request(:get, "localhost/v1/next_uri").
       with(headers: {
@@ -73,27 +73,27 @@ describe Trino::Client::StatementClient do
               "X-Trino-User" => options[:user],
               "X-Trino-Language" => options[:language],
               "X-Trino-Time-Zone" => options[:time_zone],
-    }).to_return(body: lambda{|req|if retry_p; response_json.to_json; else; retry_p=true; raise Timeout::Error.new("execution expired"); end })
+    }).to_return(body: lambda { |req| if retry_p; response_json.to_json; else; retry_p = true; raise Timeout::Error.new("execution expired"); end })
 
     sc = StatementClient.new(faraday, query, options.merge(http_open_timeout: 1))
-    sc.has_next?.should be_true
-    sc.advance.should be_true
-    retry_p.should be_true
+    expect(sc.has_next?).to eq true
+    expect(sc.advance).to eq true
+    expect(retry_p).to eq true
   end
 
   it "uses 'Accept: application/x-msgpack' if option is set" do
     retry_p = false
     stub_request(:post, "localhost/v1/statement").
       with(body: query,
-           headers: {
-              "User-Agent" => "trino-ruby/#{VERSION}",
-              "X-Trino-Catalog" => options[:catalog],
-              "X-Trino-Schema" => options[:schema],
-              "X-Trino-User" => options[:user],
-              "X-Trino-Language" => options[:language],
-              "X-Trino-Time-Zone" => options[:time_zone],
-              "Accept" => "application/x-msgpack,application/json"
-    }).to_return(body: MessagePack.dump(response_json2), headers: {"Content-Type" => "application/x-msgpack"})
+        headers: {
+           "User-Agent" => "trino-ruby/#{VERSION}",
+           "X-Trino-Catalog" => options[:catalog],
+           "X-Trino-Schema" => options[:schema],
+           "X-Trino-User" => options[:user],
+           "X-Trino-Language" => options[:language],
+           "X-Trino-Time-Zone" => options[:time_zone],
+           "Accept" => "application/x-msgpack,application/json"
+ }).to_return(body: MessagePack.dump(response_json2), headers: {"Content-Type" => "application/x-msgpack"})
 
     stub_request(:get, "localhost/v1/next_uri").
       with(headers: {
@@ -104,13 +104,13 @@ describe Trino::Client::StatementClient do
               "X-Trino-Language" => options[:language],
               "X-Trino-Time-Zone" => options[:time_zone],
               "Accept" => "application/x-msgpack,application/json"
-    }).to_return(body: lambda{|req|if retry_p; MessagePack.dump(response_json); else; retry_p=true; raise Timeout::Error.new("execution expired"); end }, headers: {"Content-Type" => "application/x-msgpack"})
+    }).to_return(body: lambda { |req| if retry_p; MessagePack.dump(response_json); else; retry_p = true; raise Timeout::Error.new("execution expired"); end }, headers: {"Content-Type" => "application/x-msgpack"})
 
     options.merge!(http_open_timeout: 1, enable_x_msgpack: "application/x-msgpack")
     sc = StatementClient.new(faraday, query, options)
-    sc.has_next?.should be_true
-    sc.advance.should be_true
-    retry_p.should be_true
+    expect(sc.has_next?).to eq true
+    expect(sc.advance).to eq true
+    expect(retry_p).to eq true
   end
 
   # trino version could be "V0_ddd" or "Vddd"
@@ -127,17 +127,17 @@ describe Trino::Client::StatementClient do
           "connectorHandle" => {}
         }
       })
-      dh.handle.should be_a_kind_of Models::TableHandle
-      dh.handle.connector_id.should == "c1"
-      dh.handle.connector_handle.should == {}
+      expect(dh.handle).to be_a_kind_of Models::TableHandle
+      expect(dh.handle.connector_id).to eq "c1"
+      expect(dh.handle.connector_handle).to eq {}
     end
 
     it "validates models" do
-      lambda do
+      expect do
         Models::DeleteHandle.decode({
           "handle" => "invalid"
         })
-      end.should raise_error(TypeError, /String to Hash/)
+      end.to raise_error(TypeError, /String to Hash/)
     end
   else
     it "decodes DeleteTarget" do
@@ -147,18 +147,18 @@ describe Trino::Client::StatementClient do
           "connectorHandle" => {}
         }
       })
-      dh.handle.should be_a_kind_of Models::TableHandle
-      dh.handle.catalog_name.should == "c1"
-      dh.handle.connector_handle.should == {}
+      expect(dh.handle).to be_a_kind_of(Models::TableHandle)
+      expect(dh.handle.catalog_name).to eq "c1"
+      expect(dh.handle.connector_handle).to eq({})
     end
 
     it "validates models" do
-      lambda do
+      expect do
         Models::DeleteTarget.decode({
           "catalogName" => "c1",
           "handle" => "invalid"
         })
-      end.should raise_error(TypeError, /String to Hash/)
+      end.to raise_error(TypeError, /String to Hash/)
     end
   end
 
@@ -167,7 +167,7 @@ describe Trino::Client::StatementClient do
       with(body: query).to_return(body: response_json2.to_json, headers: {"X-Test-Header" => "123"})
 
     sc = StatementClient.new(faraday, query, options.merge(http_open_timeout: 1))
-    sc.current_results_headers["X-Test-Header"].should == "123"
+    expect(sc.current_results_headers["X-Test-Header"]).to eq "123"
   end
 
   it "receives headers of POST through Query" do
@@ -175,7 +175,7 @@ describe Trino::Client::StatementClient do
       with(body: query).to_return(body: response_json2.to_json, headers: {"X-Test-Header" => "123"})
 
     q = Trino::Client.new(options).query(query)
-    q.current_results_headers["X-Test-Header"].should == "123"
+    expect(q.current_results_headers["X-Test-Header"]).to eq "123"
   end
 
   describe "#query_id" do
@@ -187,10 +187,10 @@ describe Trino::Client::StatementClient do
         to_return(body: response_json.to_json, headers: {"X-Test-Header" => "123"})
 
       sc = StatementClient.new(faraday, query, options.merge(http_open_timeout: 1))
-      sc.query_id.should == "queryid"
-      sc.has_next?.should be_true
-      sc.advance.should be_true
-      sc.query_id.should == "queryid"
+      expect(sc.query_id).to eq "queryid"
+      expect(sc.has_next?).to eq true
+      expect(sc.advance).to eq true
+      expect(sc.query_id).to eq "queryid"
     end
   end
 
@@ -214,21 +214,21 @@ describe Trino::Client::StatementClient do
     end
 
     it "raises an exception with sample JSON if response is unexpected" do
-      lambda do
+      expect do
         stub_request(:get, "http://localhost/v1/query/#{response_json2[:id]}").
           with(headers: headers).
           to_return(body: {"session" => "invalid session structure"}.to_json)
         statement_client.query_info
-      end.should raise_error(TrinoHttpError, /Trino API returned unexpected structure at \/v1\/query\/queryid\. Expected Trino::Client::ModelVersions::.*::QueryInfo but got {"session":"invalid session structure"}/)
+      end.to raise_error(TrinoHttpError, /Trino API returned unexpected structure at \/v1\/query\/queryid\. Expected Trino::Client::ModelVersions::.*::QueryInfo but got {"session":"invalid session structure"}/)
     end
 
     it "raises an exception if response format is unexpected" do
-      lambda do
+      expect do
         stub_request(:get, "http://localhost/v1/query/#{response_json2[:id]}").
           with(headers: headers).
           to_return(body: "unexpected data structure (not JSON)")
         statement_client.query_info
-      end.should raise_error(TrinoHttpError, /Trino API returned unexpected data format./)
+      end.to raise_error(TrinoHttpError, /Trino API returned unexpected data format./)
     end
 
     it "is redirected if server returned 301" do
@@ -241,7 +241,7 @@ describe Trino::Client::StatementClient do
         to_return(body: {"queryId" => "queryid"}.to_json)
 
       query_info = statement_client.query_info
-      query_info.query_id.should == "queryid"
+      expect(query_info.query_id).to eq "queryid"
     end
   end
 
@@ -251,14 +251,14 @@ describe Trino::Client::StatementClient do
     it "sends DELETE request with empty body to /v1/query/{queryId}" do
       stub_request(:delete, "http://localhost/v1/query/#{query_id}").
         with(body: "",
-             headers: {
-                "User-Agent" => "trino-ruby/#{VERSION}",
-                "X-Trino-Catalog" => options[:catalog],
-                "X-Trino-Schema" => options[:schema],
-                "X-Trino-User" => options[:user],
-                "X-Trino-Language" => options[:language],
-                "X-Trino-Time-Zone" => options[:time_zone],
-      }).to_return(body: {}.to_json)
+          headers: {
+             "User-Agent" => "trino-ruby/#{VERSION}",
+             "X-Trino-Catalog" => options[:catalog],
+             "X-Trino-Schema" => options[:schema],
+             "X-Trino-User" => options[:user],
+             "X-Trino-Language" => options[:language],
+             "X-Trino-Time-Zone" => options[:time_zone],
+   }).to_return(body: {}.to_json)
 
       Trino::Client.new(options).kill(query_id)
     end
@@ -277,13 +277,13 @@ describe Trino::Client::StatementClient do
     end
 
     it "sets X-Trino-Session from properties" do
-      options[:properties] = {"hello" => "world", "name"=>"value"}
+      options[:properties] = {"hello" => "world", "name" => "value"}
 
       stub_request(:post, "localhost/v1/statement").
         with(body: query,
-             headers: headers.merge({
-               "X-Trino-Session" => options[:properties].map {|k,v| "#{k}=#{v}"}.join(", ")
-             })).
+          headers: headers.merge({
+            "X-Trino-Session" => options[:properties].map { |k, v| "#{k}=#{v}" }.join(", ")
+          })).
         to_return(body: response_json.to_json)
 
       StatementClient.new(faraday, query, options)
@@ -294,7 +294,7 @@ describe Trino::Client::StatementClient do
 
       stub_request(:post, "localhost/v1/statement").
         with(body: query,
-             headers: headers.merge("X-Trino-Client-Info" => "raw")).
+          headers: headers.merge("X-Trino-Client-Info" => "raw")).
         to_return(body: response_json.to_json)
 
       StatementClient.new(faraday, query, options)
@@ -305,7 +305,7 @@ describe Trino::Client::StatementClient do
 
       stub_request(:post, "localhost/v1/statement").
         with(body: query,
-             headers: headers.merge("X-Trino-Client-Info" => '{"k1":"v1","k2":"v2"}')).
+          headers: headers.merge("X-Trino-Client-Info" => '{"k1":"v1","k2":"v2"}')).
         to_return(body: response_json.to_json)
 
       StatementClient.new(faraday, query, options)
@@ -316,7 +316,7 @@ describe Trino::Client::StatementClient do
 
       stub_request(:post, "localhost/v1/statement").
         with(body: query,
-             headers: headers.merge("X-Trino-Client-Tags" => "k1:v1,k2:v2")).
+          headers: headers.merge("X-Trino-Client-Tags" => "k1:v1,k2:v2")).
         to_return(body: response_json.to_json)
 
       StatementClient.new(faraday, query, options)
@@ -329,28 +329,28 @@ describe Trino::Client::StatementClient do
     it "adds basic auth headers when ssl is enabled and a password is given" do
       stub_request(:post, "https://localhost/v1/statement").
         with(body: query,
-             headers: {
-                "User-Agent" => "trino-ruby/#{VERSION}",
-                "X-Trino-Catalog" => options[:catalog],
-                "X-Trino-Schema" => options[:schema],
-                "X-Trino-User" => options[:user],
-                "X-Trino-Language" => options[:language],
-                "X-Trino-Time-Zone" => options[:time_zone],
-            },
-            basic_auth: [options[:user], password]
+          headers: {
+             "User-Agent" => "trino-ruby/#{VERSION}",
+             "X-Trino-Catalog" => options[:catalog],
+             "X-Trino-Schema" => options[:schema],
+             "X-Trino-User" => options[:user],
+             "X-Trino-Language" => options[:language],
+             "X-Trino-Time-Zone" => options[:time_zone],
+         },
+          basic_auth: [options[:user], password]
       ).to_return(body: response_json.to_json)
 
-      options.merge!(ssl: { verify: true }, password: password)
+      options.merge!(ssl: {verify: true}, password: password)
       StatementClient.new(faraday, query, options)
     end
 
     it "forbids using basic auth when ssl is disabled" do
-      lambda do
+      expect do
         Query.__send__(:faraday_client, {
           server: 'localhost',
           password: 'abcd'
         })
-      end.should raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
   end
 
@@ -359,7 +359,7 @@ describe Trino::Client::StatementClient do
       f = Query.__send__(:faraday_client, {
         server: "localhost",
       })
-      f.url_prefix.to_s.should == "http://localhost/"
+      expect(f.url_prefix.to_s).to eq "http://localhost/"
     end
 
     it "is enabled with ssl: true" do
@@ -367,8 +367,8 @@ describe Trino::Client::StatementClient do
         server: "localhost",
         ssl: true,
       })
-      f.url_prefix.to_s.should == "https://localhost/"
-      f.ssl.verify?.should == true
+      expect(f.url_prefix.to_s).to eq "https://localhost/"
+      expect(f.ssl.verify?).to eq true
     end
 
     it "is enabled with ssl: {verify: false}" do
@@ -376,17 +376,17 @@ describe Trino::Client::StatementClient do
         server: "localhost",
         ssl: {verify: false}
       })
-      f.url_prefix.to_s.should == "https://localhost/"
-      f.ssl.verify?.should == false
+      expect(f.url_prefix.to_s).to eq "https://localhost/"
+      expect(f.ssl.verify?).to eq false
     end
 
     it "rejects invalid ssl: verify: object" do
-      lambda do
+      expect do
         f = Query.__send__(:faraday_client, {
           server: "localhost",
           ssl: {verify: "??"}
         })
-      end.should raise_error(ArgumentError, /String/)
+      end.to raise_error(ArgumentError, /String/)
     end
 
     it "is enabled with ssl: Hash" do
@@ -405,31 +405,31 @@ describe Trino::Client::StatementClient do
         ssl: ssl,
       })
 
-      f.url_prefix.to_s.should == "https://localhost/"
-      f.ssl.verify?.should == true
-      f.ssl.ca_file.should == ssl[:ca_file]
-      f.ssl.ca_path.should == ssl[:ca_path]
-      f.ssl.cert_store.should == ssl[:cert_store]
-      f.ssl.client_cert.should == ssl[:client_cert]
-      f.ssl.client_key.should == ssl[:client_key]
+      expect(f.url_prefix.to_s).to eq "https://localhost/"
+      expect(f.ssl.verify?).to eq true
+      expect(f.ssl.ca_file).to eq ssl[:ca_file]
+      expect(f.ssl.ca_path).to eq ssl[:ca_path]
+      expect(f.ssl.cert_store).to eq ssl[:cert_store]
+      expect(f.ssl.client_cert).to eq ssl[:client_cert]
+      expect(f.ssl.client_key).to eq ssl[:client_key]
     end
 
     it "rejects an invalid string" do
-      lambda do
+      expect do
         Query.__send__(:faraday_client, {
           server: "localhost",
           ssl: '??',
         })
-      end.should raise_error(ArgumentError, /String/)
+      end.to raise_error(ArgumentError, /String/)
     end
 
     it "rejects an integer" do
-      lambda do
+      expect do
         Query.__send__(:faraday_client, {
           server: "localhost",
           ssl: 3,
         })
-      end.should raise_error(ArgumentError, /:ssl/)
+      end.to raise_error(ArgumentError, /:ssl/)
     end
   end
 
@@ -440,16 +440,15 @@ describe Trino::Client::StatementClient do
 
     faraday = Faraday.new(url: "http://localhost")
     client = StatementClient.new(faraday, query, options.merge(model_version: "316"))
-    client.current_results.should be_a_kind_of(ModelVersions::V316::QueryResults)
+    expect(client.current_results).to be_a_kind_of(ModelVersions::V316::QueryResults)
   end
 
   it "rejects unsupported model version" do
-    lambda do
+    expect do
       StatementClient.new(faraday, query, options.merge(model_version: "0.111"))
-    end.should raise_error(NameError)
+    end.to raise_error(NameError)
   end
 
-
   let :nested_json do
     nested_stats = {createTime: Time.now}
     # JSON max nesting default value is 100
@@ -465,14 +464,14 @@ describe Trino::Client::StatementClient do
   it "parse nested json properly" do
     stub_request(:post, "localhost/v1/statement").
         with(body: query,
-             headers: {
-                 "User-Agent" => "trino-ruby/#{VERSION}",
-                 "X-Trino-Catalog" => options[:catalog],
-                 "X-Trino-Schema" => options[:schema],
-                 "X-Trino-User" => options[:user],
-                 "X-Trino-Language" => options[:language],
-                 "X-Trino-Time-Zone" => options[:time_zone],
-             }).to_return(body: nested_json.to_json(:max_nesting => false))
+          headers: {
+              "User-Agent" => "trino-ruby/#{VERSION}",
+              "X-Trino-Catalog" => options[:catalog],
+              "X-Trino-Schema" => options[:schema],
+              "X-Trino-User" => options[:user],
+              "X-Trino-Language" => options[:language],
+              "X-Trino-Time-Zone" => options[:time_zone],
+          }).to_return(body: nested_json.to_json(:max_nesting => false))
 
     StatementClient.new(faraday, query, options)
   end
@@ -544,29 +543,29 @@ describe Trino::Client::StatementClient do
         stub_request(:get, "localhost/v1/next_uri").
           with(headers: headers).
           to_return(body: planning_response.to_json)
-        lambda do
+        expect do
           client.advance
-        end.should raise_error(Trino::Client::TrinoQueryTimeoutError, "Query queryid timed out")
+        end.to raise_error(Trino::Client::TrinoQueryTimeoutError, "Query queryid timed out")
       end
 
       it "raises TrinoQueryTimeoutError if timeout during initial resuming" do
         stub_request(:get, "localhost/v1/next_uri").
           with(headers: headers).
-          to_return(body: lambda{|req| raise Timeout::Error.new("execution expired")})
+          to_return(body: lambda { |req| raise Timeout::Error.new("execution expired") })
 
-        lambda do
+        expect do
           StatementClient.new(faraday, query, options.merge(timeout_type => 1), "/v1/next_uri")
-        end.should raise_error(Trino::Client::TrinoQueryTimeoutError, "Query timed out")
+        end.to raise_error(Trino::Client::TrinoQueryTimeoutError, "Query timed out")
       end
 
       it "raises TrinoHttpError if timeout during initial resuming and #{timeout_type} < retry_timeout" do
         stub_request(:get, "localhost/v1/next_uri").
           with(headers: headers).
-          to_return(body: lambda{|req| raise Timeout::Error.new("execution expired")})
+          to_return(body: lambda { |req| raise Timeout::Error.new("execution expired") })
 
-        lambda do
+        expect do
           StatementClient.new(faraday, query, options.merge(timeout_type => 2, retry_timeout: 1), "/v1/next_uri")
-        end.should raise_error(Trino::Client::TrinoHttpError, "Trino API error due to timeout")
+        end.to raise_error(Trino::Client::TrinoHttpError, "Trino API error due to timeout")
       end
     end
 
@@ -606,9 +605,9 @@ describe Trino::Client::StatementClient do
       stub_request(:get, "localhost/v1/next_uri").
         with(headers: headers).
         to_return(body: late_running_response.to_json)
-      lambda do
+      expect do
         client.advance
-      end.should raise_error(Trino::Client::TrinoQueryTimeoutError, "Query queryid timed out")
+      end.to raise_error(Trino::Client::TrinoQueryTimeoutError, "Query queryid timed out")
     end
 
     it "doesn't raise errors if query is done" do
@@ -631,7 +630,5 @@ describe Trino::Client::StatementClient do
       sleep 1
       client.advance # set finished
     end
-
   end
 end
-

data/spec/tpch_query_spec.rb

@@ -38,4 +38,4 @@ describe Trino::Client::Client do
     expect(columns.length).to be(8)
     expect(rows.length).to be(4)
   end
-end
+end

data/trino-client-ruby/lib/trino-client-ruby.rb

@@ -1 +1 @@
-require 'trino-client'
+require "trino-client"

data/trino-client-ruby/trino-client-ruby.gemspec

@@ -1,4 +1,4 @@
-require File.expand_path '../lib/trino/client/version', File.dirname(__FILE__)
+require File.expand_path "../lib/trino/client/version", File.dirname(__FILE__)
 
 Gem::Specification.new do |gem|
   gem.name          = "trino-client-ruby"
@@ -6,12 +6,12 @@ Gem::Specification.new do |gem|
 
   gem.authors       = ["Sadayuki Furuhashi"]
   gem.email         = ["sf@treasure-data.com"]
-  gem.description   = %q{Trino client library}
-  gem.summary       = %q{Trino client library}
+  gem.description   = "Trino client library"
+  gem.summary       = "Trino client library"
   gem.homepage      = "https://github.com/treasure-data/trino-client-ruby"
   gem.license       = "Apache-2.0"
 
-  gem.files         = ['lib/trino-client-ruby.rb']
+  gem.files         = ["lib/trino-client-ruby.rb"]
   gem.require_paths = ["lib"]
 
   gem.required_ruby_version = ">= 1.9.1"

data/trino-client.gemspec

@@ -1,4 +1,4 @@
-require File.expand_path 'lib/trino/client/version', File.dirname(__FILE__)
+require File.expand_path "lib/trino/client/version", File.dirname(__FILE__)
 
 Gem::Specification.new do |gem|
   gem.name          = "trino-client"
@@ -6,25 +6,27 @@ Gem::Specification.new do |gem|
 
   gem.authors       = ["Sadayuki Furuhashi"]
   gem.email         = ["sf@treasure-data.com"]
-  gem.description   = %q{Trino client library}
-  gem.summary       = %q{Trino client library}
+  gem.description   = "Trino client library"
+  gem.summary       = "Trino client library"
   gem.homepage      = "https://github.com/treasure-data/trino-client-ruby"
   gem.license       = "Apache-2.0"
 
   gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.require_paths = ["lib"]
 
-  gem.required_ruby_version = ">= 1.9.1"
+  gem.required_ruby_version = ">= 2.7.0"
 
-  gem.add_dependency "faraday", ["~> 1.0"]
-  gem.add_dependency "faraday_middleware", ["~> 1.0"]
-    gem.add_dependency "msgpack", [">= 0.7.0"]
+  gem.add_dependency "faraday", ">= 1", "< 3"
+  gem.add_dependency "faraday-gzip", ">= 1"
+  gem.add_dependency "faraday-follow_redirects", ">= 0.3"
+  gem.add_dependency "msgpack", [">= 1.5.1"]
 
-  gem.add_development_dependency "rake", [">= 0.9.2", "< 11.0"]
-  gem.add_development_dependency "rspec", ["~> 2.13.0"]
+  gem.add_development_dependency "rake", [">= 0.9.2", "< 14.0"]
+  gem.add_development_dependency "rspec", "~> 3.12.0"
   gem.add_development_dependency "webmock", ["~> 3.0"]
-  gem.add_development_dependency "addressable", ["~> 2.4.0"] # 2.5.0 doesn't support Ruby 1.9.3
-  gem.add_development_dependency "simplecov", ["~> 0.10.0"]
+  gem.add_development_dependency "addressable", "~> 2.8.1" # 2.5.0 doesn't support Ruby 1.9.3
+  gem.add_development_dependency "simplecov", "~> 0.22.0"
+  gem.add_development_dependency "standard", "~> 1.24.3"
+  gem.add_development_dependency "psych", "~> 3"
 end