algolia 2.3.4 → 3.0.0.alpha.2

data/lib/algolia/models/search/value.rb

@@ -0,0 +1,226 @@
+# 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'
+
+module Algolia
+  module Search
+    class Value
+      # Pinned order of facet lists.
+      attr_accessor :order
+
+      attr_accessor :sort_remaining_by
+
+      class EnumAttributeValidator
+        attr_reader :datatype
+        attr_reader :allowable_values
+
+        def initialize(datatype, allowable_values)
+          @allowable_values = allowable_values.map do |value|
+            case datatype.to_s
+            when /Integer/i
+              value.to_i
+            when /Float/i
+              value.to_f
+            else
+              value
+            end
+          end
+        end
+
+        def valid?(value)
+          !value || allowable_values.include?(value)
+        end
+      end
+
+      # Attribute mapping from ruby-style variable name to JSON key.
+      def self.attribute_map
+        {
+          :order => :order,
+          :sort_remaining_by => :sortRemainingBy
+        }
+      end
+
+      # Returns all the JSON keys this model knows about
+      def self.acceptable_attributes
+        attribute_map.values
+      end
+
+      # Attribute type mapping.
+      def self.types_mapping
+        {
+          :order => :'Array<String>',
+          :sort_remaining_by => :SortRemainingBy
+        }
+      end
+
+      # List of attributes with nullable: true
+      def self.openapi_nullable
+        Set.new([])
+      end
+
+      # Initializes the object
+      # @param [Hash] attributes Model attributes in the form of hash
+      def initialize(attributes = {})
+        unless attributes.is_a?(Hash)
+          raise ArgumentError, "The input argument (attributes) must be a hash in `Algolia::Value` 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::Value`. 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?(:order)
+          if (value = attributes[:order]).is_a?(Array)
+            self.order = value
+          end
+        end
+
+        if attributes.key?(:sort_remaining_by)
+          self.sort_remaining_by = attributes[:sort_remaining_by]
+        end
+      end
+
+      # Checks equality by comparing each attribute.
+      # @param [Object] Object to be compared
+      def ==(other)
+        return true if equal?(other)
+
+        self.class == other.class &&
+          order == other.order &&
+          sort_remaining_by == other.sort_remaining_by
+      end
+
+      # @see the `==` method
+      # @param [Object] Object to be compared
+      def eql?(other)
+        self == other
+      end
+
+      # Calculates hash code according to all attributes.
+      # @return [Integer] Hash code
+      def hash
+        [order, sort_remaining_by].hash
+      end
+
+      # Builds the object from hash
+      # @param [Hash] attributes Model attributes in the form of hash
+      # @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|
+          if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+            transformed_hash[key.to_s] = nil
+          elsif type =~ /\AArray<(.*)>/i
+            # 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_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+            end
+          elsif !attributes[attribute_map[key]].nil?
+            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+          end
+        end
+        new(transformed_hash)
+      end
+
+      # Deserializes the data based on type
+      # @param string type Data type
+      # @param string value Value to be deserialized
+      # @return [Object] Deserialized data
+      def self._deserialize(type, value)
+        case type.to_sym
+        when :Time
+          Time.parse(value)
+        when :Date
+          Date.parse(value)
+        when :String
+          value.to_s
+        when :Integer
+          value.to_i
+        when :Float
+          value.to_f
+        when :Boolean
+          if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+            true
+          else
+            false
+          end
+        when :Object
+          # generic object (usually a Hash), return directly
+          value
+        when /\AArray<(?<inner_type>.+)>\z/
+          inner_type = Regexp.last_match[:inner_type]
+          value.map { |v| _deserialize(inner_type, v) }
+        when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+          k_type = Regexp.last_match[:k_type]
+          v_type = Regexp.last_match[:v_type]
+          {}.tap do |hash|
+            value.each do |k, v|
+              hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+            end
+          end
+        else # model
+          # models (e.g. Pet) or oneOf
+          klass = Algolia::Search.const_get(type)
+          klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+        end
+      end
+
+      # Returns the string representation of the object
+      # @return [String] String presentation of the object
+      def to_s
+        to_hash.to_s
+      end
+
+      # to_body is an alias to to_hash (backward compatibility)
+      # @return [Hash] Returns the object in the form of hash
+      def to_body
+        to_hash
+      end
+
+      # Returns the object in the form of hash
+      # @return [Hash] Returns the object in the form of hash
+      def to_hash
+        hash = {}
+        self.class.attribute_map.each_pair do |attr, param|
+          value = send(attr)
+          if value.nil?
+            is_nullable = self.class.openapi_nullable.include?(attr)
+            next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+          end
+
+          hash[param] = _to_hash(value)
+        end
+        hash
+      end
+
+      # Outputs non-array value in the form of hash
+      # For object, use to_hash. Otherwise, just return the value
+      # @param [Object] value Any valid value
+      # @return [Hash] Returns the value in the form of hash
+      def _to_hash(value)
+        if value.is_a?(Array)
+          value.compact.map { |v| _to_hash(v) }
+        elsif value.is_a?(Hash)
+          {}.tap do |hash|
+            value.each { |k, v| hash[k] = _to_hash(v) }
+          end
+        elsif value.respond_to? :to_hash
+          value.to_hash
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/algolia/transport/echo_requester.rb

