lint fixed

Author: cryptomail

lib/zendesk_api/client.rb

@@ -183,7 +183,7 @@ def build_connection
         set_authentication(builder, config)
 
         if config.cache
-          builder.use ZendeskAPI::Middleware::Request::EtagCache, { :cache => config.cache, :instrumentation => config.instrumentation }
+          builder.use ZendeskAPI::Middleware::Request::EtagCache, {cache: config.cache, instrumentation: config.instrumentation}
         end
 
         builder.use ZendeskAPI::Middleware::Request::Upload
@@ -193,10 +193,10 @@ def build_connection
         # Should always be first in the stack
         if config.retry
           builder.use ZendeskAPI::Middleware::Request::Retry,
-                      :logger => config.logger,
-                      :retry_codes => config.retry_codes,
-                      :retry_on_exception => config.retry_on_exception,
-                      :instrumentation => config.instrumentation
+            logger: config.logger,
+            retry_codes: config.retry_codes,
+            retry_on_exception: config.retry_on_exception,
+            instrumentation: config.instrumentation
         end
         if config.raise_error_when_rate_limited
           builder.use ZendeskAPI::Middleware::Request::RaiseRateLimited, logger: config.logger

lib/zendesk_api/middleware/request/etag_cache.rb

@@ -1,5 +1,5 @@
 require "faraday/middleware"
-require 'active_support/notifications'
+require "active_support/notifications"
 
 module ZendeskAPI
   module Middleware
@@ -44,17 +44,17 @@ def call(environment)
                 content_encoding: cached[:response_headers][:content_encoding]
               )
               @instrumentation&.instrument("zendesk.cache_hit",
-                                           {
-                                             endpoint: env[:url].path,
-                                             status: env[:status]
-                                           })
+                {
+                  endpoint: env[:url].path,
+                  status: env[:status]
+                })
             elsif env[:status] == 200 && env[:response_headers]["Etag"] # modified and cacheable
               @cache.write(cache_key(env), env.to_hash)
               @instrumentation&.instrument("zendesk.cache_miss",
-                                           {
-                                             endpoint: env[:url].path,
-                                             status: env[:status]
-                                           })
+                {
+                  endpoint: env[:url].path,
+                  status: env[:status]
+                })
             end
           end
         end

lib/zendesk_api/middleware/request/retry.rb

@@ -13,8 +13,8 @@ class Retry < Faraday::Middleware
         def initialize(app, options = {})
           super(app)
           @logger = options[:logger]
-          @error_codes = options.key?(:retry_codes) && options[:retry_codes] ? options[:retry_codes] : DEFAULT_ERROR_CODES
-          @retry_on_exception = options.key?(:retry_on_exception) && options[:retry_on_exception] ? options[:retry_on_exception] : false
+          @error_codes = (options.key?(:retry_codes) && options[:retry_codes]) ? options[:retry_codes] : DEFAULT_ERROR_CODES
+          @retry_on_exception = (options.key?(:retry_on_exception) && options[:retry_on_exception]) ? options[:retry_on_exception] : false
           @instrumentation = options[:instrumentation]
         end
 
@@ -29,7 +29,7 @@ def call(env)
           if @retry_on_exception
             begin
               response = @app.call(env)
-            rescue StandardError => ex
+            rescue => ex
               exception_happened = true
               exception = ex
             end
@@ -42,7 +42,7 @@ def call(env)
             original_env[:call_attempt] += 1
             seconds_left = DEFAULT_RETRY_AFTER.to_i
             @logger.warn "An exception happened, waiting #{seconds_left} seconds... #{exception}" if @logger
-            instrument_retry(original_env, 'exception', seconds_left)
+            instrument_retry(original_env, "exception", seconds_left)
             sleep_with_logging(seconds_left)
             return @app.call(original_env)
           end
