algolia 3.0.0.beta.8 → 3.0.0.beta.9

data/lib/algolia/api/usage_client.rb

@@ -5,9 +5,9 @@ module Algolia
     attr_accessor :api_client
 
     def initialize(config = nil)
-      raise '`config` is missing.' if config.nil?
-      raise '`app_id` is missing.' if config.app_id.nil? || config.app_id == ''
-      raise '`api_key` is missing.' if config.api_key.nil? || config.api_key == ''
+      raise "`config` is missing." if config.nil?
+      raise "`app_id` is missing." if config.app_id.nil? || config.app_id == ""
+      raise "`api_key` is missing." if config.api_key.nil? || config.api_key == ""
 
       @api_client = Algolia::ApiClient.new(config)
     end
@@ -17,11 +17,14 @@ module Algolia
       hosts << Transport::StatefulHost.new("#{app_id}-dsn.algolia.net", accept: CallType::READ)
       hosts << Transport::StatefulHost.new("#{app_id}.algolia.net", accept: CallType::WRITE)
 
-      hosts += 1.upto(3).map do |i|
-        Transport::StatefulHost.new("#{app_id}-#{i}.algolianet.com", accept: CallType::READ | CallType::WRITE)
-      end.shuffle
+      hosts += 1
+        .upto(3)
+        .map do |i|
+          Transport::StatefulHost.new("#{app_id}-#{i}.algolianet.com", accept: CallType::READ | CallType::WRITE)
+        end
+        .shuffle
 
-      config = Algolia::Configuration.new(app_id, api_key, hosts, 'Usage', opts)
+      config = Algolia::Configuration.new(app_id, api_key, hosts, "Usage", opts)
       create_with_config(config)
     end
 
@@ -41,7 +44,7 @@ module Algolia
         raise ArgumentError, "Parameter `path` is required when calling `custom_delete`."
       end
 
-      path = '/{path}'.sub('{' + 'path' + '}', path.to_s)
+      path = "/{path}".sub("{" + "path" + "}", path.to_s)
       query_params = {}
       query_params = query_params.merge(parameters) unless parameters.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -51,7 +54,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'UsageClient.custom_delete',