@@ -0,0 +1,10 @@
+module Algolia
+  module Transport
+    class EchoRequester
+      def send_request(host, method, path, body, query_params, headers, timeout, connect_timeout)
+        Http::Response.new(host: host, status: 200, body: body, query_params: query_params, headers: headers, method: method, path: path, timeout: timeout,
+                           connect_timeout: connect_timeout)
+      end
+    end
+  end
+end

data/lib/algolia/{http → transport/http}/http_requester.rb

@@ -1,7 +1,6 @@
 module Algolia
   module Http
     class HttpRequester
-      include Helpers
       attr_accessor :adapter, :logger
 
       #
@@ -20,41 +19,33 @@ module Algolia
       # @param method [Symbol]
       # @param path [String]
       # @param body [JSON]
+      # @param query_params [Hash]
       # @param headers [Hash]
       #
       # @return [Http::Response]
       #
-      def send_request(host, method, path, body, headers, timeout, connect_timeout)
+      def send_request(host, method, path, body, query_params, headers, timeout, connect_timeout)
         connection                      = connection(host)
-        connection.options.timeout      = timeout
-        connection.options.open_timeout = connect_timeout
+        connection.options.timeout      = timeout / 1000
+        connection.options.open_timeout = connect_timeout / 1000
+        path += handle_query_params(query_params)
 
-        if ENV['ALGOLIA_DEBUG']
-          @logger.info("Sending #{method.to_s.upcase!} request to #{path} with body #{body}")
-        end
+        @logger.info("Sending #{method.to_s.upcase!} request to #{path} with body #{body}") if ENV['ALGOLIA_DEBUG']
 
         response = connection.run_request(method, path, body, headers)
 
         if response.success?
-          if ENV['ALGOLIA_DEBUG']
-            @logger.info("Request succeeded. Response status: #{response.status}, body: #{response.body}")
-          end
+          @logger.info("Request succeeded. Response status: #{response.status}, body: #{response.body}") if ENV['ALGOLIA_DEBUG']
           return Http::Response.new(status: response.status, body: response.body, headers: response.headers)
         end
 
-        if ENV['ALGOLIA_DEBUG']
-          @logger.info("Request failed. Response status: #{response.status}, error: #{response.body}")
-        end
+        @logger.info("Request failed. Response status: #{response.status}, error: #{response.body}") if ENV['ALGOLIA_DEBUG']
         Http::Response.new(status: response.status, error: response.body, headers: response.headers)
       rescue Faraday::TimeoutError => e
-        if ENV['ALGOLIA_DEBUG']
-          @logger.info("Request timed out. Error: #{e.message}")
-        end
+        @logger.info("Request timed out. Error: #{e.message}") if ENV['ALGOLIA_DEBUG']
         Http::Response.new(error: e.message, has_timed_out: true)
       rescue ::StandardError => e
-        if ENV['ALGOLIA_DEBUG']
-          @logger.info("Request failed. Error: #{e.message}")
-        end
+        @logger.info("Request failed. Error: #{e.message}") if ENV['ALGOLIA_DEBUG']
         Http::Response.new(error: e.message, network_failure: true)
       end
 
