google-cloud-firestore 2.3.0 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12a9c7f721487eef84a1d703f77f0b2f56aea624fc9c6e1052be059c49437a6f
-  data.tar.gz: 76d354bb9933a7a83ef6163fef5bd37da82808786f05d06a83f54dc605ca1154
+  metadata.gz: 3141b004673c1db562f162d9218ac680c0693e4d91a8eb48b7d17f444646e74a
+  data.tar.gz: 4ab2bb6f69da5f8ad2e53464ae3712647b3642d49a465dc5f75d1dbc923979f5
 SHA512:
-  metadata.gz: b8e403df8684221a0521432017c511f8b0c4d174c97c95129f7952e6751914093fe692585127d2f0a267f9776b9a464062bd10e3f3a7d9aa7c772edcddde8d2e
-  data.tar.gz: bd858f3f1c199b835ce22f567068af585f9ce41d2cd9da6811f5d06bbcc45ab1aadaa40575d1684bb2245d691c90589df420343a0233039f860030513037de75
+  metadata.gz: fd5dccbe067d6fea81556aae40b9fc9de2ca75fc389c919335217371d84578b68ad7c9854c84831bb368dd58982849c06f044cef0c864be586cdace0ea48994a
+  data.tar.gz: 7a7f0ee2a3259f2a65119b0b31dbf781d7336f7c530301f4c7f0a7fdf95fea8a7773caa4ed172c9ce8c5ff9f9fe80dab830f37ef1e6d204ae7d770fdf9c066c0

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Release History
 
+### 2.6.0 / 2021-06-15
+
+#### Features
+
+* Add support for Query Partitions
+  * Add CollectionGroup
+  * Update Client#col_group to return CollectionGroup (subclass of Query)
+  * Add QueryPartition
+  * Add QueryPartition::List
+  * Add Query#to_json and Query.from_json
+
+### 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

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

@@ -20,6 +20,7 @@ require "google/cloud/firestore/field_value"
 require "google/cloud/firestore/collection_reference"
 require "google/cloud/firestore/document_reference"
 require "google/cloud/firestore/document_snapshot"
+require "google/cloud/firestore/collection_group"
 require "google/cloud/firestore/batch"
 require "google/cloud/firestore/transaction"
 
@@ -100,11 +101,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
@@ -139,7 +140,7 @@ module Google
         alias collection col
 
         ##
-        # Creates and returns a new Query that includes all documents in the
+        # Creates and returns a new collection group that includes all documents in the
         # database that are contained in a collection or subcollection with the
         # given collection_id.
         #
@@ -147,7 +148,7 @@ module Google
         #   over. Every collection or subcollection with this ID as the last
         #   segment of its path will be included. Cannot contain a slash (`/`).
         #
-        # @return [Query] The created Query.
+        # @return [CollectionGroup] The created collection group.
         #
         # @example
         #   require "google/cloud/firestore"
@@ -155,9 +156,9 @@ module Google
         #   firestore = Google::Cloud::Firestore.new
         #
         #   # Get the cities collection group query
-        #   query = firestore.col_group "cities"
+        #   col_group = firestore.col_group "cities"
         #
-        #   query.get do |city|
+        #   col_group.get do |city|
         #     puts "#{city.document_id} has #{city[:population]} residents."
         #   end
         #
@@ -166,15 +167,8 @@ module Google
             raise ArgumentError, "Invalid collection_id: '#{collection_id}', " \
               "must not contain '/'."
           end
-          query = Google::Cloud::Firestore::V1::StructuredQuery.new(
-            from: [
-              Google::Cloud::Firestore::V1::StructuredQuery::CollectionSelector.new(
-                collection_id: collection_id, all_descendants: true
-              )
-            ]
-          )
-
-          Query.start query, service.documents_path, self
+
+          CollectionGroup.from_collection_id service.documents_path, collection_id, self
         end
         alias collection_group col_group
 
@@ -256,7 +250,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 +628,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 +643,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_group.rb

