commit: rename Commit::{author,committer}{→ _raw}

Prepare for `.mailmap` support.

cli/src/commands/git/push.rs

@@ -289,14 +289,14 @@ pub fn cmd_git_push(
         if commit.description().is_empty() && !args.allow_empty_description {
             reasons.push("it has no description");
         }
-        if commit.author().name.is_empty()
-            || commit.author().name == UserSettings::USER_NAME_PLACEHOLDER
-            || commit.author().email.is_empty()
-            || commit.author().email == UserSettings::USER_EMAIL_PLACEHOLDER
-            || commit.committer().name.is_empty()
-            || commit.committer().name == UserSettings::USER_NAME_PLACEHOLDER
-            || commit.committer().email.is_empty()
-            || commit.committer().email == UserSettings::USER_EMAIL_PLACEHOLDER
+        if commit.author_raw().name.is_empty()
+            || commit.author_raw().name == UserSettings::USER_NAME_PLACEHOLDER
+            || commit.author_raw().email.is_empty()
+            || commit.author_raw().email == UserSettings::USER_EMAIL_PLACEHOLDER
+            || commit.committer_raw().name.is_empty()
+            || commit.committer_raw().name == UserSettings::USER_NAME_PLACEHOLDER
+            || commit.committer_raw().email.is_empty()
+            || commit.committer_raw().email == UserSettings::USER_EMAIL_PLACEHOLDER
         {
             reasons.push("it has no author and/or committer set");
         }

cli/src/commit_templater.rs

@@ -472,22 +472,22 @@ fn builtin_commit_methods<'repo>() -> CommitTemplateBuildMethodFnMap<'repo, Comm
         "author",
         |_language, _build_ctx, self_property, function| {
             function.expect_no_arguments()?;
-            let out_property = self_property.map(|commit| commit.author().clone());
+            let out_property = self_property.map(|commit| commit.author_raw().clone());
             Ok(L::wrap_signature(out_property))
         },
     );
     map.insert(
         "committer",
         |_language, _build_ctx, self_property, function| {
             function.expect_no_arguments()?;
-            let out_property = self_property.map(|commit| commit.committer().clone());
+            let out_property = self_property.map(|commit| commit.committer_raw().clone());
             Ok(L::wrap_signature(out_property))
         },
     );
     map.insert("mine", |language, _build_ctx, self_property, function| {
         function.expect_no_arguments()?;
         let user_email = language.revset_parse_context.user_email().to_owned();
-        let out_property = self_property.map(move |commit| commit.author().email == user_email);
+        let out_property = self_property.map(move |commit| commit.author_raw().email == user_email);
         Ok(L::wrap_boolean(out_property))
     });
     map.insert(

lib/src/commit.rs

@@ -145,11 +145,13 @@ impl Commit {
         &self.data.description
     }
 
-    pub fn author(&self) -> &Signature {
+    /// Returns the raw author signature from the commit data.
+    pub fn author_raw(&self) -> &Signature {
         &self.data.author
     }
 
-    pub fn committer(&self) -> &Signature {
+    /// Returns the raw committer signature from the commit data.
+    pub fn committer_raw(&self) -> &Signature {
         &self.data.committer
     }
 
@@ -193,8 +195,8 @@ pub(crate) struct CommitByCommitterTimestamp(pub Commit);
 
 impl Ord for CommitByCommitterTimestamp {
     fn cmp(&self, other: &Self) -> Ordering {
-        let self_timestamp = &self.0.committer().timestamp.timestamp;
-        let other_timestamp = &other.0.committer().timestamp.timestamp;
+        let self_timestamp = &self.0.committer_raw().timestamp.timestamp;
+        let other_timestamp = &other.0.committer_raw().timestamp.timestamp;
         self_timestamp
             .cmp(other_timestamp)
             .then_with(|| self.0.cmp(&other.0)) // to comply with Eq

lib/src/default_index/revset_engine.rs

@@ -965,7 +965,7 @@ impl<'index> EvaluationContext<'index> {
             let entry = self.index.entry_by_pos(pos);
             let commit = self.store.get_commit(&entry.commit_id()).unwrap();
             Reverse(Item {
-                timestamp: commit.committer().timestamp.timestamp,
+                timestamp: commit.committer_raw().timestamp.timestamp,
                 pos: entry.position(),
             })
         };
@@ -1058,8 +1058,8 @@ fn build_predicate_fn(
                 let entry = index.entry_by_pos(pos);
                 let commit = store.get_commit(&entry.commit_id()).unwrap();
                 let field_value = match field {
-                    SignatureField::Name => &commit.author().name,
-                    SignatureField::Email => &commit.author().email,
+                    SignatureField::Name => &commit.author_raw().name,
+                    SignatureField::Email => &commit.author_raw().email,
                 };
                 pattern.matches(field_value)
             })
@@ -1071,8 +1071,8 @@ fn build_predicate_fn(
                 let entry = index.entry_by_pos(pos);
                 let commit = store.get_commit(&entry.commit_id()).unwrap();
                 let field_value = match field {
-                    SignatureField::Name => &commit.committer().name,
-                    SignatureField::Email => &commit.committer().email,
+                    SignatureField::Name => &commit.committer_raw().name,
+                    SignatureField::Email => &commit.committer_raw().email,
                 };
                 pattern.matches(field_value)
             })

lib/tests/test_commit_builder.rs

@@ -82,8 +82,8 @@ fn test_initial(backend: TestRepoBackend) {
     assert_eq!(parents, vec![store.root_commit()]);
     assert!(commit.predecessors().next().is_none());
     assert_eq!(commit.description(), "description");
-    assert_eq!(commit.author(), &author_signature);
-    assert_eq!(commit.committer(), &committer_signature);
+    assert_eq!(commit.author_raw(), &author_signature);
+    assert_eq!(commit.committer_raw(), &committer_signature);
     assert_eq!(
         store
             .root_commit()
@@ -158,14 +158,14 @@ fn test_rewrite(backend: TestRepoBackend) {
     assert_eq!(parents, vec![store.root_commit()]);
     let predecessors: Vec<_> = rewritten_commit.predecessors().try_collect().unwrap();
     assert_eq!(predecessors, vec![initial_commit.clone()]);
-    assert_eq!(rewritten_commit.author().name, settings.user_name());
-    assert_eq!(rewritten_commit.author().email, settings.user_email());
+    assert_eq!(rewritten_commit.author_raw().name, settings.user_name());
+    assert_eq!(rewritten_commit.author_raw().email, settings.user_email());
     assert_eq!(
-        rewritten_commit.committer().name,
+        rewritten_commit.committer_raw().name,
         rewrite_settings.user_name()
     );
     assert_eq!(
-        rewritten_commit.committer().email,
+        rewritten_commit.committer_raw().email,
         rewrite_settings.user_email()
     );
     assert_eq!(
@@ -214,10 +214,10 @@ fn test_rewrite_update_missing_user(backend: TestRepoBackend) {
         )
         .write()
         .unwrap();
-    assert_eq!(initial_commit.author().name, "");
-    assert_eq!(initial_commit.author().email, "");
-    assert_eq!(initial_commit.committer().name, "");
-    assert_eq!(initial_commit.committer().email, "");
+    assert_eq!(initial_commit.author_raw().name, "");
+    assert_eq!(initial_commit.author_raw().email, "");
+    assert_eq!(initial_commit.committer_raw().name, "");
+    assert_eq!(initial_commit.committer_raw().email, "");
 
     let config = config::Config::builder()
         .set_override("user.name", "Configured User")
@@ -233,14 +233,14 @@ fn test_rewrite_update_missing_user(backend: TestRepoBackend) {
         .write()
         .unwrap();
 
-    assert_eq!(rewritten_commit.author().name, "Configured User");
+    assert_eq!(rewritten_commit.author_raw().name, "Configured User");
     assert_eq!(
-        rewritten_commit.author().email,
+        rewritten_commit.author_raw().email,
         "[email protected]"
     );
-    assert_eq!(rewritten_commit.committer().name, "Configured User");
+    assert_eq!(rewritten_commit.committer_raw().name, "Configured User");
     assert_eq!(
-        rewritten_commit.committer().email,
+        rewritten_commit.committer_raw().email,
         "[email protected]"
     );
 }
@@ -272,8 +272,8 @@ fn test_rewrite_resets_author_timestamp(backend: TestRepoBackend) {
 
     let initial_timestamp =
         Timestamp::from_datetime(chrono::DateTime::parse_from_rfc3339(initial_timestamp).unwrap());
-    assert_eq!(initial_commit.author().timestamp, initial_timestamp);
-    assert_eq!(initial_commit.committer().timestamp, initial_timestamp);
+    assert_eq!(initial_commit.author_raw().timestamp, initial_timestamp);
+    assert_eq!(initial_commit.committer_raw().timestamp, initial_timestamp);
 
     // Rewrite discardable commit to no longer be discardable
     let new_timestamp_1 = "2002-03-04T05:06:07+08:00";
@@ -294,9 +294,15 @@ fn test_rewrite_resets_author_timestamp(backend: TestRepoBackend) {
         Timestamp::from_datetime(chrono::DateTime::parse_from_rfc3339(new_timestamp_1).unwrap());
     assert_ne!(new_timestamp_1, initial_timestamp);
 
-    assert_eq!(rewritten_commit_1.author().timestamp, new_timestamp_1);
-    assert_eq!(rewritten_commit_1.committer().timestamp, new_timestamp_1);
-    assert_eq!(rewritten_commit_1.author(), rewritten_commit_1.committer());
+    assert_eq!(rewritten_commit_1.author_raw().timestamp, new_timestamp_1);
+    assert_eq!(
+        rewritten_commit_1.committer_raw().timestamp,
+        new_timestamp_1
+    );
+    assert_eq!(
+        rewritten_commit_1.author_raw(),
+        rewritten_commit_1.committer_raw()
+    );
 
     // Rewrite non-discardable commit
     let new_timestamp_2 = "2003-04-05T06:07:08+09:00";
@@ -317,8 +323,11 @@ fn test_rewrite_resets_author_timestamp(backend: TestRepoBackend) {
         Timestamp::from_datetime(chrono::DateTime::parse_from_rfc3339(new_timestamp_2).unwrap());
     assert_ne!(new_timestamp_2, new_timestamp_1);
 
-    assert_eq!(rewritten_commit_2.author().timestamp, new_timestamp_1);
-    assert_eq!(rewritten_commit_2.committer().timestamp, new_timestamp_2);
+    assert_eq!(rewritten_commit_2.author_raw().timestamp, new_timestamp_1);
+    assert_eq!(
+        rewritten_commit_2.committer_raw().timestamp,
+        new_timestamp_2
+    );
 }
 
 #[test_case(TestRepoBackend::Local ; "local backend")]

lib/tests/test_git.rs

@@ -3136,8 +3136,8 @@ fn test_rewrite_imported_commit() {
             imported_commit.parent_ids().to_vec(),
             imported_commit.tree_id().clone(),
         )
-        .set_author(imported_commit.author().clone())
-        .set_committer(imported_commit.committer().clone())
+        .set_author(imported_commit.author_raw().clone())
+        .set_committer(imported_commit.committer_raw().clone())
         .set_description(imported_commit.description())
         .write()
         .unwrap();
@@ -3147,8 +3147,8 @@ fn test_rewrite_imported_commit() {
     // commit should be adjusted to create new commit.
     assert_ne!(imported_commit.id(), authored_commit.id());
     assert_ne!(
-        imported_commit.committer().timestamp,
-        authored_commit.committer().timestamp,
+        imported_commit.committer_raw().timestamp,
+        authored_commit.committer_raw().timestamp,
     );
 
     // The index should be consistent with the store.

lib/tests/test_init.rs

@@ -150,10 +150,10 @@ fn test_init_no_config_set(backend: TestRepoBackend) {
         .get_wc_commit_id(&WorkspaceId::default())
         .unwrap();
     let wc_commit = repo.store().get_commit(wc_commit_id).unwrap();
-    assert_eq!(wc_commit.author().name, "".to_string());
-    assert_eq!(wc_commit.author().email, "".to_string());
-    assert_eq!(wc_commit.committer().name, "".to_string());
-    assert_eq!(wc_commit.committer().email, "".to_string());
+    assert_eq!(wc_commit.author_raw().name, "".to_string());
+    assert_eq!(wc_commit.author_raw().email, "".to_string());
+    assert_eq!(wc_commit.committer_raw().name, "".to_string());
+    assert_eq!(wc_commit.committer_raw().email, "".to_string());
 }
 
 #[test_case(TestRepoBackend::Local ; "local backend")]
@@ -175,8 +175,8 @@ fn test_init_checkout(backend: TestRepoBackend) {
     );
     assert!(wc_commit.predecessors().next().is_none());
     assert_eq!(wc_commit.description(), "");
-    assert_eq!(wc_commit.author().name, settings.user_name());
-    assert_eq!(wc_commit.author().email, settings.user_email());
-    assert_eq!(wc_commit.committer().name, settings.user_name());
-    assert_eq!(wc_commit.committer().email, settings.user_email());
+    assert_eq!(wc_commit.author_raw().name, settings.user_name());
+    assert_eq!(wc_commit.author_raw().email, settings.user_email());
+    assert_eq!(wc_commit.committer_raw().name, settings.user_name());
+    assert_eq!(wc_commit.committer_raw().email, settings.user_email());
 }