@@ -79,6 +70,20 @@ module Algolia
       def build_url(host)
         host.protocol + host.url
       end
+
+      # Convert query_params to a full query string
+      #
+      def handle_query_params(query_params)
+        query_params.nil? || query_params.empty? ? '' : "?#{to_query_string(query_params)}"
+      end
+
+      # Create a query string from query_params
+      #
+      def to_query_string(query_params)
+        query_params.map do |key, value|
+          "#{key}=#{value}"
+        end.join('&')
+      end
     end
   end
 end

data/lib/algolia/{http → transport/http}/response.rb

@@ -3,6 +3,9 @@ module Algolia
     class Response
       attr_reader :status, :body, :error, :headers, :has_timed_out, :network_failure
 
+      # used for the echo requester
+      attr_reader :method, :path, :query_params, :host, :timeout, :connect_timeout
+
       #
       # @option status    [String]  Response status
       # @option body    [String]  Response body
@@ -12,11 +15,18 @@ module Algolia
       #
       def initialize(opts = {})
         @status          = opts[:status]
-        @body            = opts[:body] || ''
+        @body            = opts[:body]
         @error           = opts[:error] || ''
         @headers         = opts[:headers] || ''
         @has_timed_out   = opts[:has_timed_out] || false
         @network_failure = opts[:network_failure] || false
+
+        @method = opts[:method] || ''
+        @path = opts[:path] || ''
+        @host = opts[:host] || ''
+        @timeout = opts[:timeout] || 0
+        @connect_timeout = opts[:connect_timeout] || 0
+        @query_params = opts[:query_params] || {}
       end
     end
   end

data/lib/algolia/transport/request_options.rb

@@ -1,56 +1,54 @@
 module Algolia
   module Transport
     class RequestOptions
-      attr_accessor :headers, :params, :data, :timeout, :connect_timeout, :compression_type
+      attr_accessor :header_params, :query_params, :data, :timeout, :connect_timeout, :compression_type
 
       # @param [Search::Config] config
       #
       def initialize(config)
-        @headers          = {}
-        @params           = {}
-        @data             = {}
+        @header_params    = {}
+        @query_params     = {}
         @timeout          = nil
         @connect_timeout  = nil
         @compression_type = config.compression_type
       end
 
-      # Create and format headers and params from request options
+      # Create and format headers and query params from request options
       #
       # @param opts [Hash]
       #
       def create(opts = {})
-        add_headers(opts)
-        add_params(opts)
+        add_header_params(opts)
+        add_query_params(opts)
         add_timeout(opts)
         add_connect_timeout(opts)
         add_compression_type(opts)
-        add_data_body(opts)
       end
 
-      # Add or update headers
+      # Add or update header_params
       #
       # @param opts [Hash]
       #
-      def add_headers(opts = {})
-        unless opts[:headers].nil?
-          opts[:headers].each do |opt, value|
-            @headers[opt.to_s] = value
-          end
-          opts.delete(:headers)
+      def add_header_params(opts = {})
+        return if opts[:header_params].nil?
+
+        opts[:header_params].each do |opt, value|
+          @header_params[opt.to_s] = value
         end
+        opts.delete(:header_params)
       end
 
       # Add or update query parameters
       #
       # @param opts [Hash]
       #
-      def add_params(opts = {})
-        unless opts[:params].nil?
-          opts[:params].each do |opt, value|
-            @params[opt.to_sym] = value
-          end
-          opts.delete(:params)
+      def add_query_params(opts = {})
+        return if opts[:query_params].nil?
+
+        opts[:query_params].each do |opt, value|
+          @query_params[opt.to_sym] = value
         end
+        opts.delete(:query_params)
       end
 
       # Add or update timeout
@@ -79,16 +77,6 @@ module Algolia
         @compression_type = opts[:compression_type] || @compression_type
         opts.delete(:compression_type)
       end
-
-      # @param opts [Hash]
-      #
-      def add_data_body(opts = {})
-        unless opts.empty?
-          opts.each do |key, value|
-            @data[key.to_sym] = value
-          end
-        end
-      end
     end
   end
 end