@@ -0,0 +1,136 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require "google/cloud/firestore/v1"
+require "google/cloud/firestore/query"
+require "google/cloud/firestore/query_partition"
+
+module Google
+  module Cloud
+    module Firestore
+      ##
+      # # CollectionGroup
+      #
+      # A collection group object is used for adding documents, getting
+      # document references, and querying for documents, including with partitions.
+      #
+      # See {Client#col_group} and {Query}.
+      #
+      # @example
+      #   require "google/cloud/firestore"
+      #
+      #   firestore = Google::Cloud::Firestore.new
+      #
+      #   # Get a collection group
+      #   col_group = firestore.col_group "cities"
+      #
+      #   # Get and print all city documents
+      #   col_group.get do |city|
+      #     puts "#{city.document_id} has #{city[:population]} residents."
+      #   end
+      #
+      class CollectionGroup < Query
+        ##
+        # Partitions a query by returning partition cursors that can be used to run the query in parallel. The returned
+        # partition cursors are split points that can be used as starting/end points for the query results.
+        #
+        # @param [Integer] partition_count The desired maximum number of partition points. The number must be strictly
+        #   positive. The actual number of partitions returned may be fewer.
+        #
+        # @return [Array<QueryPartition>] An ordered array of query partitions.
+        #
+        # @example
+        #   require "google/cloud/firestore"
+        #
+        #   firestore = Google::Cloud::Firestore.new
+        #
+        #   col_group = firestore.col_group "cities"
+        #
+        #   partitions = col_group.partitions 3
+        #
+        #   queries = partitions.map(&:to_query)
+        #
+        def partitions partition_count
+          ensure_service!
+
+          raise ArgumentError, "partition_count must be > 0" unless partition_count.positive?
+
+          # Partition queries require explicit ordering by __name__.
+          query_with_default_order = order "__name__"
+          # Since we are always returning an extra partition (with en empty endBefore cursor), we reduce the desired
+          # partition count by one.
+          partition_count -= 1
+
+          grpc_partitions = if partition_count.positive?
+                              # Retrieve all pages, since cursor order is not guaranteed and they must be sorted.
+                              list_all partition_count, query_with_default_order
+                            else
+                              [] # Ensure that a single, empty QueryPartition is returned.
+                            end
+          cursor_values = grpc_partitions.map do |cursor|
+            # Convert each cursor to a (single-element) array of Google::Cloud::Firestore::DocumentReference.
+            cursor.values.map do |value|
+              Convert.value_to_raw value, client
+            end
+          end
+          # Sort the values of the returned cursor, which right now should only contain a single reference value (which
+          # needs to be sorted one component at a time).
+          cursor_values.sort! do |a, b|
+            a.first <=> b.first
+          end
+
+          start_at = nil
+          results = cursor_values.map do |end_before|
+            partition = QueryPartition.new query_with_default_order, start_at, end_before
+            start_at = end_before
+            partition
+          end
+          # Always add a final QueryPartition with an empty end_before value.
+          results << QueryPartition.new(query_with_default_order, start_at, nil)
+          results
+        end
+
+        ##
+        # @private New Collection group object from a path.
+        def self.from_collection_id parent_path, collection_id, client
+          query = Google::Cloud::Firestore::V1::StructuredQuery.new(
+            from: [
+              Google::Cloud::Firestore::V1::StructuredQuery::CollectionSelector.new(
+                collection_id: collection_id,
+                all_descendants: true
+              )
+            ]
+          )
+          CollectionGroup.new query, parent_path, client
+        end
+
+        protected
+
+        def list_all partition_count, query_with_default_order
+          grpc_partitions = []
+          token = nil
+          loop do
+            grpc = service.partition_query parent_path, query_with_default_order.query, partition_count, token: token
+            grpc_partitions += Array(grpc.partitions)
+            token = grpc.next_page_token
+            token = nil if token == ""
+            break unless token
+          end
+          grpc_partitions
+        end
+      end
+    end
+  end
+end

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

@@ -14,9 +14,9 @@
 
 
 require "google/cloud/firestore/v1"
+require "google/cloud/firestore/query"
 require "google/cloud/firestore/document_reference"
 require "google/cloud/firestore/document_snapshot"
-require "google/cloud/firestore/query"
 require "google/cloud/firestore/generate"
 require "google/cloud/firestore/collection_reference_list"
 
@@ -47,6 +47,13 @@ module Google
         # @private The firestore client object.
         attr_accessor :client
 
+        ##
+        # @private Creates a new CollectionReference.
+        def initialize query, path, client
+          super query, nil, client # Pass nil parent_path arg since this class implements #parent_path
+          @path = path
+        end
+
         ##
         # The collection identifier for the collection resource.
         #
@@ -257,11 +264,7 @@ module Google
             ]
           )
 
-          new.tap do |c|
-            c.client = client
-            c.instance_variable_set :@path, path
-            c.instance_variable_set :@query, query
-          end
+          CollectionReference.new query, path, client
         end
 
         protected

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