Switch http client to typhoeus (libcurl wrapper), fix linting issues, added guard

Author: jasonbosco

.rubocop.yml

@@ -1,34 +1,39 @@
-inherit_from: .rubocop_todo.yml
-
-require: rubocop-rspec
-
 AllCops:
-  TargetRubyVersion: "2.4"
   NewCops: enable
 
-Metrics/BlockLength:
-  Exclude:
-    - 'spec/**/*'
-    - 'Gemfile'
-    - 'typesense.gemspec'
-
 Style/Documentation:
   Enabled: false
 
-RSpec/ExampleLength:
+Metrics/AbcSize:
   Enabled: false
 
-Metrics/MethodLength:
+Metrics/CyclomaticComplexity:
   Enabled: false
 
-Metrics/AbcSize:
+Metrics/PerceivedComplexity:
   Enabled: false
 
 Metrics/ClassLength:
   Enabled: false
 
-Metrics/CyclomaticComplexity:
+Metrics/ParameterLists:
   Enabled: false
 
-Metrics/PerceivedComplexity:
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/BlockLength:
   Enabled: false
+
+Metrics/BlockNesting:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  EnforcedStyle: always_true
+
+Layout/LineLength:
+  Max: 300
+
+Lint/SuppressedException:
+  Exclude:
+    - examples/**

.rubocop_todo.yml

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exist?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard :rubocop, cli: '-a' do
+  watch(/.+\.rb$/)
+  watch(%r{(?:.+/)?\.rubocop(?:_todo)?\.yml$}) { |m| File.dirname(m[0]) }
+end

Guardfile

@@ -2,6 +2,7 @@
 
 require_relative '../lib/typesense'
 require 'awesome_print'
+require 'logger'
 
 AwesomePrint.defaults = {
   indent: -2
@@ -62,6 +63,6 @@
   healthcheck_interval_seconds: 1,
   retry_interval_seconds: 0.01,
   connection_timeout_seconds: 10,
-  logger: Logger.new(STDOUT),
+  logger: Logger.new($stdout),
   log_level: Logger::DEBUG
 )

examples/client_initialization.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-require 'httparty'
+require 'typhoeus'
+require 'oj'
 
 module Typesense
   class ApiCall
-    include HTTParty
-
     API_KEY_HEADER_NAME = 'X-TYPESENSE-API-KEY'
 
     def initialize(configuration)
@@ -30,38 +29,38 @@ def post(endpoint, parameters = {})
 
       perform_request :post,
                       endpoint,
-                      body: body,
-                      headers: default_headers.merge(headers)
+                      headers,
+                      body: body
     end
 
     def put(endpoint, parameters = {})
       headers, body = extract_headers_and_body_from(parameters)
 
       perform_request :put,
                       endpoint,
-                      body: body,
-                      headers: default_headers.merge(headers)
+                      headers,
+                      body: body
     end
 
     def get(endpoint, parameters = {})
       headers, query = extract_headers_and_query_from(parameters)
 
       perform_request :get,
                       endpoint,
-                      query: query,
-                      headers: default_headers.merge(headers)
+                      headers,
+                      params: query
     end
 
     def delete(endpoint, parameters = {})
       headers, query = extract_headers_and_query_from(parameters)
 
       perform_request :delete,
                       endpoint,
-                      query: query,
-                      headers: default_headers.merge(headers)
+                      headers,
+                      params: query
     end
 
-    def perform_request(method, endpoint, options = {})
+    def perform_request(method, endpoint, headers = {}, options = {})
       @configuration.validate!
       last_exception = nil
       @logger.debug "Performing #{method.to_s.upcase} request: #{endpoint}"
@@ -71,24 +70,31 @@ def perform_request(method, endpoint, options = {})
         @logger.debug "Attempting #{method.to_s.upcase} request Try ##{num_tries} to Node #{node[:index]}"
 
         begin
-          response_object = self.class.send(method,
-                                            uri_for(endpoint, node),
-                                            default_options.merge(options))
-          response_code = response_object.response.code.to_i
-          set_node_healthcheck(node, is_healthy: true) if response_code >= 1 && response_code <= 499
-
-          @logger.debug "Request to Node #{node[:index]} was successfully made (at the network layer). Response Code was #{response_code}."
+          response = Typhoeus::Request.new(uri_for(endpoint, node),
+                                           {
+                                             method: method,
+                                             headers: default_headers.merge(headers),
+                                             timeout: @connection_timeout_seconds
+                                           }.merge(options)).run
+          set_node_healthcheck(node, is_healthy: true) if response.code >= 1 && response.code <= 499
+
+          @logger.debug "Request to Node #{node[:index]} was successfully made (at the network layer). Response Code was #{response.code}."
+
+          parsed_response = if response.headers && (response.headers['content-type'] || '').include?('application/json')
+                              Oj.load(response.body)
+                            else
+                              response.body
+                            end
 
           # If response is 2xx return the object, else raise the response as an exception
-          return response_object.parsed_response if response_object.response.code_type <= Net::HTTPSuccess # 2xx
+          return parsed_response if response.code >= 200 && response.code <= 299
 
-          exception_message = (response_object.parsed_response && response_object.parsed_response['message']) || 'Error'
-          raise custom_exception_klass_for(response_object.response), exception_message
-        rescue SocketError, Net::ReadTimeout, Net::OpenTimeout,
-               EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError,
+          exception_message = (parsed_response && parsed_response['message']) || 'Error'
+          raise custom_exception_klass_for(response), exception_message
+        rescue SocketError, EOFError,
                Errno::EINVAL, Errno::ENETDOWN, Errno::ENETUNREACH, Errno::ENETRESET, Errno::ECONNABORTED, Errno::ECONNRESET,
                Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::EHOSTDOWN, Errno::EHOSTUNREACH,
-               Timeout::Error, HTTParty::ResponseError, Typesense::Error::ServerError, Typesense::Error::HTTPStatus0Error => e
+               Typesense::Error::TimeoutError, Typesense::Error::ServerError, Typesense::Error::HTTPStatus0Error => e
           # Rescue network layer exceptions and HTTP 5xx errors, so the loop can continue.
           # Using loops for retries instead of rescue...retry to maintain consistency with client libraries in
           #   other languages that might not support the same construct.
@@ -108,7 +114,7 @@ def perform_request(method, endpoint, options = {})
     def extract_headers_and_body_from(parameters)
       if json_request?(parameters)
         headers = { 'Content-Type' => 'application/json' }
-        body = sanitize_parameters(parameters).to_json
+        body = Oj.dump(sanitize_parameters(parameters))
       else
         headers = {}
         body = parameters[:body]
@@ -199,35 +205,31 @@ def set_node_healthcheck(node, is_healthy:)
     end
 
     def custom_exception_klass_for(response)
-      response_code_type = response.code_type
-      if response_code_type <= Net::HTTPBadRequest # 400
+      if response.code == 400
         Typesense::Error::RequestMalformed
-      elsif response_code_type <= Net::HTTPUnauthorized # 401
+      elsif response.code == 401
         Typesense::Error::RequestUnauthorized
-      elsif response_code_type <= Net::HTTPNotFound # 404
+      elsif response.code == 404
         Typesense::Error::ObjectNotFound
-      elsif response_code_type <= Net::HTTPConflict # 409
+      elsif response.code == 409
         Typesense::Error::ObjectAlreadyExists
-      elsif response_code_type <= Net::HTTPUnprocessableEntity # 422
+      elsif response.code == 422
         Typesense::Error::ObjectUnprocessable
-      elsif response_code_type <= Net::HTTPServerError # 5xx
+      elsif response.code >= 500 && response.code <= 599
         Typesense::Error::ServerError
-      elsif response.code.to_i.zero?
+      elsif response.timed_out?
+        Typesense::Error::TimeoutError
+      elsif response.code.zero?
         Typesense::Error::HTTPStatus0Error
       else
         Typesense::Error::HTTPError
       end
     end
 
-    def default_options
-      {
-        timeout: @connection_timeout_seconds
-      }
-    end
-
     def default_headers
       {
-        API_KEY_HEADER_NAME.to_s => @api_key
+        API_KEY_HEADER_NAME.to_s => @api_key,
+        'User-Agent' => 'Typesense Ruby Client'
       }
     end
   end

lib/typesense/api_call.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'logger'
+
 module Typesense
   class Configuration
     attr_accessor :nodes, :nearest_node, :connection_timeout_seconds, :healthcheck_interval_seconds, :num_retries, :retry_interval_seconds, :api_key, :logger, :log_level
@@ -13,7 +15,7 @@ def initialize(options = {})
       @retry_interval_seconds = options[:retry_interval_seconds] || 0.1
       @api_key = options[:api_key]
 
-      @logger = options[:logger] || Logger.new(STDOUT)
+      @logger = options[:logger] || Logger.new($stdout)
       @log_level = options[:log_level] || Logger::WARN
       @logger.level = @log_level
 

lib/typesense/configuration.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'oj'
+
 module Typesense
   class Documents
     RESOURCE_PATH = '/documents'
@@ -15,7 +17,7 @@ def create(document)
     end
 
     def create_many(documents)
-      documents_in_jsonl_format = documents.map { |document| JSON.dump(document) }.join("\n")
+      documents_in_jsonl_format = documents.map { |document| Oj.dump(document) }.join("\n")
       import(documents_in_jsonl_format)
     end
 
@@ -38,7 +40,7 @@ def [](document_id)
     private
 
     def endpoint_path(operation = nil)
-      "#{Collections::RESOURCE_PATH}/#{@collection_name}#{Documents::RESOURCE_PATH}#{operation.nil? ? '' : '/' + operation}"
+      "#{Collections::RESOURCE_PATH}/#{@collection_name}#{Documents::RESOURCE_PATH}#{operation.nil? ? '' : "/#{operation}"}"
     end
   end
 end

lib/typesense/documents.rb

@@ -26,6 +26,9 @@ class ServerError < Error
     class HTTPStatus0Error < Error
     end
 
+    class TimeoutError < Error
+    end
+
     class NoMethodError < ::NoMethodError
     end
 

lib/typesense/error.rb

@@ -25,7 +25,7 @@ def [](override_id)
     private
 
     def endpoint_path(operation = nil)
-      "#{Collections::RESOURCE_PATH}/#{@collection_name}#{Overrides::RESOURCE_PATH}#{operation.nil? ? '' : '/' + operation}"
+      "#{Collections::RESOURCE_PATH}/#{@collection_name}#{Overrides::RESOURCE_PATH}#{operation.nil? ? '' : "/#{operation}"}"
     end
   end
 end

lib/typesense/overrides.rb

@@ -4,10 +4,10 @@
 require_relative 'shared_configuration_context'
 
 describe Typesense::Alias do
-  include_context 'with Typesense configuration'
-
   subject(:books_alias) { typesense.aliases['books'] }
 
+  include_context 'with Typesense configuration'
+
   describe '#retrieve' do
     it 'returns the specified alias' do
       stub_request(:get, Typesense::ApiCall.new(typesense.configuration).send(:uri_for, '/aliases/books', typesense.configuration.nodes[0]))

spec/typesense/alias_spec.rb

@@ -4,10 +4,10 @@
 require_relative 'shared_configuration_context'
 
 describe Typesense::Aliases do
-  include_context 'with Typesense configuration'
-
   subject(:aliases) { typesense.aliases }
 
+  include_context 'with Typesense configuration'
+
   describe '#upsert' do
     it 'upserts an alias and returns it' do
       stub_request(:put, Typesense::ApiCall.new(typesense.configuration).send(:uri_for, '/aliases/books', typesense.configuration.nodes[0]))