data/lib/algolia/transport/retry_strategy.rb

@@ -1,13 +1,12 @@
 module Algolia
   module Transport
-    # Class RetryStatregy
     class RetryStrategy
       include RetryOutcomeType
 
-      # @param config [Search::Config] config which contains the hosts
+      # @param hosts [StatefulHost]
       #
-      def initialize(config)
-        @hosts = config.default_hosts
+      def initialize(hosts)
+        @hosts = hosts
         @lock  = Mutex.new
       end
 
@@ -76,9 +75,7 @@ module Algolia
       # @return [Boolean]
       #
       def retryable?(http_response_code, network_failure)
-        if network_failure
-          return true
-        end
+        return true if network_failure
 
         !http_response_code.nil? && (http_response_code.to_i / 100).floor != 2 && (http_response_code.to_i / 100).floor != 4
       end
@@ -110,7 +107,7 @@ module Algolia
       # @return [Boolean]
       #
       def flag?(item, flag)
-        (item & (1 << (flag - 1))) > 0
+        (item & (1 << (flag - 1))).positive?
       end
     end
   end

data/lib/algolia/transport/stateful_host.rb

@@ -1,6 +1,5 @@
 module Algolia
   module Transport
-    # Class StatefulHost
     class StatefulHost
       include CallType
 
@@ -19,7 +18,7 @@ module Algolia
         @accept      = opts[:accept] || (READ | WRITE)
         @last_use    = opts[:last_use] || Time.now.utc
         @retry_count = opts[:retry_count] || 0
-        @up          = opts.has_key?(:up) ? opts[:up] : true
+        @up          = opts.key?(:up) ? opts[:up] : true
       end
     end
   end

data/lib/algolia/transport/transport.rb

@@ -7,37 +7,14 @@ module Algolia
     class Transport
       include RetryOutcomeType
       include CallType
-      include Helpers
 
-      # @param config [Search::Config] config used for search
+      # @param config [Configuration]
       # @param requester [Object] requester used for sending requests. Uses Algolia::Http::HttpRequester by default
       #
       def initialize(config, requester)
-        @config           = config
-        @http_requester   = requester
-        @retry_strategy   = RetryStrategy.new(config)
-      end
-
-      # Build a request with call type READ
-      #
-      # @param method [Symbol] method used for request
-      # @param path [String] path of the request
-      # @param body [Hash] request body
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      def read(method, path, body = {}, opts = {})
-        request(READ, method, path, body, opts)
-      end
-
-      # Build a request with call type WRITE
-      #
-      # @param method [Symbol] method used for request
-      # @param path [String] path of the request
-      # @param body [Hash] request body
-      # @param opts [Hash] contains extra parameters to send with your query
-      #
-      def write(method, path, body = {}, opts = {})
-        request(WRITE, method, path, body, opts)
+        @config = config
+        @requester = requester
+        @retry_strategy = RetryStrategy.new(config.hosts)
       end
 
       # @param call_type [Binary] READ or WRITE operation
@@ -48,35 +25,38 @@ module Algolia
       #
       # @return [Response] response of the request
       #
-      def request(call_type, method, path, body = {}, opts = {})
+      def request(call_type, method, path, body, opts = {})
         @retry_strategy.get_tryable_hosts(call_type).each do |host|
           opts[:timeout]         ||= get_timeout(call_type) * (host.retry_count + 1)
           opts[:connect_timeout] ||= @config.connect_timeout * (host.retry_count + 1)
 
           request_options = RequestOptions.new(@config)
           request_options.create(opts)
-          request_options.params.merge!(request_options.data) if method == :GET
+          # TODO: what is this merge for ?
+          # request_options.query_params.merge!(request_options.data) if method == :GET
 
           request  = build_request(method, path, body, request_options)
