feat: remove unnecessary mr and rename enum mr_sync to cl_sync(#1457) (#1567)

* feat: remove unnecessary mr components and rename enum mr_sync to cl_sync(#1457)

* feat: remove unnecessary mr components and rename enum mr_sync to cl_sync(#1457)

---------

Co-authored-by: s_yangjunke <[email protected]>
Co-authored-by: Quanyi Ma <[email protected]>

Author: 3 people

ceres/src/merge_checker/mr_sync_checker.rs renamed to ceres/src/merge_checker/cl_sync_checker.rs

@@ -8,32 +8,32 @@ use jupiter::{model::cl_dto::ClInfoDto, storage::Storage};
 
 use crate::merge_checker::{CheckResult, CheckType, Checker, ConditionResult};
 
-pub struct MrSyncChecker {
+pub struct ClSyncChecker {
     pub storage: Arc<Storage>,
 }
 
 #[derive(Debug, Deserialize)]
-pub(crate) struct MrSyncParams {
-    mr_from: String,
+pub(crate) struct ClSyncParams {
+    cl_from: String,
     current: String,
 }
 
-impl MrSyncParams {
+impl ClSyncParams {
     fn from_value(v: &serde_json::Value) -> anyhow::Result<Self> {
         Ok(serde_json::from_value(v.clone())?)
     }
 }
 
 #[async_trait]
-impl Checker for MrSyncChecker {
+impl Checker for ClSyncChecker {
     async fn run(&self, params: &serde_json::Value) -> CheckResult {
-        let params = MrSyncParams::from_value(params).expect("parse params err");
+        let params = ClSyncParams::from_value(params).expect("parse params err");
         let mut res = CheckResult {
-            check_type_code: CheckType::MrSync,
+            check_type_code: CheckType::ClSync,
             status: ConditionResult::FAILED,
             message: String::new(),
         };
-        if params.mr_from == params.current {
+        if params.cl_from == params.current {
             res.status = ConditionResult::PASSED;
         } else {
             res.message =
@@ -42,15 +42,15 @@ impl Checker for MrSyncChecker {
         res
     }
 
-    async fn build_params(&self, mr_info: &ClInfoDto) -> Result<serde_json::Value, MegaError> {
+    async fn build_params(&self, cl_info: &ClInfoDto) -> Result<serde_json::Value, MegaError> {
         let refs = self
             .storage
             .mono_storage()
-            .get_ref(&mr_info.path)
+            .get_ref(&cl_info.path)
             .await?
-            .expect("Err: MR Related Refs Not Found");
+            .expect("Err: CL Related Refs Not Found");
         Ok(serde_json::json!({
-            "mr_from": mr_info.from_hash,
+            "cl_from": cl_info.from_hash,
             "current": refs.ref_commit_hash
         }))
     }

ceres/src/merge_checker/code_review_checker.rs

@@ -32,11 +32,11 @@ impl Checker for CodeReviewChecker {
             message: String::new(),
         };
 
-        let approved = self.verify_mr(&params.cl_link).await;
+        let approved = self.verify_cl(&params.cl_link).await;
         match approved {
             Ok(_) => {
                 res.status = crate::merge_checker::ConditionResult::PASSED;
-                res.message = String::from("All reviewers have approved the MR.");
+                res.message = String::from("All reviewers have approved the CL.");
             }
 
             Err(e) => {
@@ -56,7 +56,7 @@ impl Checker for CodeReviewChecker {
 }
 
 impl CodeReviewChecker {
-    async fn verify_mr(&self, cl_link: &str) -> Result<(), MegaError> {
+    async fn verify_cl(&self, cl_link: &str) -> Result<(), MegaError> {
         let reviewers = self
             .storage
             .reviewer_storage()
@@ -66,7 +66,7 @@ impl CodeReviewChecker {
         let mut err_message = String::new();
         for reviewer in reviewers {
             if !reviewer.approved {
-                let msg = format!("Reviewer {} has not approved the MR.\n", reviewer.id);
+                let msg = format!("Reviewer {} has not approved the CL.\n", reviewer.id);
                 err_message = err_message + &msg;
             }
         }

ceres/src/merge_checker/commit_message_checker.rs

@@ -19,7 +19,7 @@ impl Checker for CommitMessageChecker {
         let message = if status == ConditionResult::PASSED {
             "Commit message follows conventional commits".to_string()
         } else {
-            "Commit message does not follow conventional commits. Please make sure your MR title follows the Conventional Commits specification.".to_string()
+            "Commit message does not follow conventional commits. Please make sure your CL title follows the Conventional Commits specification.".to_string()
         };
 
         CheckResult {
@@ -29,8 +29,8 @@ impl Checker for CommitMessageChecker {
         }
     }
 
-    async fn build_params(&self, mr_info: &ClInfoDto) -> Result<Value, MegaError> {
-        let title = mr_info.title.clone();
+    async fn build_params(&self, cl_info: &ClInfoDto) -> Result<Value, MegaError> {
+        let title = cl_info.title.clone();
         Ok(json!({
             "title": title,
         }))

ceres/src/merge_checker/gpg_signature_checker.rs

@@ -15,7 +15,7 @@ pub struct GpgSignatureChecker {
 
 #[derive(Debug, Deserialize)]
 pub(crate) struct GpgSignatureParams {
-    mr_to: String,
+    cl_to: String,
     committer: String,
 }
 
@@ -35,7 +35,7 @@ impl Checker for GpgSignatureChecker {
             message: String::new(),
         };
 
-        let is_verified = self.verify_mr(&params.mr_to, params.committer).await;
+        let is_verified = self.verify_cl(&params.cl_to, params.committer).await;
         match is_verified {
             Ok(_) => {
                 res.status = ConditionResult::PASSED;
@@ -51,20 +51,20 @@ impl Checker for GpgSignatureChecker {
         res
     }
 
-    async fn build_params(&self, mr_info: &ClInfoDto) -> Result<Value, MegaError> {
+    async fn build_params(&self, cl_info: &ClInfoDto) -> Result<Value, MegaError> {
         Ok(serde_json::json!({
-            "mr_to": mr_info.to_hash,
-            "committer": mr_info.username,
+            "cl_to": cl_info.to_hash,
+            "committer": cl_info.username,
         }))
     }
 }
 
 impl GpgSignatureChecker {
-    async fn verify_mr(&self, mr_to: &str, assignee: String) -> Result<(), MegaError> {
+    async fn verify_cl(&self, cl_to: &str, assignee: String) -> Result<(), MegaError> {
         let commit = self
             .storage
             .mono_storage()
-            .get_commit_by_hash(mr_to)
+            .get_commit_by_hash(cl_to)
             .await?
             .ok_or_else(|| MegaError::with_message("Commit not found"))?;
 

ceres/src/merge_checker/mod.rs

@@ -4,31 +4,31 @@ use async_trait::async_trait;
 use serde::Serialize;
 use utoipa::ToSchema;
 
+use crate::merge_checker::cl_sync_checker::ClSyncChecker;
 use crate::merge_checker::commit_message_checker::CommitMessageChecker;
 use crate::merge_checker::gpg_signature_checker::GpgSignatureChecker;
-use crate::merge_checker::mr_sync_checker::MrSyncChecker;
 use callisto::{check_result, sea_orm_active_enums::CheckTypeEnum};
 use common::errors::MegaError;
 use jupiter::{model::cl_dto::ClInfoDto, storage::Storage};
 
+pub mod cl_sync_checker;
 mod code_review_checker;
 mod commit_message_checker;
 mod gpg_signature_checker;
-pub mod mr_sync_checker;
 
 #[async_trait]
 pub trait Checker: Send + Sync {
     async fn run(&self, params: &serde_json::Value) -> CheckResult;
 
-    async fn build_params(&self, mr_info: &ClInfoDto) -> Result<serde_json::Value, MegaError>;
+    async fn build_params(&self, cl_info: &ClInfoDto) -> Result<serde_json::Value, MegaError>;
 }
 
 #[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, ToSchema)]
 pub enum CheckType {
     GpgSignature,
     BranchProtection,
     CommitMessage,
-    MrSync,
+    ClSync,
     MergeConflict,
     CiStatus,
     CodeReview,
@@ -68,7 +68,7 @@ impl CheckType {
             CheckType::GpgSignature => "Gpg signature",
             CheckType::BranchProtection => "Branch protection",
             CheckType::CommitMessage => "Commit message",
-            CheckType::MrSync => "Mr sync",
+            CheckType::ClSync => "Cl sync",
             CheckType::MergeConflict => "Merge conflict",
             CheckType::CiStatus => "Ci status",
             CheckType::CodeReview => "Code review",
@@ -86,8 +86,8 @@ impl CheckType {
             CheckType::CommitMessage => {
                 "Verify whether the commit message follows Conventional Commits or the internal agreed-upon format"
             }
-            CheckType::MrSync => {
-                "Ensure the MR is based on the latest commit of the target branch and determine whether a rebase is required"
+            CheckType::ClSync => {
+                "Ensure the CL is based on the latest commit of the target branch and determine whether a rebase is required"
             }
             CheckType::MergeConflict => {
                 "The pull request must not have any unresolved merge conflicts"
@@ -108,7 +108,7 @@ impl From<CheckTypeEnum> for CheckType {
             CheckTypeEnum::GpgSignature => CheckType::GpgSignature,
             CheckTypeEnum::BranchProtection => CheckType::BranchProtection,
             CheckTypeEnum::CommitMessage => CheckType::CommitMessage,
-            CheckTypeEnum::MrSync => CheckType::MrSync,
+            CheckTypeEnum::ClSync => CheckType::ClSync,
             CheckTypeEnum::MergeConflict => CheckType::MergeConflict,
             CheckTypeEnum::CiStatus => CheckType::CiStatus,
             CheckTypeEnum::CodeReview => CheckType::CodeReview,
@@ -122,7 +122,7 @@ impl From<CheckType> for CheckTypeEnum {
             CheckType::GpgSignature => CheckTypeEnum::GpgSignature,
             CheckType::BranchProtection => CheckTypeEnum::BranchProtection,
             CheckType::CommitMessage => CheckTypeEnum::CommitMessage,
-            CheckType::MrSync => CheckTypeEnum::MrSync,
+            CheckType::ClSync => CheckTypeEnum::ClSync,
             CheckType::MergeConflict => CheckTypeEnum::MergeConflict,
             CheckType::CiStatus => CheckTypeEnum::CiStatus,
             CheckType::CodeReview => CheckTypeEnum::CodeReview,
@@ -152,8 +152,8 @@ impl CheckerRegistry {
             username,
         };
         r.register(
-            CheckType::MrSync,
-            Box::new(MrSyncChecker {
+            CheckType::ClSync,
+            Box::new(ClSyncChecker {
                 storage: storage.clone(),
             }),
         );
@@ -178,22 +178,22 @@ impl CheckerRegistry {
         self.checkers.insert(check_type, checker);
     }
 
-    pub async fn run_checks(&self, mr_info: ClInfoDto) -> Result<(), MegaError> {
+    pub async fn run_checks(&self, cl_info: ClInfoDto) -> Result<(), MegaError> {
         let check_configs = self
             .storage
             .cl_storage()
-            .get_checks_config_by_path(&mr_info.path)
+            .get_checks_config_by_path(&cl_info.path)
             .await?;
         let mut save_models = vec![];
 
         for c_config in check_configs {
             if let Some(checker) = self.checkers.get(&c_config.check_type_code.into()) {
-                let params = checker.build_params(&mr_info).await?;
+                let params = checker.build_params(&cl_info).await?;
                 let res = checker.run(&params).await;
                 let model = check_result::Model::new(
-                    &mr_info.path,
-                    &mr_info.link,
-                    &mr_info.to_hash,
+                    &cl_info.path,
+                    &cl_info.link,
+                    &cl_info.to_hash,
                     res.check_type_code.into(),
                     &res.status.to_string(),
                     &res.message,

ceres/src/model/mr.rs

@@ -54,7 +54,7 @@ mod test {
     #[test]
     fn test_link_generate() {
         let link = generate_link();
-        println!("MR Link: '{link:?}'");
+        println!("CL Link: '{link:?}'");
         assert!(
             link.chars().count() == 8
                 && link.chars().all(|c| !c.is_alphabetic() || c.is_uppercase())