style.sh

Firestore/Example/Tests/Integration/FSTDatastoreTests.mm

@@ -204,7 +204,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)testCommit {
   XCTestExpectation *expectation = [self expectationWithDescription:@"commitWithCompletion"];
 
-  _datastore->CommitMutations({}, [self, expectation](const Status& status) {
+  _datastore->CommitMutations({}, [self, expectation](const Status &status) {
     XCTAssertTrue(status.ok(), @"Failed to commit");
     [expectation fulfill];
   });

Firestore/Source/API/FIRFirestore.mm

@@ -288,7 +288,8 @@ extern "C" NSString *const FIRFirestoreErrorDomain = @"FIRFirestoreErrorDomain";
       ^(std::shared_ptr<Transaction> internalTransaction,
         void (^internalCompletion)(id _Nullable, NSError *_Nullable)) {
         FIRTransaction *transaction =
-            [FIRTransaction transactionWithInternalTransaction:std::move(internalTransaction) firestore:self];
+            [FIRTransaction transactionWithInternalTransaction:std::move(internalTransaction)
+                                                     firestore:self];
         dispatch_async(queue, ^{
           NSError *_Nullable error = nil;
           id _Nullable result = updateBlock(transaction, &error);

Firestore/Source/API/FIRTransaction+Internal.h

@@ -24,7 +24,8 @@
 
 @interface FIRTransaction (Internal)
 
-+ (instancetype)transactionWithInternalTransaction:(std::shared_ptr<firebase::firestore::core::Transaction>)transaction
-                                    firestore:(FIRFirestore *)firestore;
++ (instancetype)transactionWithInternalTransaction:
+                    (std::shared_ptr<firebase::firestore::core::Transaction>)transaction
+                                         firestore:(FIRFirestore *)firestore;
 
 @end

Firestore/Source/API/FIRTransaction.mm

@@ -18,6 +18,7 @@
 
 #include <memory>
 #include <utility>
+#include <vector>
 
 #import "Firestore/Source/API/FIRDocumentReference+Internal.h"
 #import "Firestore/Source/API/FIRDocumentSnapshot+Internal.h"
@@ -53,7 +54,7 @@ NS_ASSUME_NONNULL_BEGIN
 @implementation FIRTransaction (Internal)
 
 + (instancetype)transactionWithInternalTransaction:(std::shared_ptr<Transaction>)transaction
-                                    firestore:(FIRFirestore *)firestore {
+                                         firestore:(FIRFirestore *)firestore {
   return [[FIRTransaction alloc] initWithTransaction:std::move(transaction) firestore:firestore];
 }
 
@@ -116,8 +117,8 @@ NS_ASSUME_NONNULL_BEGIN
                               NSError *_Nullable error))completion {
   [self validateReference:document];
   _internalTransaction->Lookup(
-      {document.key},
-      [self, document, completion](const std::vector<FSTMaybeDocument *> &documents, const Status &status) {
+      {document.key}, [self, document, completion](const std::vector<FSTMaybeDocument *> &documents,
+                                                   const Status &status) {
         if (!status.ok()) {
           completion(nil, MakeNSError(status));
           return;

Firestore/Source/Core/FSTSyncEngine.mm

@@ -302,7 +302,8 @@ class LimboResolution {
             completion(nil, error);
             return;
           }
-          transaction->Commit([self, retries, workerQueue, updateBlock, completion, result](const Status& status) {
+          transaction->Commit([self, retries, workerQueue, updateBlock, completion,
+                               result](const Status &status) {
             if (status.ok()) {
               completion(result, nil);
               return;

Firestore/Source/Core/FSTTypes.h

@@ -18,7 +18,13 @@
 
 #include <memory>
 
-namespace firebase { namespace firestore { namespace core { class Transaction; } } }
+namespace firebase {
+namespace firestore {
+namespace core {
+class Transaction;
+}
+}
+}
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -56,7 +62,8 @@ typedef void (^FSTVoidMaybeDocumentArrayErrorBlock)(
  *                    transaction.
  * @param completion To be called by the block once the user's code is finished.
  */
-typedef void (^FSTTransactionBlock)(std::shared_ptr<firebase::firestore::core::Transaction> transaction,
-                                    void (^completion)(id _Nullable, NSError *_Nullable));
+typedef void (^FSTTransactionBlock)(
+    std::shared_ptr<firebase::firestore::core::Transaction> transaction,
+    void (^completion)(id _Nullable, NSError *_Nullable));
 
 NS_ASSUME_NONNULL_END

Firestore/Source/Local/FSTLocalStore.mm

@@ -376,9 +376,10 @@ static const int64_t kResumeTokenMaxAgeSeconds = 5 * 60;  // 5 minutes
 }
 
 - (nullable FSTMaybeDocument *)readDocument:(const DocumentKey &)key {
-  return self.persistence.run("ReadDocument", [&]() -> FSTMaybeDocument *_Nullable {
-    return [self.localDocuments documentForKey:key];
-  });
+  return self.persistence.run(
+      "ReadDocument", [&]() -> FSTMaybeDocument *_Nullable {
+        return [self.localDocuments documentForKey:key];
+      });
 }
 
 - (FSTQueryData *)allocateQuery:(FSTQuery *)query {

Firestore/core/src/firebase/firestore/core/transaction.h

@@ -45,10 +45,10 @@ namespace core {
 
 class Transaction {
  public:
-   // TODO(varconst): once `FSTMaybeDocument` is replaced with a C++ equivalent,
-   // this function could take a single `StatusOr` parameter.
-  using LookupCallback = std::function <
-                         void(const std::vector<FSTMaybeDocument*>&, const util::Status&)>;
+  // TODO(varconst): once `FSTMaybeDocument` is replaced with a C++ equivalent,
+  // this function could take a single `StatusOr` parameter.
+  using LookupCallback = std::function<void(
+      const std::vector<FSTMaybeDocument*>&, const util::Status&)>;
   using CommitCallback = std::function<void(const util::Status&)>;
 
   Transaction() = default;
@@ -58,7 +58,8 @@ class Transaction {
    * Takes a set of keys and asynchronously attempts to fetch all the documents
    * from the backend, ignoring any local changes.
    */
-  void Lookup(const std::vector<model::DocumentKey>& keys, LookupCallback&& callback);
+  void Lookup(const std::vector<model::DocumentKey>& keys,
+              LookupCallback&& callback);
 
   /**
    * Stores mutation for the given key and set data, to be committed when
@@ -86,29 +87,31 @@ class Transaction {
   void Commit(CommitCallback&& callback);
 
  private:
-/**
- * Every time a document is read, this should be called to record its version. If we read two
- * different versions of the same document, this will return an error through its out parameter.
- * When the transaction is committed, the versions recorded will be set as preconditions on the
- * writes sent to the backend.
- */
+  /**
+   * Every time a document is read, this should be called to record its version.
+   * If we read two different versions of the same document, this will return an
+   * error through its out parameter. When the transaction is committed, the
+   * versions recorded will be set as preconditions on the writes sent to the
+   * backend.
+   */
   util::Status RecordVersion(FSTMaybeDocument* doc);
 
   /** Stores mutations to be written when `Commit` is called. */
   void WriteMutations(std::vector<FSTMutation*>&& mutations);
 
-/**
- * Returns version of this doc when it was read in this transaction as a
- * precondition, or no precondition if it was not read.
- */
+  /**
+   * Returns version of this doc when it was read in this transaction as a
+   * precondition, or no precondition if it was not read.
+   */
   model::Precondition CreatePrecondition(const model::DocumentKey& key);
 
-/**
- * Returns the precondition for a document if the operation is an update, based
- * on the provided UpdateOptions. Will return none precondition if an error
- * occurred, in which case it sets the error parameter.
- */
-  util::StatusOr<model::Precondition> CreateUpdatePrecondition(const model::DocumentKey& key);
+  /**
+   * Returns the precondition for a document if the operation is an update,
+   * based on the provided UpdateOptions. Will return none precondition if an
+   * error occurred, in which case it sets the error parameter.
+   */
+  util::StatusOr<model::Precondition> CreateUpdatePrecondition(
+      const model::DocumentKey& key);
 
   void EnsureCommitNotCalled();
 
@@ -117,10 +120,10 @@ class Transaction {
   std::vector<FSTMutation*> mutations_;
   bool commit_called_ = false;
 
-/**
- * An error that may have occurred as a consequence of a write. If set, needs to be raised in the
- * completion handler instead of trying to commit.
- */
+  /**
+   * An error that may have occurred as a consequence of a write. If set, needs
+   * to be raised in the completion handler instead of trying to commit.
+   */
   util::Status last_write_error_;
 
   std::map<model::DocumentKey, model::SnapshotVersion> read_versions_;

Firestore/core/src/firebase/firestore/core/transaction.mm

@@ -110,7 +110,8 @@ Precondition Transaction::CreatePrecondition(const DocumentKey& key) {
   }
 }
 
-StatusOr<Precondition> Transaction::CreateUpdatePrecondition(const DocumentKey& key) {
+StatusOr<Precondition> Transaction::CreateUpdatePrecondition(
+    const DocumentKey& key) {
   const auto iter = read_versions_.find(key);
   if (iter == read_versions_.end()) {
     // Document was not read, so we just use the preconditions for an update.
@@ -177,9 +178,10 @@ void Transaction::Commit(CommitCallback&& callback) {
   if (!unwritten.empty()) {
     // TODO(klimt): This is a temporary restriction, until "verify" is supported
     // on the backend.
-    callback(Status{FirestoreErrorCode::FailedPrecondition,
-             "Every document read in a transaction must also be written in "
-             "that transaction."});
+    callback(
+        Status{FirestoreErrorCode::FailedPrecondition,
+               "Every document read in a transaction must also be written in "
+               "that transaction."});
   } else {
     datastore_->CommitMutations(mutations_, std::move(callback));
   }

Firestore/core/src/firebase/firestore/remote/datastore.h

@@ -68,10 +68,10 @@ namespace remote {
  */
 class Datastore : public std::enable_shared_from_this<Datastore> {
  public:
-   // TODO(varconst): once `FSTMaybeDocument` is replaced with a C++ equivalent,
-   // this function could take a single `StatusOr` parameter.
-  using LookupCallback = std::function <
-                         void(const std::vector<FSTMaybeDocument*>&, const util::Status&)>;
+  // TODO(varconst): once `FSTMaybeDocument` is replaced with a C++ equivalent,
+  // this function could take a single `StatusOr` parameter.
+  using LookupCallback = std::function<void(
+      const std::vector<FSTMaybeDocument*>&, const util::Status&)>;
   using CommitCallback = std::function<void(const util::Status&)>;
 
   Datastore(const core::DatabaseInfo& database_info,

Firestore/core/src/firebase/firestore/remote/datastore.mm

@@ -168,7 +168,8 @@ void Datastore::CommitMutations(const std::vector<FSTMutation*>& mutations,
                                 CommitCallback&& callback) {
   ResumeRpcWithCredentials(
       // TODO(c++14): move into lambda.
-      [this, mutations, callback](const StatusOr<Token>& maybe_credentials) mutable {
+      [this, mutations,
+       callback](const StatusOr<Token>& maybe_credentials) mutable {
         if (!maybe_credentials.ok()) {
           callback(maybe_credentials.status());
           return;
@@ -203,9 +204,8 @@ void Datastore::CommitMutationsWithCredentials(
       });
 }
 
-void Datastore::LookupDocuments(
-    const std::vector<DocumentKey>& keys,
-    LookupCallback&& callback) {
+void Datastore::LookupDocuments(const std::vector<DocumentKey>& keys,
+                                LookupCallback&& callback) {
   ResumeRpcWithCredentials(
       // TODO(c++14): move into lambda.
       [this, keys, callback](const StatusOr<Token>& maybe_credentials) mutable {

Firestore/core/test/firebase/firestore/remote/datastore_test.mm

@@ -16,6 +16,7 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "Firestore/core/src/firebase/firestore/remote/datastore.h"
 #include "Firestore/core/src/firebase/firestore/util/async_queue.h"
@@ -191,13 +192,13 @@ TEST_F(DatastoreTest, LookupDocumentsOneSuccessfulRead) {
   bool done = false;
   std::vector<FSTMaybeDocument*> resulting_docs;
   Status resulting_status;
-  datastore->LookupDocuments({},
-                             [&](const std::vector<FSTMaybeDocument*>& documents,
-                               const Status& status) {
-                               done = true;
-                               resulting_docs = documents;
-                               resulting_status = status;
-                             });
+  datastore->LookupDocuments(
+      {}, [&](const std::vector<FSTMaybeDocument*>& documents,
+              const Status& status) {
+        done = true;
+        resulting_docs = documents;
+        resulting_status = status;
+      });
   // Make sure Auth has a chance to run.
   worker_queue.EnqueueBlocking([] {});
 
@@ -216,13 +217,13 @@ TEST_F(DatastoreTest, LookupDocumentsTwoSuccessfulReads) {
   bool done = false;
   std::vector<FSTMaybeDocument*> resulting_docs;
   Status resulting_status;
-  datastore->LookupDocuments({},
-                             [&](const std::vector<FSTMaybeDocument*>& documents,
-                               const Status& status) {
-                               done = true;
-                               resulting_docs = documents;
-                               resulting_status = status;
-                             });
+  datastore->LookupDocuments(
+      {}, [&](const std::vector<FSTMaybeDocument*>& documents,
+              const Status& status) {
+        done = true;
+        resulting_docs = documents;
+        resulting_status = status;
+      });
   // Make sure Auth has a chance to run.
   worker_queue.EnqueueBlocking([] {});
 
@@ -260,12 +261,12 @@ TEST_F(DatastoreTest, CommitMutationsError) {
 TEST_F(DatastoreTest, LookupDocumentsErrorBeforeFirstRead) {
   bool done = false;
   Status resulting_status;
-  datastore->LookupDocuments({},
-                             [&](const std::vector<FSTMaybeDocument*>& documents,
-                               const Status& status) {
-                               done = true;
-                               resulting_status = status;
-                             });
+  datastore->LookupDocuments(
+      {}, [&](const std::vector<FSTMaybeDocument*>& documents,
+              const Status& status) {
+        done = true;
+        resulting_status = status;
+      });
   // Make sure Auth has a chance to run.
   worker_queue.EnqueueBlocking([] {});
 
@@ -280,12 +281,12 @@ TEST_F(DatastoreTest, LookupDocumentsErrorAfterFirstRead) {
   bool done = false;
   std::vector<FSTMaybeDocument*> resulting_docs;
   Status resulting_status;
-  datastore->LookupDocuments({},
-                             [&](const std::vector<FSTMaybeDocument*>& documents,
-                               const Status& status) {
-                               done = true;
-                               resulting_status = status;
-                             });
+  datastore->LookupDocuments(
+      {}, [&](const std::vector<FSTMaybeDocument*>& documents,
+              const Status& status) {
+        done = true;
+        resulting_status = status;
+      });
   // Make sure Auth has a chance to run.
   worker_queue.EnqueueBlocking([] {});
 
@@ -305,9 +306,8 @@ TEST_F(DatastoreTest, CommitMutationsAuthFailure) {
   credentials.FailGetToken();
 
   Status resulting_status;
-  datastore->CommitMutations({}, [&](const Status& status) {
-    resulting_status = status;
-  });
+  datastore->CommitMutations(
+      {}, [&](const Status& status) { resulting_status = status; });
   worker_queue.EnqueueBlocking([] {});
   EXPECT_FALSE(resulting_status.ok());
 }
@@ -317,8 +317,7 @@ TEST_F(DatastoreTest, LookupDocumentsAuthFailure) {
 
   Status resulting_status;
   datastore->LookupDocuments(
-      {}, [&](const std::vector<FSTMaybeDocument*>& ,
-                               const Status& status) {
+      {}, [&](const std::vector<FSTMaybeDocument*>&, const Status& status) {
         resulting_status = status;
       });
   worker_queue.EnqueueBlocking([] {});