fix rubocop and test errors/warnings

Author: UmanShahzad

.rubocop.yml

@@ -9,6 +9,9 @@ Layout/LineLength:
     Enabled: true
     Max: 80
 
+Lint/MissingSuper:
+    Enabled: false
+
 Metrics/MethodLength:
     Enabled: false
 
@@ -18,7 +21,19 @@ Metrics/AbcSize:
 Lint/DuplicateMethods:
     Enabled: false
 
+Style/Documentation:
+    Enabled: false
+
+Style/ClassAndModuleChildren:
+    Enabled: false
+
 Style/MethodCallWithArgsParentheses:
+    EnforcedStyle: require_parentheses
+    IgnoreMacros: false
+    IgnoredPatterns: []
     AllowParenthesesInMultilineCall: true
     AllowParenthesesInChaining: true
     AllowParenthesesInCamelCaseMethod: true
+
+Style/MethodCallWithoutArgsParentheses:
+    Enabled: false

lib/ipinfo.rb

@@ -22,76 +22,77 @@ def create(access_token = nil, settings = {})
             IPinfo.new(access_token, settings)
         end
     end
+end
 
-    class IPinfo
-        attr_accessor :access_token, :countries, :http_client
-
-        def initialize(access_token = nil, settings = {})
-            @access_token = access_token
-            @http_client = http_client(settings.fetch('http_client', nil))
+class IPinfo::IPinfo
+    include IPinfo
+    attr_accessor :access_token, :countries, :httpc
 
-            maxsize = settings.fetch('maxsize', DEFAULT_CACHE_MAXSIZE)
-            ttl = settings.fetch('ttl', DEFAULT_CACHE_TTL)
-            @cache = settings.fetch('cache', DefaultCache.new(ttl, maxsize))
-            @countries = countries(settings.fetch('countries',
-                                                  DEFAULT_COUNTRY_FILE))
-        end
+    def initialize(access_token = nil, settings = {})
+        @access_token = access_token
+        @httpc = prepare_http_client(settings.fetch('http_client', nil))
 
-        def details(ip_address = nil)
-            details = request_details(ip_address)
-            if details.key? :country
-                details[:country_name] =
-                    @countries.fetch(details.fetch(:country), nil)
-            end
+        maxsize = settings.fetch('maxsize', DEFAULT_CACHE_MAXSIZE)
+        ttl = settings.fetch('ttl', DEFAULT_CACHE_TTL)
+        @cache = settings.fetch('cache', DefaultCache.new(ttl, maxsize))
+        @countries = prepare_countries(settings.fetch('countries',
+                                                      DEFAULT_COUNTRY_FILE))
+    end
 
-            if details.key? :ip
-                details[:ip_address] =
-                    IPAddr.new(details.fetch(:ip))
-            end
+    def details(ip_address = nil)
+        details = request_details(ip_address)
+        if details.key? :country
+            details[:country_name] =
+                @countries.fetch(details.fetch(:country), nil)
+        end
 
-            if details.key? :loc
-                loc = details.fetch(:loc).split(',')
-                details[:latitude] = loc[0]
-                details[:longitude] = loc[1]
-            end
+        if details.key? :ip
+            details[:ip_address] =
+                IPAddr.new(details.fetch(:ip))
+        end
 
-            Response.new(details)
+        if details.key? :loc
+            loc = details.fetch(:loc).split(',')
+            details[:latitude] = loc[0]
+            details[:longitude] = loc[1]
         end
 
-        protected
+        Response.new(details)
+    end
 
-        def request_details(ip_address = nil)
-            unless @cache.contains?(ip_address)
-                response = @http_client.get(escape_path(ip_address))
+    protected
 
-                if response.status.eql?(429)
-                    raise RateLimitError,
-                          RATE_LIMIT_MESSAGE
-                end
+    def request_details(ip_address = nil)
+        unless @cache.contains?(ip_address)
+            response = @httpc.get(escape_path(ip_address))
 
-                details = JSON.parse(response.body, symbolize_names: true)
-                @cache.set(ip_address, details)
+            if response.status.eql?(429)
+                raise RateLimitError,
+                      RATE_LIMIT_MESSAGE
             end
-            @cache.get(ip_address)
-        end
 
-        def http_client(http_client = nil)
-            @http_client = if http_client
-                               Adapter.new(access_token, http_client)
-                           else
-                               Adapter.new(access_token)
-                           end
+            details = JSON.parse(response.body, symbolize_names: true)
+            @cache.set(ip_address, details)
         end
+        @cache.get(ip_address)
+    end
 
-        def countries(filename)
-            file = File.read(filename)
-            JSON.parse(file)
-        end
+    def prepare_http_client(httpc = nil)
+        @httpc = if httpc
+                     Adapter.new(access_token, httpc)
+                 else
+                     Adapter.new(access_token)
+                 end
+    end
+
+    def prepare_countries(filename)
+        file = File.read(filename)
+        JSON.parse(file)
+    end
 
