algolia 3.15.4 → 3.15.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52cb63e14d4759337c66f9f2459f752ee03af7b7944b338783ee8797e989ddb6
-  data.tar.gz: 7b01e70ae34a17388540ae743ff93a5da87646c79f32fe811e38c9cc3e61f2ec
+  metadata.gz: 866c3b0ca3aeefdf7eac97bc971e746f161b53ac53807083a28223a933e27a49
+  data.tar.gz: f1b7931dfcee757ea5bf242f5a89df2b613bb2e27f1ebdd318197589e632a920
 SHA512:
-  metadata.gz: c98515c4ba5726fb4bb5871765ced01b3a7a9d92a85ddeab588a279d6bb68d4991c05b8d0eef5ba59f3be2a47d0c50ba75713f4d7eb165d5c000e9d0a89cfc07
-  data.tar.gz: a4ee881c2a812f5c0e9d643a109042ec8c7cda54d1766adab36f25c65d770fa84b93d862352db5f109f2a9c14bbc64080c6f96bb3afbb56423ac22558a2fc591
+  metadata.gz: 46aeb23ea063e85a8ed25baec6910c3099c1bbd31d46d0393fbcad90acc33bc3f4c62b8e5f891f9ae870e3bed301fb7509314e796cf1950775f27656a5c36d58
+  data.tar.gz: f74c062ec55982f8fd360bd60aacdc65b72e2646bdc76392b75353f5b833df335548dfbe24465091ab2cf7f9fd1bd9dee45c4cdf7da199d8498a869abd7a984b

data/.github/workflows/release.yml

@@ -21,7 +21,7 @@ jobs:
       - name: Install Ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 3.4.2
