snake_case

Author: wilhuff

Firestore/core/src/firebase/firestore/local/leveldb_key.cc

@@ -122,12 +122,12 @@ void WriteComponentLabel(std::string *dest, ComponentLabel label) {
  * unread byte, and label will be set to the decoded label value.
  */
 bool ReadComponentLabel(absl::string_view *contents, ComponentLabel *label) {
-  int64_t rawResult = 0;
+  int64_t raw_result = 0;
   absl::string_view tmp(contents->data(), contents->size());
-  if (OrderedCode::ReadSignedNumIncreasing(&tmp, &rawResult)) {
-    if (rawResult >= ComponentLabel::Terminator &&
-        rawResult <= ComponentLabel::Unknown) {
-      *label = static_cast<ComponentLabel>(rawResult);
+  if (OrderedCode::ReadSignedNumIncreasing(&tmp, &raw_result)) {
+    if (raw_result >= ComponentLabel::Terminator &&
+        raw_result <= ComponentLabel::Unknown) {
+      *label = static_cast<ComponentLabel>(raw_result);
       *contents = absl::string_view(tmp.data(), tmp.size());
       return true;
     }
@@ -139,18 +139,18 @@ bool ReadComponentLabel(absl::string_view *contents, ComponentLabel *label) {
  * Reads a component label from the given key contents.
  *
  * If the read is unsuccessful or if the read was successful but the label that
- * was read did not match the expectedLabel returns false and changes none of
+ * was read did not match the expected_label returns false and changes none of
  * its arguments.
  *
  * If the read is successful, returns true and contents will be updated to the
  * next unread byte.
  */
 bool ReadComponentLabelMatching(absl::string_view *contents,
-                                ComponentLabel expectedLabel) {
-  int64_t rawResult = 0;
+                                ComponentLabel expected_label) {
+  int64_t raw_result = 0;
   absl::string_view tmp = *contents;
-  if (OrderedCode::ReadSignedNumIncreasing(&tmp, &rawResult)) {
-    if (rawResult == expectedLabel) {
+  if (OrderedCode::ReadSignedNumIncreasing(&tmp, &raw_result)) {
+    if (raw_result == expected_label) {
       *contents = tmp;
       return true;
     }
@@ -169,12 +169,12 @@ bool ReadComponentLabelMatching(absl::string_view *contents,
  * unread byte, and result will be set to the decoded integer value.
  */
 bool ReadInt32(absl::string_view *contents, int32_t *result) {
-  int64_t rawResult = 0;
+  int64_t raw_result = 0;
   absl::string_view tmp(contents->data(), contents->size());
-  if (OrderedCode::ReadSignedNumIncreasing(&tmp, &rawResult)) {
-    if (rawResult >= INT32_MIN && rawResult <= INT32_MAX) {
+  if (OrderedCode::ReadSignedNumIncreasing(&tmp, &raw_result)) {
+    if (raw_result >= INT32_MIN && raw_result <= INT32_MAX) {
       *contents = absl::string_view(tmp.data(), tmp.size());
-      *result = static_cast<int32_t>(rawResult);
+      *result = static_cast<int32_t>(raw_result);
       return true;
     }
   }
@@ -191,7 +191,7 @@ void WriteLabeledInt32(std::string *dest, ComponentLabel label, int32_t value) {
 
 /**
  * Reads a component label and signed number from the given key contents and
- * verifies that the label matches the expectedLabel and the value fits in a
+ * verifies that the label matches the expected_label and the value fits in a
  * 32-bit integer.
  *
  * If the read is unsuccessful, the label didn't match, or the number that was
@@ -202,13 +202,13 @@ void WriteLabeledInt32(std::string *dest, ComponentLabel label, int32_t value) {
  * unread byte, and value will be set to the decoded integer value.
  */
 bool ReadLabeledInt32(absl::string_view *contents,
-                      ComponentLabel expectedLabel,
+                      ComponentLabel expected_label,
                       int32_t *value) {
   absl::string_view tmp(contents->data(), contents->size());
-  if (ReadComponentLabelMatching(&tmp, expectedLabel)) {
-    absl::string_view tmpSlice = absl::string_view(tmp.data(), tmp.size());
-    if (ReadInt32(&tmpSlice, value)) {
-      *contents = tmpSlice;
+  if (ReadComponentLabelMatching(&tmp, expected_label)) {
+    absl::string_view tmp_slice = absl::string_view(tmp.data(), tmp.size());
+    if (ReadInt32(&tmp_slice, value)) {
+      *contents = tmp_slice;
       return true;
     }
   }
@@ -227,7 +227,7 @@ void WriteLabeledString(std::string *dest,
 
 /**
  * Reads a component label and a string from the given key contents and verifies
- * that the label matches the expectedLabel.
+ * that the label matches the expected_label.
  *
  * If the read is unsuccessful or the label didn't match, returns false, and
  * changes none of its arguments.
@@ -236,10 +236,10 @@ void WriteLabeledString(std::string *dest,
  * unread byte, and value will be set to the decoded string value.
  */
 bool ReadLabeledString(absl::string_view *contents,
-                       ComponentLabel expectedLabel,
+                       ComponentLabel expected_label,
                        std::string *value) {
   absl::string_view tmp(contents->data(), contents->size());
-  if (ReadComponentLabelMatching(&tmp, expectedLabel)) {
+  if (ReadComponentLabelMatching(&tmp, expected_label)) {
     if (OrderedCode::ReadString(&tmp, value)) {
       *contents = absl::string_view(tmp.data(), tmp.size());
       return true;
@@ -251,8 +251,8 @@ bool ReadLabeledString(absl::string_view *contents,
 
 /**
  * Reads a component label and a string from the given key contents and verifies
- * that the label matches the expectedLabel and the string matches the
- * expectedValue.
+ * that the label matches the expected_label and the string matches the
+ * expected_value.
  *
  * If the read is unsuccessful, the label or didn't match, or the string value
  * didn't match, returns false, and changes none of its arguments.
@@ -261,12 +261,12 @@ bool ReadLabeledString(absl::string_view *contents,
  * unread byte.
  */
 bool ReadLabeledStringMatching(absl::string_view *contents,
-                               ComponentLabel expectedLabel,
-                               const char *expectedValue) {
+                               ComponentLabel expected_label,
+                               const char *expected_value) {
   std::string value;
   absl::string_view tmp = *contents;
-  if (ReadLabeledString(&tmp, expectedLabel, &value)) {
-    if (value == expectedValue) {
+  if (ReadLabeledString(&tmp, expected_label, &value)) {
+    if (value == expected_value) {
       *contents = tmp;
       return true;
     }
@@ -299,33 +299,33 @@ void WriteResourcePath(std::string *dest, const ResourcePath &path) {
  * unread byte, and value will be set to the decoded document key.
  */
 bool ReadDocumentKey(absl::string_view *contents, DocumentKey *result) {
-  absl::string_view completeSegments = *contents;
+  absl::string_view complete_segments = *contents;
 
   std::string segment;
   std::vector<std::string> path_segments{};
   for (;;) {
     // Advance a temporary slice to avoid advancing contents into the next key
     // component which may not be a path segment.
-    absl::string_view readPosition(completeSegments.data(),
-                                   completeSegments.size());
-    if (!ReadComponentLabelMatching(&readPosition,
+    absl::string_view read_position(complete_segments.data(),
+                                   complete_segments.size());
+    if (!ReadComponentLabelMatching(&read_position,
                                     ComponentLabel::PathSegment)) {
       break;
     }
-    if (!OrderedCode::ReadString(&readPosition, &segment)) {
+    if (!OrderedCode::ReadString(&read_position, &segment)) {
       return false;
     }
 
     path_segments.push_back(std::move(segment));
     segment.clear();
 
-    completeSegments =
-        absl::string_view(readPosition.data(), readPosition.size());
+    complete_segments =
+        absl::string_view(read_position.data(), read_position.size());
   }
 
   ResourcePath path{std::move(path_segments)};
   if (path.size() > 0 && DocumentKey::IsDocumentKey(path)) {
-    *contents = completeSegments;
+    *contents = complete_segments;
     *result = DocumentKey(std::move(path));
     return true;
   }
@@ -346,14 +346,14 @@ inline bool ReadTerminator(absl::string_view *contents) {
   return result;
 }
 
-inline void WriteTableName(std::string *dest, const char *tableName) {
-  WriteLabeledString(dest, ComponentLabel::TableName, tableName);
+inline void WriteTableName(std::string *dest, const char *table_name) {
+  WriteLabeledString(dest, ComponentLabel::TableName, table_name);
 }
 
 inline bool ReadTableNameMatching(absl::string_view *contents,
-                                  const char *expectedTableName) {
+                                  const char *expected_table_name) {
   return ReadLabeledStringMatching(contents, ComponentLabel::TableName,
-                                   expectedTableName);
+                                   expected_table_name);
 }
 
 inline void WriteBatchID(std::string *dest, model::BatchId batch_id) {
@@ -405,7 +405,7 @@ std::string InvalidKey(const absl::string_view key) {
 
 std::string Describe(const absl::string_view key) {
   absl::string_view contents = key;
-  bool isTerminated = false;
+  bool is_terminated = false;
 
   std::string description;
   absl::StrAppend(&description, "[");
@@ -418,7 +418,7 @@ std::string Describe(const absl::string_view key) {
     }
 
     if (label == ComponentLabel::Terminator) {
-      isTerminated = true;
+      is_terminated = true;
       contents = tmp;
       break;
     }
@@ -428,12 +428,12 @@ std::string Describe(const absl::string_view key) {
     tmp = contents;
 
     if (label == ComponentLabel::PathSegment) {
-      DocumentKey documentKey;
-      if (!ReadDocumentKey(&tmp, &documentKey)) {
+      DocumentKey document_key;
+      if (!ReadDocumentKey(&tmp, &document_key)) {
         break;
       }
       absl::StrAppend(&description,
-                      " key=", documentKey.path().CanonicalString());
+                      " key=", document_key.path().CanonicalString());
 
     } else if (label == ComponentLabel::TableName) {
       std::string table;
@@ -481,7 +481,7 @@ std::string Describe(const absl::string_view key) {
   if (contents.size() > 0) {
     absl::StrAppend(&description, " invalid key=<", InvalidKey(key), ">");
 
-  } else if (!isTerminated) {
+  } else if (!is_terminated) {
     absl::StrAppend(&description, " incomplete key");
   }
 
@@ -674,11 +674,11 @@ std::string LevelDbTargetDocumentKey::KeyPrefix(model::TargetId target_id) {
 }
 
 std::string LevelDbTargetDocumentKey::Key(model::TargetId target_id,
-                                          const DocumentKey &documentKey) {
+                                          const DocumentKey &document_key) {
   std::string result;
   WriteTableName(&result, kTargetDocumentsTable);
   WriteTargetID(&result, target_id);
-  WriteResourcePath(&result, documentKey.path());
+  WriteResourcePath(&result, document_key.path());
   WriteTerminator(&result);
   return result;
 }
@@ -707,11 +707,11 @@ std::string LevelDbDocumentTargetKey::KeyPrefix(
   return result;
 }
 
-std::string LevelDbDocumentTargetKey::Key(const DocumentKey &documentKey,
+std::string LevelDbDocumentTargetKey::Key(const DocumentKey &document_key,
                                           model::TargetId target_id) {
   std::string result;
   WriteTableName(&result, kDocumentTargetsTable);
-  WriteResourcePath(&result, documentKey.path());
+  WriteResourcePath(&result, document_key.path());
   WriteTargetID(&result, target_id);
   WriteTerminator(&result);
   return result;

Firestore/core/test/firebase/firestore/local/leveldb_key_test.cc

@@ -122,27 +122,27 @@ TEST(LevelDbMutationKeyTest, Description) {
 }
 
 TEST(LevelDbDocumentMutationKeyTest, Prefixing) {
-  auto tableKey = LevelDbDocumentMutationKey::KeyPrefix();
-  auto emptyUserKey = LevelDbDocumentMutationKey::KeyPrefix("");
-  auto fooUserKey = LevelDbDocumentMutationKey::KeyPrefix("foo");
+  auto table_key = LevelDbDocumentMutationKey::KeyPrefix();
+  auto empty_user_key = LevelDbDocumentMutationKey::KeyPrefix("");
+  auto foo_user_key = LevelDbDocumentMutationKey::KeyPrefix("foo");
 
-  DocumentKey documentKey = testutil::Key("foo/bar");
-  auto foo2Key = LevelDbDocumentMutationKey::Key("foo", documentKey, 2);
+  DocumentKey document_key = testutil::Key("foo/bar");
+  auto foo2_key = LevelDbDocumentMutationKey::Key("foo", document_key, 2);
 
-  ASSERT_TRUE(util::StartsWith(emptyUserKey, tableKey));
+  ASSERT_TRUE(util::StartsWith(empty_user_key, table_key));
 
   // While we want a key with whole segments in common be considered a prefix
   // it's vital that partial segments in common not be prefixes.
-  ASSERT_TRUE(util::StartsWith(fooUserKey, tableKey));
+  ASSERT_TRUE(util::StartsWith(foo_user_key, table_key));
 
   // Here even though "" is a prefix of "foo" that prefix is within a segment so
   // keys derived from those segments cannot be prefixes of each other.
-  ASSERT_FALSE(util::StartsWith(fooUserKey, emptyUserKey));
-  ASSERT_FALSE(util::StartsWith(emptyUserKey, fooUserKey));
+  ASSERT_FALSE(util::StartsWith(foo_user_key, empty_user_key));
+  ASSERT_FALSE(util::StartsWith(empty_user_key, foo_user_key));
 
   // However whole segments in common are prefixes.
-  ASSERT_TRUE(util::StartsWith(foo2Key, tableKey));
-  ASSERT_TRUE(util::StartsWith(foo2Key, fooUserKey));
+  ASSERT_TRUE(util::StartsWith(foo2_key, table_key));
+  ASSERT_TRUE(util::StartsWith(foo2_key, foo_user_key));
 }
 
 TEST(LevelDbDocumentMutationKeyTest, EncodeDecodeCycle) {