@@ -52,7 +52,7 @@ def call(env)
             original_env[:call_attempt] += 1
             seconds_left = (response.env[:response_headers][:retry_after] || DEFAULT_RETRY_AFTER).to_i
             @logger.warn "You may have been rate limited. Retrying in #{seconds_left} seconds..." if @logger
-            instrument_retry(original_env, response.env[:status] == 429 ? 'rate_limited' : 'server_error', seconds_left)
+            instrument_retry(original_env, (response.env[:status] == 429) ? "rate_limited" : "server_error", seconds_left)
             sleep_with_logging(seconds_left)
             response = @app.call(original_env)
           end

lib/zendesk_api/middleware/response/zendesk_request_event.rb

@@ -18,19 +18,19 @@ def call(env)
             instrumentation = @client.config.instrumentation
             if instrumentation
               instrumentation.instrument("zendesk.request",
-                                         { duration: duration,
-                                           endpoint: response_env[:url].path,
-                                           method: response_env[:method],
-                                           status: response_env[:status] })
+                {duration: duration,
+                 endpoint: response_env[:url].path,
+                 method: response_env[:method],
+                 status: response_env[:status]})
               if response_env[:status] < 500
                 instrumentation.instrument("zendesk.rate_limit",
-                                           {
-                                             endpoint: response_env[:url].path,
-                                             status: response_env[:status],
-                                             threshold: response_env[:response_headers] ? response_env[:response_headers]['X-Rate-Limit-Remaining'] : nil,
-                                             limit: response_env[:response_headers] ? response_env[:response_headers]['X-Rate-Limit'] : nil,
-                                             reset: response_env[:response_headers] ? response_env[:response_headers]['X-Rate-Limit-Reset'] : nil
-                                           })
+                  {
+                    endpoint: response_env[:url].path,
+                    status: response_env[:status],
+                    threshold: response_env[:response_headers] ? response_env[:response_headers]["X-Rate-Limit-Remaining"] : nil,
+                    limit: response_env[:response_headers] ? response_env[:response_headers]["X-Rate-Limit"] : nil,
+                    reset: response_env[:response_headers] ? response_env[:response_headers]["X-Rate-Limit-Reset"] : nil
+                  })
               end
             end
           end

spec/core/middleware/request/etag_cache_spec.rb

@@ -1,5 +1,5 @@
-require 'core/spec_helper'
-require 'active_support/cache'
+require "core/spec_helper"
+require "active_support/cache"
 
 describe ZendeskAPI::Middleware::Request::EtagCache do
   it "caches" do
@@ -36,10 +36,10 @@
         url: URI("https://example.zendesk.com/api/v2/blergh"),
         method: :get,
         request_headers: {},
-        response_headers: { "Etag" => "x", x_rate_limit_remaining: 10 },
+        response_headers: {"Etag" => "x", :x_rate_limit_remaining => 10},
         status: status,
-        body: { "x" => 1 },
-        response_body: { "x" => 1 }
+        body: {"x" => 1},
+        response_body: {"x" => 1}
       }
     end
     let(:no_instrumentation_middleware) do

spec/core/middleware/request/retry_spec.rb

@@ -128,59 +128,59 @@ def runtime
       client.config.instrumentation = instrumentation
       # Inject instrumentation into middleware instance
       allow_any_instance_of(ZendeskAPI::Middleware::Request::Retry).to receive(:instrumentation).and_return(instrumentation)
-      stub_request(:get, %r{instrumented}).to_return(:status => 429, :headers => { :retry_after => 1 }).to_return(:status => 200)
+      stub_request(:get, %r{instrumented}).to_return(status: 429, headers: {retry_after: 1}).to_return(status: 200)
     end
 
     it "calls instrumentation on retry" do
       expect(instrumentation).to receive(:instrument).with(
         "zendesk.retry",
-        hash_including(:attempt => 1, :endpoint => anything, :method => anything, :reason => anything, :delay => anything)
+        hash_including(attempt: 1, endpoint: anything, method: anything, reason: anything, delay: anything)
       ).at_least(:once)
       client.connection.get("instrumented")
     end
 
     it "calls instrumentation on second retry attempt" do
       # Override stub for this test to force two rate limit responses before success
