google-cloud-firestore 2.1.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1e7097a28daa16ef5b2de8684c5b052b6409b792a4e7f382f878c47745dbf1a
-  data.tar.gz: 35dae74e7a063ad5e456420633c50b60ea0731b2fcafdde0e6ceab25b10bea25
+  metadata.gz: 9faa52fed532effb0c8cb260b4159cfed65ba53a790f1c2451f5a610f46fa551
+  data.tar.gz: 8e2cbe9b830a1e4c46b49080cfa717a9e6e9f8901848aea6a905edd1d3234544
 SHA512:
-  metadata.gz: 23da24a3a861701b5156d1851be1eba45770565319e86d66e098f3a59156490ec16a7457d52fa55d0c216df653d2e1873a6212b5df3b23c67f576d40d706bd53
-  data.tar.gz: 9aef0214f2cf6a9db195be9b27dbb50f087b8d25be9041419a9d14d018f910aad449140848a0d49aa0223961672361b18e47a1f60b0e6eeeedd3752a88c2ac3a
+  metadata.gz: 94c1832275adb689e4394d03fd724dd39240eedb9fbfad132f4217ea97b1d6076cc0b8e0b846eec2a1afdf1180ffd2e981c5d5ecef12e6aaf11a04fe52460b44
+  data.tar.gz: c9b0c729751b0ed24ff39be1e56905da26bec6af30410e1112325482b07b888f3f1c07e60c5b1bc7bd8e90b58a710f0cb31e4a0d6181179c69d5b23267d5904f

data/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Release History
 