-          response = @http_requester.send_request(
+          response = @requester.send_request(
             host,
             request[:method],
             request[:path],
             request[:body],
-            request[:headers],
+            request[:query_params],
+            request[:header_params],
             request[:timeout],
             request[:connect_timeout]
           )
 
-          outcome  = @retry_strategy.decide(host, http_response_code: response.status, is_timed_out: response.has_timed_out, network_failure: response.network_failure)
+          outcome = @retry_strategy.decide(host, http_response_code: response.status, is_timed_out: response.has_timed_out, network_failure: response.network_failure)
           if outcome == FAILURE
-            decoded_error = json_to_hash(response.error, @config.symbolize_keys)
-            raise AlgoliaHttpError.new(get_option(decoded_error, 'status'), get_option(decoded_error, 'message'))
+            decoded_error = JSON.parse(response.error, :symbolize_names => true)
+            puts decoded_error
+            raise AlgoliaHttpError.new(decoded_error[:status], decoded_error[:message])
           end
-          return json_to_hash(response.body, @config.symbolize_keys) unless outcome == RETRY
+          return response unless outcome == RETRY
         end
 
-        raise AlgoliaUnreachableHostError, 'Unreachable hosts'
+        raise AlgoliaUnreachableHostError('Unreachable hosts')
       end
 
       private
@@ -93,54 +73,27 @@ module Algolia
       def build_request(method, path, body, request_options)
         request                   = {}
         request[:method]          = method.downcase
-        request[:path]            = build_uri_path(path, request_options.params)
-        request[:body]            = build_body(body, request_options, method)
-        request[:headers]         = generate_headers(request_options)
+        request[:path]            = path
+        request[:body]            = body
+        request[:query_params]    = stringify_query_params(request_options.query_params)
+        request[:header_params]   = generate_header_params(request_options)
         request[:timeout]         = request_options.timeout
         request[:connect_timeout] = request_options.connect_timeout
         request
       end
 
-      # Build the uri from path and additional params
-      #
-      # @param [Object] path
-      # @param [Object] params
-      #
-      # @return [String]
-      #
-      def build_uri_path(path, params)
-        path + handle_params(params)
-      end
-
-      # Build the body of the request
-      #
-      # @param [Hash] body
-      #
-      # @return [Hash]
-      #
-      def build_body(body, request_options, method)
-        if method == :GET && body.empty?
-          return nil
-        end
-
-        # merge optional special request options to the body when it
-        # doesn't have to be in the array format
-        body.merge!(request_options.data) if body.is_a?(Hash) && method != :GET
-        to_json(body)
-      end
-
       # Generates headers from config headers and optional parameters
       #
       # @param request_options [RequestOptions]
       #
       # @return [Hash] merged headers
       #
-      def generate_headers(request_options = {})
-        headers = @config.headers.merge(request_options.headers)
-        if request_options.compression_type == Defaults::GZIP_ENCODING
-          headers['Accept-Encoding']  = Defaults::GZIP_ENCODING
-        end
-        headers
+      def generate_header_params(request_options = {})
+        header_params = request_options.header_params.transform_keys(&:downcase)
+        header_params = @config.header_params.merge(header_params)
+        header_params['accept-encoding'] = 'gzip' if request_options.compression_type == 'gzip'
+
+        header_params
       end
 
       # Retrieves a timeout according to call_type
@@ -157,6 +110,13 @@ module Algolia
           @config.write_timeout
         end
       end
+
+      def stringify_query_params(query_params)
+        query_params.map do |key, value|
+          value = value.join(',') if value.is_a?(Array)
+          [key, value.to_s]
+        end.to_h
+      end
     end
   end
 end

data/lib/algolia/user_agent.rb

@@ -2,24 +2,14 @@ module Algolia
   class UserAgent
     attr_accessor :value
 
-    @@value = Defaults::USER_AGENT
-
-    # Set the value of the UserAgent
-    #
-    def self.value
-      @@value
-    end
-
-    # Resets the value of the UserAgent
-    #
-    def self.reset_to_default
-      @@value = Defaults::USER_AGENT
+    def initialize
+      @value = "Algolia for Ruby (#{VERSION}); Ruby (#{RUBY_VERSION})"
     end
 
     # Adds a segment to the UserAgent
     #
-    def self.add(segment, version)
-      @@value += format('; %<segment>s (%<version>s)', segment: segment, version: version)
+    def add(segment, version)
+      @value += format('; %<segment>s (%<version>s)', segment: segment, version: version)
     end
   end
 end