-      stub_request(:get, %r{instrumented_twice}).
-        to_return(:status => 429, :headers => { :retry_after => 0 }).
-        to_return(:status => 429, :headers => { :retry_after => 0 }).
-        to_return(:status => 200)
+      stub_request(:get, %r{instrumented_twice})
+        .to_return(status: 429, headers: {retry_after: 0})
+        .to_return(status: 429, headers: {retry_after: 0})
+        .to_return(status: 200)
 
       # Expect instrumentation for attempt 1 and attempt 2
       expect(instrumentation).to receive(:instrument).with(
         "zendesk.retry",
-        hash_including(:attempt => 1, :endpoint => anything, :method => anything, :reason => 'rate_limited', :delay => anything)
+        hash_including(attempt: 1, endpoint: anything, method: anything, reason: "rate_limited", delay: anything)
       ).at_least(:once)
       expect(instrumentation).to receive(:instrument).with(
         "zendesk.retry",
-        hash_including(:attempt => 2, :endpoint => anything, :method => anything, :reason => 'rate_limited', :delay => anything)
+        hash_including(attempt: 2, endpoint: anything, method: anything, reason: "rate_limited", delay: anything)
       ).at_least(:once)
 
       client.connection.get("instrumented_twice")
     end
 
     it "calls instrumentation  with first attempt server error, and rate limited on second retry attempt" do
       # Override stub for this test to force two rate limit responses before success
-      stub_request(:get, %r{instrumented_twice}).
-        to_return(:status => 503, :headers => { :retry_after => 0 }).
-        to_return(:status => 429, :headers => { :retry_after => 0 }).
-        to_return(:status => 200)
+      stub_request(:get, %r{instrumented_twice})
+        .to_return(status: 503, headers: {retry_after: 0})
+        .to_return(status: 429, headers: {retry_after: 0})
+        .to_return(status: 200)
 
       # Expect instrumentation for attempt 1 and attempt 2
       expect(instrumentation).to receive(:instrument).with(
         "zendesk.retry",
-        hash_including(:attempt => 1, :endpoint => anything, :method => anything, :reason => 'server_error', :delay => anything)
+        hash_including(attempt: 1, endpoint: anything, method: anything, reason: "server_error", delay: anything)
       ).at_least(:once)
       expect(instrumentation).to receive(:instrument).with(
         "zendesk.retry",
-        hash_including(:attempt => 2, :endpoint => anything, :method => anything, :reason => 'rate_limited', :delay => anything)
+        hash_including(attempt: 2, endpoint: anything, method: anything, reason: "rate_limited", delay: anything)
       ).at_least(:once)
 
       client.connection.get("instrumented_twice")
     end
 
     it "does not call instrumentation when no retry occurs" do