+          ruby-version: 3.4.3
           bundler-cache: true
 
       - uses: rubygems/release-gem@a25424ba2ba8b387abc8ef40807c2c85b96cbe32

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [3.15.5](https://github.com/algolia/algoliasearch-client-ruby/compare/3.15.4...3.15.5)
+
+- [efec6baf1c](https://github.com/algolia/api-clients-automation/commit/efec6baf1c) chore(deps): dependencies 2025-04-21 ([#4762](https://github.com/algolia/api-clients-automation/pull/4762)) by [@algolia-bot](https://github.com/algolia-bot/)
+- [53ac749807](https://github.com/algolia/api-clients-automation/commit/53ac749807) chore(deps): dependencies 2025-04-28 ([#4785](https://github.com/algolia/api-clients-automation/pull/4785)) by [@algolia-bot](https://github.com/algolia-bot/)
+
 ## [3.15.4](https://github.com/algolia/algoliasearch-client-ruby/compare/3.15.3...3.15.4)
 
 - [369c14232](https://github.com/algolia/api-clients-automation/commit/369c14232) fix(specs): condition cant be numeric filter ([#4726](https://github.com/algolia/api-clients-automation/pull/4726)) by [@kai687](https://github.com/kai687/)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    algolia (3.15.4)
+    algolia (3.15.5)
       base64 (>= 0.2.0, < 1)
       faraday (>= 1.0.1, < 3.0)
       faraday-net_http_persistent (>= 0.15, < 3)
@@ -11,8 +11,8 @@ GEM
   remote: https://rubygems.org/
   specs:
     base64 (0.2.0)
-    connection_pool (2.5.0)
-    faraday (2.12.2)
+    connection_pool (2.5.2)
+    faraday (2.13.1)
       faraday-net_http (>= 2.0, < 3.5)
       json
       logger
@@ -21,8 +21,8 @@ GEM
     faraday-net_http_persistent (2.3.0)
       faraday (~> 2.5)
       net-http-persistent (>= 4.0.4, < 5)
-    json (2.10.1)
-    logger (1.6.6)
+    json (2.11.3)
+    logger (1.7.0)
     net-http (0.6.0)
       uri
     net-http-persistent (4.0.5)

data/lib/algolia/models/ingestion/destination_input.rb

@@ -7,101 +7,225 @@ require "time"
 
 module Algolia
   module Ingestion
-    module DestinationInput
-      class << self
-      # List of class defined in oneOf (OpenAPI v3)
-        def openapi_one_of
-          [
-            :"DestinationIndexName"
-          ]
+    class DestinationInput
+      # Algolia index name (case-sensitive).
+      attr_accessor :index_name
+
+      attr_accessor :record_type
+
+      # Attributes from your source to exclude from Algolia records.  Not all your data attributes will be useful for searching. Keeping your Algolia records small increases indexing and search performance.  - Exclude nested attributes with `.` notation. For example, `foo.bar` indexes the `foo` attribute and all its children **except** the `bar` attribute. - Exclude attributes from arrays with `[i]`, where `i` is the index of the array element.   For example, `foo.[0].bar` only excludes the `bar` attribute from the first element of the `foo` array, but indexes the complete `foo` attribute for all other elements.   Use `*` as wildcard: `foo.[*].bar` excludes `bar` from all elements of the `foo` array.
+      attr_accessor :attributes_to_exclude
+
+      # Attribute mapping from ruby-style variable name to JSON key.
+      def self.attribute_map
+        {
+          :index_name => :indexName,
+          :record_type => :recordType,
+          :attributes_to_exclude => :attributesToExclude
+        }
+      end
+
+      # Attribute type mapping.
+      def self.types_mapping
+        {
+          :index_name => :"String",
+          :record_type => :"RecordType",
+          :attributes_to_exclude => :"Array<String>"
+        }
+      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 = {})
+        if (!attributes.is_a?(Hash))
+          raise(
+            ArgumentError,
+            "The input argument (attributes) must be a hash in `Algolia::DestinationInput` initialize method"
+          )
         end
 
-        # Builds the object
-        # @param [Mixed] Data to be matched against the list of oneOf items
-        # @return [Object] Returns the model or the data itself
-        def build(data)
-          # Go through the list of oneOf items and attempt to identify the appropriate one.
-          # Note:
-          # - We do not attempt to check whether exactly one item matches.
-          # - No advanced validation of types in some cases (e.g. "x: { type: string }" will happily match { x: 123 })
-          #   due to the way the deserialization is made in the base_object template (it just casts without verifying).
-          # - TODO: scalar values are de facto behaving as if they were nullable.
-          # - TODO: logging when debugging is set.
-          openapi_one_of.each do |klass|
-            begin
-              # "nullable: true"
-              next if klass == :AnyType
-              typed_data = find_and_cast_into_type(klass, data)
-              return typed_data if typed_data
-              # rescue all errors so we keep iterating even if the current item lookup raises
-            rescue
-            end
+        # check to see if the attribute exists and convert string to symbol for hash key
+        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::DestinationInput`. Please check the name to make sure it's valid. List of attributes: " +
+                self.class.attribute_map.keys.inspect
+            )
           end
 
-          openapi_one_of.include?(:AnyType) ? data : nil
+          h[k.to_sym] = v
+        }
+
+        if attributes.key?(:index_name)
+          self.index_name = attributes[:index_name]
+        else
+          self.index_name = nil
         end
 
-        private
-
-        SchemaMismatchError = Class.new(StandardError)
-
-        def find_and_cast_into_type(klass, data)
-          return if data.nil?
-
-          case klass.to_s
-          when "Boolean"
-            return data if data.instance_of?(TrueClass) || data.instance_of?(FalseClass)
-          when "Float"
-            return data if data.instance_of?(Float)
-          when "Integer"
-            return data if data.instance_of?(Integer)
-          when "Time"
-            return Time.parse(data)
-          when "Date"
-            return Date.parse(data)
-          when "String"
-            return data if data.instance_of?(String)
-            # "type: object"
-          when "Object"
-            return data if data.instance_of?(Hash)
-            # "type: array"
-          when /\AArray<(?<sub_type>.+)>\z/
-            if data.instance_of?(Array)
-              sub_type = Regexp.last_match[:sub_type]
-              return data.map { |item| find_and_cast_into_type(sub_type, item) }
-            end
-            # "type: object" with "additionalProperties: { ... }"
-          when /\AHash<String, (?<sub_type>.+)>\z/
-            if data.instance_of?(Hash) && data.keys.all? { |k| k.instance_of?(Symbol) || k.instance_of?(String) }
-              sub_type = Regexp.last_match[:sub_type]
-              return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }
+        if attributes.key?(:record_type)
+          self.record_type = attributes[:record_type]
+        end
+
+        if attributes.key?(:attributes_to_exclude)
+          if (value = attributes[:attributes_to_exclude]).is_a?(Array)
+            self.attributes_to_exclude = value
+          end
+        end
+      end
+
+      # Checks equality by comparing each attribute.
+      # @param [Object] Object to be compared
+      def ==(other)
+        return true if self.equal?(other)
+        self.class == other.class &&
+          index_name == other.index_name &&
+          record_type == other.record_type &&
+          attributes_to_exclude == other.attributes_to_exclude
+      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
+        [index_name, record_type, attributes_to_exclude].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_sym] = 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_sym] = attributes[attribute_map[key]].map { |v|
+                _deserialize(::Regexp.last_match(1), v)
+              }
             end
-            # model
+          elsif !attributes[attribute_map[key]].nil?
+            transformed_hash[key.to_sym] = _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
-            const = Algolia::Ingestion.const_get(klass)
-            if const
-              if const.respond_to?(:openapi_one_of)
-                # nested oneOf model
-                model = const.build(data)
-              elsif const.respond_to?(:discriminator_attributes)
-                if const.discriminator_attributes.all? { |attr| data.key?(attr) }
-                  model = const.build_from_hash(data)
-                end
-              else
-                # maybe it's an enum, or doens't have discriminators
-                model = const.build_from_hash(data)
-              end
-
-              return model if model
+            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
+          # model
+        else
+          # models (e.g. Pet) or oneOf
+          klass = Algolia::Ingestion.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
 
-          # if no match by now, raise
-          raise
-        rescue
-          raise SchemaMismatchError, "#{data} doesn't match the #{klass} type"
+      # 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
+
+      def to_json(*_args)
+        to_hash.to_json
+      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

data/lib/algolia/version.rb

@@ -3,5 +3,5 @@
 # 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.
 
 module Algolia
-  VERSION = "3.15.4"
+  VERSION = "3.15.5"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: algolia
 version: !ruby/object:Gem::Version
-  version: 3.15.4
+  version: 3.15.5
 platform: ruby
 authors:
 - https://alg.li/support
 bindir: bin
 cert_chain: []
-date: 2025-04-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -307,7 +307,6 @@ files:
 - lib/algolia/models/ingestion/destination.rb
 - lib/algolia/models/ingestion/destination_create.rb
 - lib/algolia/models/ingestion/destination_create_response.rb
-- lib/algolia/models/ingestion/destination_index_name.rb
 - lib/algolia/models/ingestion/destination_input.rb
 - lib/algolia/models/ingestion/destination_search.rb
 - lib/algolia/models/ingestion/destination_sort_keys.rb
@@ -765,7 +764,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: A simple Ruby client for the algolia.com REST API
 test_files: []

data/lib/algolia/models/ingestion/destination_index_name.rb

@@ -1,232 +0,0 @@
-# frozen_string_literal: true
-
-# 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 Ingestion
-    class DestinationIndexName
-      # Algolia index name (case-sensitive).
-      attr_accessor :index_name
-
-      attr_accessor :record_type
-
-      # Attributes from your source to exclude from Algolia records.  Not all your data attributes will be useful for searching. Keeping your Algolia records small increases indexing and search performance.  - Exclude nested attributes with `.` notation. For example, `foo.bar` indexes the `foo` attribute and all its children **except** the `bar` attribute. - Exclude attributes from arrays with `[i]`, where `i` is the index of the array element.   For example, `foo.[0].bar` only excludes the `bar` attribute from the first element of the `foo` array, but indexes the complete `foo` attribute for all other elements.   Use `*` as wildcard: `foo.[*].bar` excludes `bar` from all elements of the `foo` array.
-      attr_accessor :attributes_to_exclude
-
-      # Attribute mapping from ruby-style variable name to JSON key.
-      def self.attribute_map
-        {
-          :index_name => :indexName,
-          :record_type => :recordType,
-          :attributes_to_exclude => :attributesToExclude
-        }
-      end
-
-      # Attribute type mapping.
-      def self.types_mapping
-        {
-          :index_name => :"String",
-          :record_type => :"RecordType",
-          :attributes_to_exclude => :"Array<String>"
-        }
-      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 = {})
-        if (!attributes.is_a?(Hash))
-          raise(
-            ArgumentError,
-            "The input argument (attributes) must be a hash in `Algolia::DestinationIndexName` initialize method"
-          )
-        end
-
-        # check to see if the attribute exists and convert string to symbol for hash key
-        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::DestinationIndexName`. 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
-        }
-
-        if attributes.key?(:index_name)
-          self.index_name = attributes[:index_name]
-        else
-          self.index_name = nil
-        end
-
-        if attributes.key?(:record_type)
-          self.record_type = attributes[:record_type]
-        end
-
-        if attributes.key?(:attributes_to_exclude)
-          if (value = attributes[:attributes_to_exclude]).is_a?(Array)
-            self.attributes_to_exclude = value
-          end
-        end
-      end
-
-      # Checks equality by comparing each attribute.
-      # @param [Object] Object to be compared
-      def ==(other)
-        return true if self.equal?(other)
-        self.class == other.class &&
-          index_name == other.index_name &&
-          record_type == other.record_type &&
-          attributes_to_exclude == other.attributes_to_exclude
-      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
-        [index_name, record_type, attributes_to_exclude].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_sym] = 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_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
-
-      # 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
-          # model
-        else
-          # models (e.g. Pet) or oneOf
-          klass = Algolia::Ingestion.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
-
-      def to_json(*_args)
-        to_hash.to_json
-      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