google-cloud-firestore 2.2.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c1c6b4bcea222f6ed81150700b9d6c969fc70eeb8492db0ed69db1bb43f62cb
-  data.tar.gz: 50bbd220cf388af656606d99948477d47f9a1fa3d41ab479f6fcaa32f32e909d
+  metadata.gz: 8d0f9ea11dcd132795aca2ffe91250ca03fce477e6fdcb3aafc7e9d01560b172
+  data.tar.gz: 3701797b2412e82cdf227fe9d162291e53e2aaf4a1c3cc8d37d18ea0a9795f1c
 SHA512:
-  metadata.gz: d1a810ae1cd779858ad8762dacd08765b2daf06b1de8ce13dc675b79ef7c6696c3bbda34d7593a6087e2189aebd2e23090bd89d11da8753f1751726270a61391
-  data.tar.gz: af77949c47636ca6e65ca14224fa5270a9f3daa4c00fd236e19780273e35593c0986ba5e5a0d601a6f107cbdc5482db51ca002841ee8cbf21acbd9ac752a93ee
+  metadata.gz: e8ce0745147c89e081b94f08a3753bc0a234f1a2e9a5eb9eb15cfc798abbb01e5970fb354db0ff6b71096353dabe2a023e8cba7d5d4c909f20793f953473044d
+  data.tar.gz: 489e87876e77584f429472f12c157b0c1412d336190b3a8a88e706e262c3d0409b4b00c55207ebd6cab15f0a6ae7b1ad45177c8dfcc87408cd96384db1a11038

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Release History
 
+### 2.5.1 / 2021-04-19
+
+#### Bug Fixes
+
+* Add GRPC::Unknown to retryable errors in Watch::Listener
+
+### 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

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
@@ -119,15 +119,14 @@ If you alter an example's title, you may encounter breaking tests.
 ### Firestore Acceptance Tests
 
 The Firestore acceptance tests interact with the live service API. Follow the
-instructions in the {file:AUTHENTICATION.md Authentication guide} for enabling
+instructions in the {file:AUTHENTICATION.md Authentication Guide} for enabling
 the Firestore API. Occasionally, some API features may not yet be generally
 available, making it difficult for some contributors to successfully run the
 entire acceptance test suite. However, please ensure that you do successfully
 run acceptance tests for any code areas covered by your pull request.
 
 To run the acceptance tests, first create and configure a project in the Google
-Developers Console, as described in the {file:AUTHENTICATION.md Authentication
-guide}. Be sure to download the JSON KEY file. Make note of the PROJECT_ID and
+Developers Console, as described in the {file:AUTHENTICATION.md Authentication Guide}. Be sure to download the JSON KEY file. Make note of the PROJECT_ID and
 the KEYFILE location on your system.
 
 Before you can run the Firestore acceptance tests, you must first create indexes

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/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