+### 2.5.0 / 2021-03-10
+
+#### Features
+
+* Drop support for Ruby 2.4 and add support for Ruby 3.0
+
+### 2.4.1 / 2021-01-06
+
+#### Bug Fixes
+
+* Replace usage of Write.transform with Write.update_transforms
+
+### 2.4.0 / 2020-11-19
+
+#### Features
+
+* add support for != and NOT_IN queries
+
+### 2.3.0 / 2020-09-30
+
+#### Features
+
+* Add error callbacks for listener threads
+  * Add DocumentListener#last_error
+  * Add DocumentListener#on_error
+  * Add QueryListener#last_error
+  * Add QueryListener#on_error
+
+### 2.2.0 / 2020-09-17
+
+#### Features
+
+* quota_project can be set via library configuration ([#7630](https://www.github.com/googleapis/google-cloud-ruby/issues/7630))
+
+#### Documentation
+
+* Add snapshot query cursor sample ([#7601](https://www.github.com/googleapis/google-cloud-ruby/issues/7601))
+
 ### 2.1.0 / 2020-09-10
 
 #### Features

data/CONTRIBUTING.md

@@ -24,7 +24,7 @@ be able to accept your pull requests.
 In order to use the google-cloud-firestore console and run the project's tests,
 there is a small amount of setup:
 
-1. Install Ruby. google-cloud-firestore requires Ruby 2.4+. You may choose to
+1. Install Ruby. google-cloud-firestore requires Ruby 2.5+. You may choose to
    manage your Ruby and gem installations with [RVM](https://rvm.io/),
    [rbenv](https://github.com/rbenv/rbenv), or
    [chruby](https://github.com/postmodern/chruby).
@@ -45,7 +45,7 @@ there is a small amount of setup:
 
    ```sh
    $ cd google-cloud-firestore/
-   $ bundle exec rake bundleupdate
+   $ bundle install
    ```
 
 ## Console

data/LOGGING.md

@@ -3,7 +3,7 @@
 To enable logging for this library, set the logger for the underlying
 [gRPC](https://github.com/grpc/grpc/tree/master/src/ruby) library. The logger
 that you set may be a Ruby stdlib
-[`Logger`](https://ruby-doc.org/stdlib-2.5.0/libdoc/logger/rdoc/Logger.html) as
+[`Logger`](https://ruby-doc.org/stdlib/libdoc/logger/rdoc/Logger.html) as
 shown below, or a
 [`Google::Cloud::Logging::Logger`](https://googleapis.dev/ruby/google-cloud-logging/latest)
 that will write logs to [Stackdriver

data/lib/google-cloud-firestore.rb

@@ -125,6 +125,7 @@ Google::Cloud.configure.add_config! :firestore do |config|
   config.add_field! :credentials, default_creds, match: [String, Hash, Google::Auth::Credentials], allow_nil: true
   config.add_alias! :keyfile, :credentials
   config.add_field! :scope, default_scopes, match: [String, Array]
+  config.add_field! :quota_project, nil, match: String
   config.add_field! :timeout, nil, match: Integer
   config.add_field! :emulator_host, default_emulator, match: String, allow_nil: true
   config.add_field! :endpoint, "firestore.googleapis.com", match: String

data/lib/google/cloud/firestore/batch.rb

@@ -119,7 +119,7 @@ module Google
 
           doc_path = coalesce_doc_path_argument doc
 
-          @writes << Convert.writes_for_create(doc_path, data)
+          @writes << Convert.write_for_create(doc_path, data)
 
           nil
         end
@@ -218,7 +218,7 @@ module Google
 
           doc_path = coalesce_doc_path_argument doc
 
-          @writes << Convert.writes_for_set(doc_path, data, merge: merge)
+          @writes << Convert.write_for_set(doc_path, data, merge: merge)
 
           nil
         end
@@ -322,8 +322,7 @@ module Google
 
           doc_path = coalesce_doc_path_argument doc
 
-          @writes << Convert.writes_for_update(doc_path, data,
-                                               update_time: update_time)
+          @writes << Convert.write_for_update(doc_path, data, update_time: update_time)
 
           nil
         end

data/lib/google/cloud/firestore/client.rb

@@ -100,11 +100,11 @@ module Google
         #     puts col.collection_id
         #   end
         #
-        def cols
+        def cols &block
           ensure_service!
           grpc = service.list_collections "#{path}/documents"
           cols_enum = CollectionReferenceList.from_grpc(grpc, self, "#{path}/documents").all
-          cols_enum.each { |c| yield c } if block_given?
+          cols_enum.each(&block) if block_given?
           cols_enum
         end
         alias collections cols
@@ -256,7 +256,7 @@ module Google
           ensure_service!
 
           unless block_given?
-            return enum_for :get_all, docs, field_mask: field_mask
+            return enum_for :get_all, *docs, field_mask: field_mask
           end
 
           doc_paths = Array(docs).flatten.map do |doc_path|
@@ -634,9 +634,9 @@ module Google
             commit_return = transaction.commit
             # Conditional return value, depending on truthy commit_response
             commit_response ? commit_return : transaction_return
-          rescue Google::Cloud::UnavailableError => err
+          rescue Google::Cloud::UnavailableError => e
             # Re-raise if retried more than the max
-            raise err if backoff[:current] > backoff[:max]
+            raise e if backoff[:current] > backoff[:max]
 
             # Sleep with incremental backoff before restarting
             sleep backoff[:delay]
@@ -649,18 +649,18 @@ module Google
             transaction = Transaction.from_client \
               self, previous_transaction: transaction.transaction_id
             retry
-          rescue Google::Cloud::InvalidArgumentError => err
+          rescue Google::Cloud::InvalidArgumentError => e
             # Return if a previous call was retried but ultimately succeeded
-            return nil if backoff[:current] > 0
+            return nil if backoff[:current].positive?
 
             # Re-raise error.
-            raise err
-          rescue StandardError => err
+            raise e
+          rescue StandardError => e
             # Rollback transaction when handling unexpected error
             transaction.rollback rescue nil
 
             # Re-raise error.
-            raise err
+            raise e
           end
         end
 

data/lib/google/cloud/firestore/collection_reference_list.rb

@@ -90,17 +90,17 @@ module Google
         #     collection_reference.collection_id
         #   end
         #
-        def all request_limit: nil
+        def all request_limit: nil, &block
           request_limit = request_limit.to_i if request_limit
           unless block_given?
             return enum_for :all, request_limit: request_limit
           end
           results = self
           loop do
-            results.each { |r| yield r }
+            results.each(&block)
             if request_limit
               request_limit -= 1
-              break if request_limit < 0
+              break if request_limit.negative?
             end
             break unless results.next?
             results = results.next

data/lib/google/cloud/firestore/convert.rb

@@ -24,7 +24,12 @@ module Google
       ##
       # @private Helper module for converting Protobuf values.
       module Convert
-        # rubocop:disable all
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/BlockLength
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/ModuleLength
+        # rubocop:disable Metrics/PerceivedComplexity
         module ClassMethods
           def time_to_timestamp time
             return nil if time.nil?
@@ -32,9 +37,10 @@ module Google
             # Force the object to be a Time object.
             time = time.to_time
 
-            Google::Protobuf::Timestamp.new \
+            Google::Protobuf::Timestamp.new(
               seconds: time.to_i,
-              nanos: time.nsec
+              nanos:   time.nsec
+            )
           end
 
           def timestamp_to_time timestamp
@@ -100,9 +106,10 @@ module Google
             elsif Google::Cloud::Firestore::DocumentReference === obj
               Google::Cloud::Firestore::V1::Value.new reference_value: obj.path
             elsif Array === obj
-              values = obj.map { |o| raw_to_value(o) }
-              Google::Cloud::Firestore::V1::Value.new(array_value:
-                Google::Cloud::Firestore::V1::ArrayValue.new(values: values))
+              values = obj.map { |o| raw_to_value o }
+              Google::Cloud::Firestore::V1::Value.new(
+                array_value: Google::Cloud::Firestore::V1::ArrayValue.new(values: values)
+              )
             elsif Hash === obj
               # keys have been changed to strings before the hash gets here
               geo_pairs = hash_is_geo_point? obj
@@ -112,8 +119,9 @@ module Google
                 )
               else
                 fields = hash_to_fields obj
-                Google::Cloud::Firestore::V1::Value.new(map_value:
-                  Google::Cloud::Firestore::V1::MapValue.new(fields: fields))
+                Google::Cloud::Firestore::V1::Value.new(
+                  map_value: Google::Cloud::Firestore::V1::MapValue.new(fields: fields)
+                )
               end
             elsif obj.respond_to?(:read) && obj.respond_to?(:rewind)
               obj.rewind
@@ -129,9 +137,7 @@ module Google
             return false unless hash.keys.count == 2
 
             pairs = hash.map { |k, v| [String(k), v] }.sort
-            if pairs.map(&:first) == ["latitude", "longitude"]
-              pairs
-            end
+            pairs if pairs.map(&:first) == ["latitude", "longitude"]
           end
 
           def hash_to_geo_point hash, pairs = nil
@@ -140,47 +146,39 @@ module Google
             raise ArgumentError, "value is not a geo point" unless pairs
 
             Google::Type::LatLng.new(
-              latitude: pairs.first.last,
-              longitude: pairs.last.last,
+              latitude:  pairs.first.last,
+              longitude: pairs.last.last
             )
           end
 
-          def writes_for_create doc_path, data
-            writes = []
-
-            if is_field_value_nested data, :delete
+          def write_for_create doc_path, data
+            if field_value_nested? data, :delete
               raise ArgumentError, "DELETE not allowed on create"
             end
             raise ArgumentError, "data is required" unless data.is_a? Hash
 
             data, field_paths_and_values = remove_field_value_from data
 
-            if data.any? || field_paths_and_values.empty?
-              write = Google::Cloud::Firestore::V1::Write.new(
-                update: Google::Cloud::Firestore::V1::Document.new(
-                  name: doc_path,
-                  fields: hash_to_fields(data)),
-                current_document: Google::Cloud::Firestore::V1::Precondition.new(
-                  exists: false)
-              )
-              writes << write
-            end
-
-            if field_paths_and_values.any?
-              transform_write = transform_write doc_path, field_paths_and_values
-
-              if data.empty?
-                transform_write.current_document = \
-                  Google::Cloud::Firestore::V1::Precondition.new(exists: false)
-              end
-
-              writes << transform_write
-            end
+            doc = Google::Cloud::Firestore::V1::Document.new(
+              name:   doc_path,
+              fields: hash_to_fields(data)
+            )
+            precondition = Google::Cloud::Firestore::V1::Precondition.new exists: false
+            Google::Cloud::Firestore::V1::Write.new(
+              update:            doc,
+              current_document:  precondition,
+              update_transforms: field_transforms(field_paths_and_values)
+            )
+          end
 
-            writes
+          def field_transforms paths
+            return nil if paths.empty?
+            paths.map do |field_path, field_value|
+              to_field_transform field_path, field_value
+            end.to_a
           end
 
-          def writes_for_set doc_path, data, merge: nil
+          def write_for_set doc_path, data, merge: nil
             raise ArgumentError, "data is required" unless data.is_a? Hash
 
             if merge
@@ -195,11 +193,9 @@ module Google
                 end
                 allow_empty = false
               end
-              return writes_for_set_merge doc_path, data, field_paths, allow_empty
+              return write_for_set_merge doc_path, data, field_paths, allow_empty
             end
 
-            writes = []
-
             data, delete_paths = remove_field_value_from data, :delete
             if delete_paths.any?
               raise ArgumentError, "DELETE not allowed on set"
@@ -207,30 +203,25 @@ module Google
 
             data, field_paths_and_values = remove_field_value_from data
 
-            writes << Google::Cloud::Firestore::V1::Write.new(
-              update: Google::Cloud::Firestore::V1::Document.new(
-                name: doc_path,
-                fields: hash_to_fields(data))
+            doc = Google::Cloud::Firestore::V1::Document.new(
+              name:   doc_path,
+              fields: hash_to_fields(data)
+            )
+            Google::Cloud::Firestore::V1::Write.new(
+              update:            doc,
+              update_transforms: field_transforms(field_paths_and_values)
             )
-
-            if field_paths_and_values.any?
-              writes << transform_write(doc_path, field_paths_and_values)
-            end
-
-            writes
           end
 
-          def writes_for_set_merge doc_path, data, field_paths, allow_empty
+          def write_for_set_merge doc_path, data, field_paths, allow_empty
             raise ArgumentError, "data is required" unless data.is_a? Hash
 
             validate_field_paths! field_paths
 
-            writes = []
-
             # Ensure provided field paths are valid.
             all_valid = identify_leaf_nodes data
             all_valid_check = field_paths.map do |verify_path|
-              if all_valid.include?(verify_path)
+              if all_valid.include? verify_path
                 true
               else
                 found_in_all_valid = all_valid.select do |fp|
@@ -271,32 +262,25 @@ module Google
             # Restore delete paths
             field_paths += delete_field_paths_and_values.keys
 
-            if data.empty? && !allow_empty
-              if field_paths_and_values.empty? && delete_field_paths_and_values.empty?
-                raise ArgumentError, "data required for set with merge"
-              end
+            if data.empty? && !allow_empty && field_paths_and_values.empty? && delete_field_paths_and_values.empty?
+              raise ArgumentError, "data required for set with merge"
             end
 
-            if data.any? || field_paths.any? || (allow_empty && field_paths_and_values.empty?)
-              writes << Google::Cloud::Firestore::V1::Write.new(
-                update: Google::Cloud::Firestore::V1::Document.new(
-                  name: doc_path,
-                  fields: hash_to_fields(data)),
-                update_mask: Google::Cloud::Firestore::V1::DocumentMask.new(
-                  field_paths: field_paths.map(&:formatted_string).sort)
-              )
-            end
-
-            if field_paths_and_values.any?
-              writes << transform_write(doc_path, field_paths_and_values)
-            end
-
-            writes
+            doc = Google::Cloud::Firestore::V1::Document.new(
+              name:   doc_path,
+              fields: hash_to_fields(data)
+            )
+            doc_mask = Google::Cloud::Firestore::V1::DocumentMask.new(
+              field_paths: field_paths.map(&:formatted_string).sort
+            )
+            Google::Cloud::Firestore::V1::Write.new(
+              update:            doc,
+              update_mask:       doc_mask,
+              update_transforms: field_transforms(field_paths_and_values)
+            )
           end
 
-          def writes_for_update doc_path, data, update_time: nil
-            writes = []
-
+          def write_for_update doc_path, data, update_time: nil
             raise ArgumentError, "data is required" unless data.is_a? Hash
 
             # Convert data to use FieldPath
@@ -308,11 +292,11 @@ module Google
             # Duplicate field paths check
             validate_field_paths! new_data_pairs.map(&:first)
 
-            delete_paths, new_data_pairs = new_data_pairs.partition do |field_path, value|
+            delete_paths, new_data_pairs = new_data_pairs.partition do |_field_path, value|
               value.is_a?(FieldValue) && value.type == :delete
             end
 
-            root_field_paths_and_values, new_data_pairs = new_data_pairs.partition do |field_path, value|
+            root_field_paths_and_values, new_data_pairs = new_data_pairs.partition do |_field_path, value|
               value.is_a? FieldValue
             end
 
@@ -325,7 +309,7 @@ module Google
             data, nested_deletes = remove_field_value_from data, :delete
             raise ArgumentError, "DELETE cannot be nested" if nested_deletes.any?
 
-            data, nested_field_paths_and_values  = remove_field_value_from data
+            data, nested_field_paths_and_values = remove_field_value_from data
 
             field_paths_and_values = root_field_paths_and_values.merge nested_field_paths_and_values
 
@@ -338,34 +322,31 @@ module Google
               raise ArgumentError, "data is required"
             end
 
+            write = Google::Cloud::Firestore::V1::Write.new(
+              update:           Google::Cloud::Firestore::V1::Document.new(name: doc_path),
+              update_mask:      Google::Cloud::Firestore::V1::DocumentMask.new,
+              current_document: Google::Cloud::Firestore::V1::Precondition.new(exists: true)
+            )
+
             if data.any? || delete_paths.any?
-              write = Google::Cloud::Firestore::V1::Write.new(
-                update: Google::Cloud::Firestore::V1::Document.new(
-                  name: doc_path,
-                  fields: hash_to_fields(data)),
-                update_mask: Google::Cloud::Firestore::V1::DocumentMask.new(
-                  field_paths: (field_paths).map(&:formatted_string).sort),
-                current_document: Google::Cloud::Firestore::V1::Precondition.new(
-                  exists: true)
-              )
+              htf = hash_to_fields data
+              htf.each_pair do |k, v|
+                write.update.fields[k] = v
+              end
+              write.update_mask.field_paths += field_paths.map(&:formatted_string).sort
+
               if update_time
-                write.current_document = \
-                  Google::Cloud::Firestore::V1::Precondition.new(
-                    update_time: time_to_timestamp(update_time))
+                write.current_document = Google::Cloud::Firestore::V1::Precondition.new(
+                  update_time: time_to_timestamp(update_time)
+                )
               end
-              writes << write
             end
 
             if field_paths_and_values.any?
-              transform_write = transform_write doc_path, field_paths_and_values
-              if data.empty?
-                transform_write.current_document = \
-                  Google::Cloud::Firestore::V1::Precondition.new(exists: true)
-              end
-              writes << transform_write
+              write.update_transforms += field_transforms field_paths_and_values
             end
 
-            writes
+            write
           end
 
           def write_for_delete doc_path, exists: nil, update_time: nil
@@ -387,13 +368,20 @@ module Google
             write
           end
 
-          def is_field_value_nested obj, field_value_type = nil
+          def field_value_nested? obj, field_value_type = nil
             return obj if obj.is_a?(FieldValue) && (field_value_type.nil? || obj.type == field_value_type)
 
-            if obj.is_a? Array
-              obj.each { |o| val = is_field_value_nested o, field_value_type; return val if val }
-            elsif obj.is_a? Hash
-              obj.each { |_k, v| val = is_field_value_nested v, field_value_type; return val if val }
+            case obj
+            when Array
+              obj.each do |o|
+                val = field_value_nested? o, field_value_type
+                return val if val
+              end
+            when Hash
+              obj.each do |_k, v|
+                val = field_value_nested? v, field_value_type
+                return val if val
+              end
             end
             nil
           end
@@ -406,35 +394,33 @@ module Google
               if value.is_a?(FieldValue) && (field_value_type.nil? || value.type == field_value_type)
                 paths << [FieldPath.new(*key), value]
                 nil # will be removed by calling compact
-              else
-                if value.is_a? Hash
-                  unless value.empty?
-                    nested_hash, nested_paths = remove_field_value_from value, field_value_type
-                    if nested_paths.any?
-                      nested_paths.each do |nested_field_path, nested_field_value|
-                        updated_field_paths = ([key] + nested_field_path.fields).flatten
-                        updated_field_path = FieldPath.new *updated_field_paths
-                        paths << [updated_field_path, nested_field_value]
-                      end
-                    end
-                    if nested_hash.empty?
-                      nil # will be removed by calling compact
-                    else
-                      [String(key), nested_hash]
+              elsif value.is_a? Hash
+                if value.empty?
+                  [String(key), value]
+                else
+                  nested_hash, nested_paths = remove_field_value_from value, field_value_type
+                  if nested_paths.any?
+                    nested_paths.each do |nested_field_path, nested_field_value|
+                      updated_field_paths = ([key] + nested_field_path.fields).flatten
+                      updated_field_path = FieldPath.new(*updated_field_paths)
+                      paths << [updated_field_path, nested_field_value]
                     end
+                  end
+                  if nested_hash.empty?
+                    nil # will be removed by calling compact
                   else
-                    [String(key), value]
+                    [String(key), nested_hash]
                   end
-                else
-                  if value.is_a? Array
-                    nested_field_value = is_field_value_nested value, field_value_type
-                    if nested_field_value
-                      raise ArgumentError, "cannot nest #{nested_field_value.type} under arrays"
-                    end
+                end
+              else
+                if value.is_a? Array
+                  nested_field_value = field_value_nested? value, field_value_type
+                  if nested_field_value
+                    raise ArgumentError, "cannot nest #{nested_field_value.type} under arrays"
                   end
-
-                  [String(key), value]
                 end
+
+                [String(key), value]
               end
             end
 
@@ -449,14 +435,14 @@ module Google
               if value.is_a? Hash
                 nested_paths = identify_leaf_nodes value
                 nested_paths.each do |nested_path|
-                  paths << (([key] + nested_path.fields).flatten)
+                  paths << ([key] + nested_path.fields).flatten
                 end
               else
                 paths << [key]
               end
             end
 
-            paths.map { |path| FieldPath.new *path }
+            paths.map { |path| FieldPath.new(*path) }
           end
 
           def identify_all_file_paths hash
@@ -465,15 +451,14 @@ module Google
             hash.map do |key, value|
               paths << [key]
 
-              if value.is_a? Hash
-                nested_paths = identify_all_file_paths value
-                nested_paths.each do |nested_path|
-                  paths << (([key] + nested_path.fields).flatten)
-                end
+              next unless value.is_a? Hash
+              nested_paths = identify_all_file_paths value
+              nested_paths.each do |nested_path|
+                paths << ([key] + nested_path.fields).flatten
               end
             end
 
-            paths.map { |path| FieldPath.new *path }
+            paths.map { |path| FieldPath.new(*path) }
           end
 
           def select_by_field_paths hash, field_paths
@@ -533,19 +518,19 @@ module Google
             right_hash.each_pair do |key, right_value|
               left_value = left_hash[key]
 
-              if left_value.is_a?(Hash) && right_value.is_a?(Hash)
-                left_hash[key] = deep_merge_hashes left_value, right_value
-              else
-                left_hash[key] = right_value
-              end
+              left_hash[key] = if left_value.is_a?(Hash) && right_value.is_a?(Hash)
+                                 deep_merge_hashes left_value, right_value
+                               else
+                                 right_value
+                               end
             end
 
             left_hash
           end
 
-          START_FIELD_PATH_CHARS = /\A[a-zA-Z_]/
-          INVALID_FIELD_PATH_CHARS = /[\~\*\/\[\]]/
-          ESCAPED_FIELD_PATH = /\A\`(.*)\`\z/
+          START_FIELD_PATH_CHARS = /\A[a-zA-Z_]/.freeze
+          INVALID_FIELD_PATH_CHARS = %r{[~*/\[\]]}.freeze
+          ESCAPED_FIELD_PATH = /\A`(.*)`\z/.freeze
 
           def build_hash_from_field_paths_and_values pairs
             pairs.each do |field_path, _value|
@@ -579,59 +564,52 @@ module Google
             "`#{str}`"
           end
 
-          def transform_write doc_path, paths
-            field_transforms = paths.map do |field_path, field_value|
-              to_field_transform field_path, field_value
-            end
-
-            Google::Cloud::Firestore::V1::Write.new(
-              transform: Google::Cloud::Firestore::V1::DocumentTransform.new(
-                document: doc_path,
-                field_transforms: field_transforms
-              )
-            )
-          end
-
           def to_field_transform field_path, field_value
-            if field_value.type == :server_time
+            case field_value.type
+            when :server_time
               Google::Cloud::Firestore::V1::DocumentTransform::FieldTransform.new(
-                field_path: field_path.formatted_string,
+                field_path:          field_path.formatted_string,
                 set_to_server_value: :REQUEST_TIME
               )
-            elsif field_value.type == :array_union
+            when :array_union
               Google::Cloud::Firestore::V1::DocumentTransform::FieldTransform.new(
-                field_path: field_path.formatted_string,
+                field_path:              field_path.formatted_string,
                 append_missing_elements: raw_to_value(Array(field_value.value)).array_value
               )
-            elsif field_value.type == :array_delete
+            when :array_delete
               Google::Cloud::Firestore::V1::DocumentTransform::FieldTransform.new(
-                field_path: field_path.formatted_string,
+                field_path:            field_path.formatted_string,
                 remove_all_from_array: raw_to_value(Array(field_value.value)).array_value
               )
-            elsif field_value.type == :increment
+            when :increment
               Google::Cloud::Firestore::V1::DocumentTransform::FieldTransform.new(
                 field_path: field_path.formatted_string,
-                increment: raw_to_value(field_value.value)
+                increment:  raw_to_value(field_value.value)
               )
-            elsif field_value.type == :maximum
+            when :maximum
               Google::Cloud::Firestore::V1::DocumentTransform::FieldTransform.new(
                 field_path: field_path.formatted_string,
-                maximum: raw_to_value(field_value.value)
+                maximum:    raw_to_value(field_value.value)
               )
-            elsif field_value.type == :minimum
+            when :minimum
               Google::Cloud::Firestore::V1::DocumentTransform::FieldTransform.new(
                 field_path: field_path.formatted_string,
-                minimum: raw_to_value(field_value.value)
+                minimum:    raw_to_value(field_value.value)
               )
             else
               raise ArgumentError, "unknown field transform #{field_value.type}"
             end
           end
         end
-        # rubocop:enable all
 
         extend ClassMethods
       end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/BlockLength
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/ModuleLength
+      # rubocop:enable Metrics/PerceivedComplexity
     end
   end
 end