+        :operation => :"UsageClient.custom_delete",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -69,7 +72,7 @@ module Algolia
     # @return [Object]
     def custom_delete(path, parameters = nil, request_options = {})
       response = custom_delete_with_http_info(path, parameters, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Object')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Object")
     end
 
     # This method allow you to send requests to the Algolia REST API.
@@ -84,7 +87,7 @@ module Algolia
         raise ArgumentError, "Parameter `path` is required when calling `custom_get`."
       end
 
-      path = '/{path}'.sub('{' + 'path' + '}', path.to_s)
+      path = "/{path}".sub("{" + "path" + "}", path.to_s)
       query_params = {}
       query_params = query_params.merge(parameters) unless parameters.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -94,7 +97,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'UsageClient.custom_get',
+        :operation => :"UsageClient.custom_get",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -112,7 +115,7 @@ module Algolia
     # @return [Object]
     def custom_get(path, parameters = nil, request_options = {})
       response = custom_get_with_http_info(path, parameters, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Object')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Object")
     end
 
     # This method allow you to send requests to the Algolia REST API.
@@ -128,7 +131,7 @@ module Algolia
         raise ArgumentError, "Parameter `path` is required when calling `custom_post`."
       end
 
-      path = '/{path}'.sub('{' + 'path' + '}', path.to_s)
+      path = "/{path}".sub("{" + "path" + "}", path.to_s)
       query_params = {}
       query_params = query_params.merge(parameters) unless parameters.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -138,7 +141,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(body)
 
       new_options = request_options.merge(
-        :operation => :'UsageClient.custom_post',
+        :operation => :"UsageClient.custom_post",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -157,7 +160,7 @@ module Algolia
     # @return [Object]
     def custom_post(path, parameters = nil, body = nil, request_options = {})
       response = custom_post_with_http_info(path, parameters, body, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Object')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Object")
     end
 
     # This method allow you to send requests to the Algolia REST API.
@@ -173,7 +176,7 @@ module Algolia
         raise ArgumentError, "Parameter `path` is required when calling `custom_put`."
       end
 
-      path = '/{path}'.sub('{' + 'path' + '}', path.to_s)
+      path = "/{path}".sub("{" + "path" + "}", path.to_s)
       query_params = {}
       query_params = query_params.merge(parameters) unless parameters.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -183,7 +186,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(body)
 
       new_options = request_options.merge(
-        :operation => :'UsageClient.custom_put',
+        :operation => :"UsageClient.custom_put",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -202,7 +205,7 @@ module Algolia
     # @return [Object]
     def custom_put(path, parameters = nil, body = nil, request_options = {})
       response = custom_put_with_http_info(path, parameters, body, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Object')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Object")
     end
 
     # Retrieves the selected usage statistics for one index.
@@ -214,7 +217,14 @@ module Algolia
     # @param granularity [Granularity] Granularity of the aggregated metrics.  - &#x60;hourly&#x60;: the maximum time range for hourly metrics is 7 days. - &#x60;daily&#x60;: the maximum time range for daily metrics is 365 days.  (default to 'daily')
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
-    def get_index_usage_with_http_info(statistic, index_name, start_date, end_date, granularity = nil, request_options = {})
+    def get_index_usage_with_http_info(
+      statistic,
+      index_name,
+      start_date,
+      end_date,
+      granularity = nil,
+      request_options = {}
+    )
       # verify the required parameter 'statistic' is set
       if @api_client.config.client_side_validation && statistic.nil?
         raise ArgumentError, "Parameter `statistic` is required when calling `get_index_usage`."
@@ -232,8 +242,10 @@ module Algolia
         raise ArgumentError, "Parameter `end_date` is required when calling `get_index_usage`."
       end
 
-      path = '/1/usage/{statistic}/{indexName}'.sub('{' + 'statistic' + '}', Transport.encode_uri(statistic.to_s)).sub('{' + 'indexName' + '}',
-                                                                                                                       Transport.encode_uri(index_name.to_s))
+      path = "/1/usage/{statistic}/{indexName}".sub("{" + "statistic" + "}", Transport.encode_uri(statistic.to_s)).sub(
+        "{" + "indexName" + "}",
+        Transport.encode_uri(index_name.to_s)
+      )
       query_params = {}
       query_params[:startDate] = start_date
       query_params[:endDate] = end_date
@@ -245,7 +257,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'UsageClient.get_index_usage',
+        :operation => :"UsageClient.get_index_usage",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -265,8 +277,15 @@ module Algolia
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [GetUsage200Response]
     def get_index_usage(statistic, index_name, start_date, end_date, granularity = nil, request_options = {})
-      response = get_index_usage_with_http_info(statistic, index_name, start_date, end_date, granularity, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Usage::GetUsage200Response')
+      response = get_index_usage_with_http_info(
+        statistic,
+        index_name,
+        start_date,
+        end_date,
+        granularity,
+        request_options
+      )
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Usage::GetUsage200Response")
     end
 
     # Retrieves usage statistics evaluated over a specified period.
@@ -291,7 +310,7 @@ module Algolia
         raise ArgumentError, "Parameter `end_date` is required when calling `get_usage`."
       end
 
-      path = '/1/usage/{statistic}'.sub('{' + 'statistic' + '}', Transport.encode_uri(statistic.to_s))
+      path = "/1/usage/{statistic}".sub("{" + "statistic" + "}", Transport.encode_uri(statistic.to_s))
       query_params = {}
       query_params[:startDate] = start_date
       query_params[:endDate] = end_date
@@ -303,7 +322,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'UsageClient.get_usage',
+        :operation => :"UsageClient.get_usage",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -323,7 +342,8 @@ module Algolia
     # @return [GetUsage200Response]
     def get_usage(statistic, start_date, end_date, granularity = nil, request_options = {})
       response = get_usage_with_http_info(statistic, start_date, end_date, granularity, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Usage::GetUsage200Response')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Usage::GetUsage200Response")
     end
+
   end
 end

data/lib/algolia/api_client.rb

@@ -1,5 +1,5 @@
-require 'cgi'
-require 'json'
+require "cgi"
+require "json"
 
 module Algolia
   class ApiClient
@@ -12,7 +12,7 @@ module Algolia
     # @option config [Configuration] Configuration for initializing the object, default to Configuration.default
     def initialize(config = Configuration.default)
       @config = config
-      @requester = config.requester || Http::HttpRequester.new('net_http_persistent', LoggerHelper.create)
+      @requester = config.requester || Http::HttpRequester.new("net_http_persistent", LoggerHelper.create)
       @transporter = Transport::Transport.new(config, @requester)
     end
 
@@ -28,9 +28,9 @@ module Algolia
         call_type = opts[:use_read_transporter] || http_method == :GET ? CallType::READ : CallType::WRITE
         response = transporter.request(call_type, http_method, path, opts[:body], opts)
       rescue Faraday::TimeoutError
-        raise ApiError, 'Connection timed out'
+        raise ApiError, "Connection timed out"
       rescue Faraday::ConnectionFailed
-        raise ApiError, 'Connection failed'
+        raise ApiError, "Connection failed"
       end
 
       response
@@ -44,7 +44,7 @@ module Algolia
       return nil if body.nil? || body.empty?
 
       # return response body directly for String return type
-      return body.to_s if return_type == 'String'
+      return body.to_s if return_type == "String"
 
       begin
         data = JSON.parse("[#{body}]", :symbolize_names => true)[0]
@@ -54,7 +54,7 @@ module Algolia
         data = body
       end
 
-      convert_to_type data, return_type
+      convert_to_type(data, return_type)
     end
 
     # Convert data to the given return type.
@@ -65,21 +65,21 @@ module Algolia
       return nil if data.nil?
 
       case return_type
-      when 'String'
+      when "String"
         data.to_s
-      when 'Integer'
+      when "Integer"
         data.to_i
-      when 'Float'
+      when "Float"
         data.to_f
-      when 'Boolean'
+      when "Boolean"
         data == true
-      when 'Time'
+      when "Time"
         # parse date time (expecting ISO 8601 format)
-        Time.parse data
-      when 'Date'
+        Time.parse(data)
+      when "Date"
         # parse date time (expecting ISO 8601 format)
-        Date.parse data
-      when 'Object'
+        Date.parse(data)
+      when "Object"
         # generic object (usually a Hash), return directly
         data
       when /\AArray<(.+)>\z/
@@ -103,14 +103,15 @@ module Algolia
     # @param [Object] model object to be converted into JSON string
     # @return [String] JSON string representation of the object
     def object_to_http_body(model)
-      return '{}' if model.nil?
+      return "{}" if model.nil?
       return model if model.is_a?(String)
 
       body = if model.is_a?(Array)
-               model.map { |m| object_to_hash(m) }
-             else
-               object_to_hash(model)
-             end
+        model.map { |m| object_to_hash(m) }
+      else
+        object_to_hash(model)
+      end
+
       body.to_json
     end
 
@@ -132,13 +133,13 @@ module Algolia
     def build_collection_param(param, collection_format)
       case collection_format
       when :csv
-        param.join(',')
+        param.join(",")
       when :ssv
-        param.join(' ')
+        param.join(" ")
       when :tsv
         param.join("\t")
       when :pipes
-        param.join('|')
+        param.join("|")
       when :multi
         # return the array directly as typhoeus will handle it as expected
         param

data/lib/algolia/api_error.rb

@@ -10,15 +10,15 @@ module Algolia
     #   ApiError.new(:code => 500, :response_headers => {}, :response_body => "")
     #   ApiError.new(:code => 404, :message => "Not Found")
     def initialize(arg = nil)
-      if arg.is_a? Hash
-        if arg.key?(:message) || arg.key?('message')
-          super(arg[:message] || arg['message'])
+      if arg.is_a?(Hash)
+        if arg.key?(:message) || arg.key?("message")
+          super(arg[:message] || arg["message"])
         else
           super
         end
 
         arg.each do |k, v|
-          instance_variable_set "@#{k}", v
+          instance_variable_set("@#{k}", v)
         end
       else
         super
@@ -33,10 +33,10 @@ module Algolia
 
     def message
       msg = if @message.nil?
-              'Error message: the server returns an error'
-            else
-              @message
-            end
+        "Error message: the server returns an error"
+      else
+        @message
+      end
 
       msg += "\nHTTP status code: #{code}" if code
       msg += "\nResponse headers: #{response_headers}" if response_headers

data/lib/algolia/configuration.rb

@@ -2,7 +2,18 @@
 
 module Algolia
   class Configuration
-    attr_accessor :hosts, :app_id, :api_key, :user_agent, :header_params, :read_timeout, :write_timeout, :connect_timeout, :compression_type, :requester
+    attr_accessor(
+      :hosts,
+      :app_id,
+      :api_key,
+      :user_agent,
+      :header_params,
+      :read_timeout,
+      :write_timeout,
+      :connect_timeout,
+      :compression_type,
+      :requester
+    )
 
     # Set this to false to skip client side validation in the operation.
     # Default to true.
@@ -17,16 +28,16 @@ module Algolia
       @write_timeout = opts[:write_timeout] || 30_000
       @read_timeout = opts[:read_timeout] || 5_000
       @connect_timeout = opts[:connect_timeout] || 2_000
-      @compression_type = opts[:compression_type] || 'none'
+      @compression_type = opts[:compression_type] || "none"
       @requester = opts[:requester]
 
       @user_agent = UserAgent.new.add(client_name, VERSION)
 
       @header_params = {
-        'X-Algolia-Application-Id' => app_id,
-        'X-Algolia-API-Key' => api_key,
-        'Content-Type' => 'application/json',
-        'User-Agent' => @user_agent
+        "X-Algolia-Application-Id" => app_id,
+        "X-Algolia-API-Key" => api_key,
+        "Content-Type" => "application/json",
+        "User-Agent" => @user_agent
       }
       @header_params.transform_keys!(&:downcase)
 

data/lib/algolia/error.rb

@@ -20,9 +20,9 @@ module Algolia
     attr_accessor :code, :message
 
     def initialize(code, message)
-      self.code    = code
+      self.code = code
       self.message = message
-      super("#{self.code}: #{self.message}")
+      super("#{self.code()}: #{self.message()}")
     end
   end
 end

data/lib/algolia/logger_helper.rb

@@ -1,13 +1,13 @@
-require 'logger'
+require "logger"
 
 module Algolia
   class LoggerHelper
     # @param debug_file [nil|String] file used to output the logs
     #
     def self.create(debug_file = nil)
-      file              = debug_file || (ENV['ALGOLIA_DEBUG'] ? File.new('debug.log', 'a+') : $stderr)
-      instance          = ::Logger.new file
-      instance.progname = 'algolia'
+      file = debug_file || (ENV["ALGOLIA_DEBUG"] ? File.new("debug.log", "a+") : $stderr)
+      instance = ::Logger.new(file)
+      instance.progname = "algolia"
       instance
     end
   end

data/lib/algolia/models/abtesting/ab_test.rb

@@ -1,7 +1,7 @@
 # Code generated by OpenAPI Generator (https://openapi-generator.tech), manual changes will be lost - read more on https://github.com/algolia/api-clients-automation. DO NOT EDIT.
 
-require 'date'
-require 'time'
+require "date"
+require "time"
 
 module Algolia
   module Abtesting
@@ -87,49 +87,54 @@ module Algolia
       # Attribute type mapping.
       def self.types_mapping
         {
-          :ab_test_id => :Integer,
-          :click_significance => :Float,
-          :conversion_significance => :Float,
-          :add_to_cart_significance => :Float,
-          :purchase_significance => :Float,
-          :revenue_significance => :'Hash<String, Float>',
-          :updated_at => :String,
-          :created_at => :String,
-          :end_at => :String,
-          :name => :String,
-          :status => :Status,
-          :variants => :'Array<Variant>',
-          :configuration => :ABTestConfiguration
+          :ab_test_id => :"Integer",
+          :click_significance => :"Float",
+          :conversion_significance => :"Float",
+          :add_to_cart_significance => :"Float",
+          :purchase_significance => :"Float",
+          :revenue_significance => :"Hash<String, Float>",
+          :updated_at => :"String",
+          :created_at => :"String",
+          :end_at => :"String",
+          :name => :"String",
+          :status => :"Status",
+          :variants => :"Array<Variant>",
+          :configuration => :"ABTestConfiguration"
         }
       end
 
       # List of attributes with nullable: true
       def self.openapi_nullable
-        Set.new([
-                  :click_significance,
-                  :conversion_significance,
-                  :add_to_cart_significance,
-                  :purchase_significance,
-                  :revenue_significance
-                ])
+        Set.new(
+          [
+            :click_significance,
+            :conversion_significance,
+            :add_to_cart_significance,
+            :purchase_significance,
+            :revenue_significance
+          ]
+        )
       end
 
       # Initializes the object
       # @param [Hash] attributes Model attributes in the form of hash
       def initialize(attributes = {})
-        unless attributes.is_a?(Hash)
+        if (!attributes.is_a?(Hash))
           raise ArgumentError, "The input argument (attributes) must be a hash in `Algolia::ABTest` initialize method"
         end
 
         # check to see if the attribute exists and convert string to symbol for hash key
-        attributes = attributes.each_with_object({}) do |(k, v), h|
-          unless self.class.attribute_map.key?(k.to_sym)
-            raise ArgumentError,
-                  "`#{k}` is not a valid attribute in `Algolia::ABTest`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
+        attributes = attributes.each_with_object({}) { |(k, v), h|
+          if (!self.class.attribute_map.key?(k.to_sym))
+            raise(
+              ArgumentError,
+              "`#{k}` is not a valid attribute in `Algolia::ABTest`. Please check the name to make sure it's valid. List of attributes: " +
+                self.class.attribute_map.keys.inspect
+            )
           end
 
           h[k.to_sym] = v
-        end
+        }
 
         if attributes.key?(:ab_test_id)
           self.ab_test_id = attributes[:ab_test_id]
@@ -215,8 +220,7 @@ module Algolia
       # Checks equality by comparing each attribute.
       # @param [Object] Object to be compared
       def ==(other)
-        return true if equal?(other)
-
+        return true if self.equal?(other)
         self.class == other.class &&
           ab_test_id == other.ab_test_id &&
           click_significance == other.click_significance &&
@@ -242,8 +246,21 @@ module Algolia
       # Calculates hash code according to all attributes.
       # @return [Integer] Hash code
       def hash
-        [ab_test_id, click_significance, conversion_significance, add_to_cart_significance, purchase_significance, revenue_significance, updated_at, created_at, end_at, name,
-         status, variants, configuration].hash
+        [
+          ab_test_id,
+          click_significance,
+          conversion_significance,
+          add_to_cart_significance,
+          purchase_significance,
+          revenue_significance,
+          updated_at,
+          created_at,
+          end_at,
+          name,
+          status,
+          variants,
+          configuration
+        ].hash
       end
 
       # Builds the object from hash
@@ -251,7 +268,6 @@ module Algolia
       # @return [Object] Returns the model itself
       def self.build_from_hash(attributes)
         return nil unless attributes.is_a?(Hash)
-
         attributes = attributes.transform_keys(&:to_sym)
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
@@ -261,12 +277,15 @@ module Algolia
             # check to ensure the input is an array given that the attribute
             # is documented as an array but the input is not
             if attributes[attribute_map[key]].is_a?(Array)
-              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v|
+                _deserialize(::Regexp.last_match(1), v)
+              }
             end
           elsif !attributes[attribute_map[key]].nil?
             transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
+
         new(transformed_hash)
       end
 
@@ -292,6 +311,7 @@ module Algolia
           else
             false
           end
+
         when :Object
           # generic object (usually a Hash), return directly
           value
@@ -306,10 +326,12 @@ module Algolia
               hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
             end
           end
-        else # model
+          # model
+        else
           # models (e.g. Pet) or oneOf
           klass = Algolia::Abtesting.const_get(type)
-          klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+          klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass
+            .build_from_hash(value)
         end
       end
 
@@ -342,6 +364,7 @@ module Algolia
 
           hash[param] = _to_hash(value)
         end
+
         hash
       end
 
@@ -356,12 +379,14 @@ module Algolia
           {}.tap do |hash|
             value.each { |k, v| hash[k] = _to_hash(v) }
           end
-        elsif value.respond_to? :to_hash
+        elsif value.respond_to?(:to_hash)
           value.to_hash
         else
           value
         end
       end
+
     end
+
   end
 end