-      stub_request(:get, %r{no_retry}).to_return(:status => 200)
+      stub_request(:get, %r{no_retry}).to_return(status: 200)
       expect(instrumentation).not_to receive(:instrument).with(
         "zendesk.retry",
         hash_including(:attempt, :endpoint, :method, :reason, :delay)

spec/core/middleware/response/zendesk_request_event_spec.rb

@@ -1,24 +1,24 @@
-require_relative '../../../spec_helper'
-require 'faraday'
-require 'zendesk_api/middleware/response/zendesk_request_event'
+require_relative "../../../spec_helper"
+require "faraday"
+require "zendesk_api/middleware/response/zendesk_request_event"
 
 RSpec.describe ZendeskAPI::Middleware::Response::ZendeskRequestEvent do
-  let(:instrumentation) { double('Instrumentation') }
+  let(:instrumentation) { double("Instrumentation") }
   let(:client) do
-    double('Client', config: double('Config', instrumentation: instrumentation))
+    double("Client", config: double("Config", instrumentation: instrumentation))
   end
   let(:app) { ->(env) { Faraday::Response.new(env) } }
   let(:middleware) { described_class.new(app, client) }
   let(:response_headers) do
     {
-      'X-Rate-Limit-Remaining': 10,
-      'X-Rate-Limit': 100,
-      'X-Rate-Limit-Reset': 1234567890
+      "X-Rate-Limit-Remaining": 10,
+      "X-Rate-Limit": 100,
+      "X-Rate-Limit-Reset": 1234567890
     }
   end
   let(:env) do
     {
-      url: URI('https://example.zendesk.com/api/v2/tickets'),
+      url: URI("https://example.zendesk.com/api/v2/tickets"),
       method: :get,
       status: status,
       response_headers: response_headers
@@ -29,57 +29,57 @@
     allow(instrumentation).to receive(:instrument)
   end
 
-  context 'when the response status is less than 500' do
+  context "when the response status is less than 500" do
     let(:status) { 200 }
 
-    it 'instruments zendesk.request and zendesk.rate_limit' do
+    it "instruments zendesk.request and zendesk.rate_limit" do
       expect(instrumentation).to receive(:instrument).with(
-        'zendesk.request',
-        hash_including(:duration, endpoint: '/api/v2/tickets', method: :get, status: 200)
+        "zendesk.request",
+        hash_including(:duration, endpoint: "/api/v2/tickets", method: :get, status: 200)
       )
       expect(instrumentation).to receive(:instrument).with(
-        'zendesk.rate_limit',
-        hash_including(endpoint: '/api/v2/tickets', status: 200)
+        "zendesk.rate_limit",
+        hash_including(endpoint: "/api/v2/tickets", status: 200)
       )
       middleware.call(env).on_complete { |_response_env| 1 }
     end
   end
 
-  context 'when the response status is 500 or greater' do
+  context "when the response status is 500 or greater" do
     let(:status) { 500 }
 
-    it 'instruments only zendesk.request' do
+    it "instruments only zendesk.request" do
       expect(instrumentation).to receive(:instrument).with(
-        'zendesk.request',
-        hash_including(:duration, endpoint: '/api/v2/tickets', method: :get, status: 500)
+        "zendesk.request",
+        hash_including(:duration, endpoint: "/api/v2/tickets", method: :get, status: 500)
       )
-      expect(instrumentation).not_to receive(:instrument).with('zendesk.rate_limit', anything)
+      expect(instrumentation).not_to receive(:instrument).with("zendesk.rate_limit", anything)
       middleware.call(env).on_complete { |_response_env| 1 }
     end
   end
 
-  context 'duration calculation' do
+  context "duration calculation" do
     let(:status) { 201 }
 
-    it 'passes a positive duration to instrumentation' do
+    it "passes a positive duration to instrumentation" do
       expect(instrumentation).to receive(:instrument) do |event, payload|
-        if event == 'zendesk.request'
+        if event == "zendesk.request"
           expect(payload[:duration]).to be > 0
         end
       end
-      expect(instrumentation).to receive(:instrument).with('zendesk.rate_limit', anything)
+      expect(instrumentation).to receive(:instrument).with("zendesk.rate_limit", anything)
       middleware.call(env).on_complete { |_response_env| 1 }
     end
   end
 
-  context 'when instrumentation is nil' do
+  context "when instrumentation is nil" do
     let(:status) { 200 }
     let(:client) do
-      double('Client', config: double('Config', instrumentation: nil))
+      double("Client", config: double("Config", instrumentation: nil))
     end
     let(:middleware) { described_class.new(app, client) }
 
-    it 'does not raise an error' do
+    it "does not raise an error" do
       expect { middleware.call(env).on_complete { |_response_env| 1 } }.not_to raise_error
     end
   end

spec/spec_helper.rb

@@ -1,4 +1,4 @@
-require 'rspec'
+require "rspec"
 
 RSpec.configure do |config|
   config.expect_with :rspec do |c|