-        private
+    private
 
-        def escape_path(ip)
-            ip ? "/#{CGI.escape(ip)}" : '/'
-        end
+    def escape_path(ip)
+        ip ? "/#{CGI.escape(ip)}" : '/'
     end
 end

lib/ipinfo/adapter.rb

@@ -2,44 +2,43 @@
 
 require 'faraday'
 require 'cgi'
+require 'ipinfo/mod'
 
-module IPinfo
-    class Adapter
-        HOST = 'ipinfo.io'
+class IPinfo::Adapter
+    HOST = 'ipinfo.io'
 
-        attr_reader :conn
+    attr_reader :conn
 
-        def initialize(token = nil, adapter = :net_http)
-            @token = token
-            @conn = connection(adapter)
-        end
+    def initialize(token = nil, adapter = :net_http)
+        @token = token
+        @conn = connection(adapter)
+    end
 
-        def get(uri)
-            @conn.get(uri) do |req|
-                default_headers.each_pair do |key, value|
-                    req.headers[key] = value
-                end
-                req.params['token'] = CGI.escape(token) if token
+    def get(uri)
+        @conn.get(uri) do |req|
+            default_headers.each_pair do |key, value|
+                req.headers[key] = value
             end
+            req.params['token'] = CGI.escape(token) if token
         end
+    end
 
-        private
+    private
 
-        attr_reader :token
+    attr_reader :token
 
-        def connection(adapter)
-            Faraday.new(url: "https://#{HOST}") do |faraday|
-                faraday.adapter adapter
-            end
+    def connection(adapter)
+        Faraday.new(url: "https://#{HOST}") do |conn|
+            conn.adapter(adapter)
         end
+    end
 
-        def default_headers
-            headers = {
-                'User-Agent' => 'IPinfoClient/Ruby/1.0',
-                'Accept' => 'application/json'
-            }
-            headers['Authorization'] = "Bearer #{CGI.escape(token)}" if token
-            headers
-        end
+    def default_headers
+        headers = {
+            'User-Agent' => 'IPinfoClient/Ruby/1.0',
+            'Accept' => 'application/json'
+        }
+        headers['Authorization'] = "Bearer #{CGI.escape(token)}" if token
+        headers
     end
 end

lib/ipinfo/cache/cache_interface.rb

@@ -1,19 +1,17 @@
 # frozen_string_literal: true
 
-module IPinfo
-    class CacheInterface
-        class InterfaceNotImplemented < StandardError; end
+class IPinfo::CacheInterface
+    class InterfaceNotImplemented < StandardError; end
 
-        def get(_key)
-            raise InterfaceNotImplemented
-        end
+    def get(_key)
+        raise InterfaceNotImplemented
+    end
 
-        def set(_key, _value)
-            raise InterfaceNotImplemented
-        end
+    def set(_key, _value)
+        raise InterfaceNotImplemented
+    end
 
-        def contains?(_key)
-            raise InterfaceNotImplemented
-        end
+    def contains?(_key)
+        raise InterfaceNotImplemented
     end
 end

lib/ipinfo/cache/default_cache.rb

@@ -3,23 +3,20 @@
 require 'ipinfo/cache/cache_interface'
 require 'lru_redux'
 
-module IPinfo
-    class DefaultCache < CacheInterface
-        def initialize(ttl, max_size)
-            super
-            @cache = LruRedux::TTL::Cache.new(max_size, ttl)
-        end
+class IPinfo::DefaultCache < IPinfo::CacheInterface
+    def initialize(ttl, max_size)
+        @cache = LruRedux::TTL::Cache.new(max_size, ttl)
+    end
 
-        def get(key)
-            @cache[key]
-        end
+    def get(key)
+        @cache[key]
+    end
 
-        def set(key, value)
-            @cache[key] = value
-        end
+    def set(key, value)
+        @cache[key] = value
+    end
 
-        def contains?(key)
-            !@cache[key].nil?
-        end
+    def contains?(key)
+        !@cache[key].nil?
     end
 end

lib/ipinfo/errors.rb

@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 
-module IPinfo
-    class RateLimitError < StandardError; end
-end
+class IPinfo::RateLimitError < StandardError; end

lib/ipinfo/mod.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module IPinfo
+end

lib/ipinfo/response.rb

@@ -3,17 +3,15 @@
 require 'ipaddr'
 require 'json'
 
-module IPinfo
-    class Response
-        attr_reader :all
+class IPinfo::Response
+    attr_reader :all
 
-        def initialize(response)
-            @all = response
+    def initialize(response)
+        @all = response
 
-            @all.each do |name, value|
-                instance_variable_set("@#{name}", value)
-                self.class.send(:attr_accessor, name)
-            end
+        @all.each do |name, value|
+            instance_variable_set("@#{name}", value)
+            self.class.send(:attr_accessor, name)
         end
     end
 end