refactor(bucket-mgr): extract bind chains and renderers into modules

3 files changed, 238 insertions, 206 deletions

diff --git a/rola-cli/src/bucket_mgr/bind.rs b/rola-cli/src/bucket_mgr/bind.rs
index 48186a2..fefebd6 100644
--- a/rola-cli/src/bucket_mgr/bind.rs
+++ b/rola-cli/src/bucket_mgr/bind.rs
@@ -1,21 +1,15 @@
-use colored::Colorize;
 use mingling::{
-    Groupped, LazyRes,
-    macros::{chain, dispatcher_clap, pack, pack_err, r_println, renderer},
-    res::ResExitCode,
+    Groupped,
+    macros::{dispatcher_clap, pack, pack_err},
 };
-use rorolala::bucket::{self, bind::BucketBind};
+use rorolala::bucket::bind::BucketBind;
 use serde::Serialize;
-use shared_functions::info;
 
-use crate::{
-    Next,
-    bucket_mgr::ResultEnumBucketOperation::Set,
-    error::{ErrorRequireOverwrite, ErrorSpace},
-    locale::I18nBucketManager,
-    output::display::markdown,
-    res::{bucket::ResBucketWithoutProtocol, overwrite::ResOverwrite},
-};
+mod chains;
+pub use chains::*;
+
+mod renderers;
+pub use renderers::*;
 
 pub const EC_BUCKET_BIND_INDEX_NOT_PROVIDED: i32 = 251;
 pub const EC_BUCKET_BIND_INDEX_NOT_FOUND: i32 = 252;
@@ -68,195 +62,3 @@ pub enum ResultEnumBucketOperation {
 
 pack_err!(ErrorBucketBindIndexNotProvided);
 pack_err!(ErrorBucketBindIndexNotFound = u8);
-
-// Chains
-
-#[chain]
-pub fn handle_bucket_bind(args: EntryBucketBind) -> Next {
-    match args.index {
-        Some(op_idx) => {
-            if let Some(url) = args.set {
-                // bind idx --set url
-                return StateBucketBindSet::new((op_idx, url)).to_chain();
-            } else if args.remove {
-                // bind idx --remove
-                return StateBucketBindRemove::new(op_idx).to_chain();
-            } else {
-                // bind idx
-                return StateBucketBindListSpecified::new(op_idx).to_chain();
-            }
-        }
-        None => {
-            if !args.remove && args.set.is_none() {
-                // bind
-                return StateBucketBindListAll::new(()).to_chain();
-            } else {
-                // index not provided
-                // bind --set url
-                // or
-                // bind --remove
-                return ErrorBucketBindIndexNotProvided::default().to_render();
-            }
-        }
-    }
-}
-
-#[chain]
-pub fn handle_state_bucket_bind_set(
-    set: StateBucketBindSet,
-    bucket: &mut LazyRes<ResBucketWithoutProtocol>,
-    overwrite: &ResOverwrite,
-) -> Next {
-    let (index, url) = set.inner;
-    let bucket_space_ref = &bucket.get_ref().space;
-
-    let exist = match bucket::bind::check_bucket_bind_exists(bucket_space_ref, index) {
-        Ok(exists) => exists,
-        Err(e) => return ErrorSpace::from(e).to_chain(),
-    };
-
-    // When the bind already exists but overwrite is not specified
-    // Dispatch to ErrorRequireOverwrite
-    if exist && !overwrite.overwrite {
-        return ErrorRequireOverwrite::default().to_render();
-    }
-
-    if let Err(space_error) =
-        bucket::bind::write_bucket_bind(bucket_space_ref, index, url.clone().as_str())
-    {
-        ErrorSpace::from(space_error).to_chain();
-    }
-
-    ResultBucketOperated {
-        operation: Set,
-        index,
-        url: Some(url),
-    }
-    .to_render()
-}
-
-#[chain]
-pub fn handle_state_bucket_bind_remove(
-    remove: StateBucketBindRemove,
-    bucket: &mut LazyRes<ResBucketWithoutProtocol>,
-) -> Next {
-    let index = remove.inner;
-    let bucket_space_ref = &bucket.get_ref().space;
-
-    if let Err(space_error) = bucket::bind::remove_bucket_bind(bucket_space_ref, index) {
-        return ErrorSpace::from(space_error).to_chain();
-    }
-
-    ResultBucketOperated {
-        operation: ResultEnumBucketOperation::Remove,
-        index,
-        url: None,
-    }
-    .to_render()
-}
-
-#[chain]
-pub fn handle_state_bucket_bind_list_specified(
-    index: StateBucketBindListSpecified,
-    bucket: &mut LazyRes<ResBucketWithoutProtocol>,
-) -> Next {
-    let index = index.inner;
-    let bucket_space_ref = &bucket.get_ref().space;
-    let bind_info = match bucket::bind::read_bucket_bind(bucket_space_ref, index) {
-        Err(e) => return ErrorSpace::from(e).to_chain(),
-        Ok(None) => return ErrorBucketBindIndexNotFound::new(index).to_render(),
-        Ok(Some(r)) => r,
-    };
-
-    ResultOneBucketBind {
-        index: bind_info.get_index(),
-        url: bind_info.get_url().to_string(),
-    }
-    .to_render()
-}
-
-#[chain]
-pub fn handle_state_bucket_bind_list_all(
-    _p: StateBucketBindListAll,
-    bucket: &mut LazyRes<ResBucketWithoutProtocol>,
-) -> Next {
-    let bucket_space_ref = &bucket.get_ref().space;
-    info!("Reading all bucket binds from space");
-    let bind_list = match bucket::bind::read_bucket_binds(bucket_space_ref) {
-        Err(e) => return ErrorSpace::from(e).to_chain(),
-        Ok(r) => r,
-    };
-    info!("Read {} bucket binds", bind_list.len());
-    ResultAllBucketBind { bind_list }.to_render()
-}
-
-// Result Renderers
-
-#[renderer]
-pub fn render_result_one_bucket_bind(result: ResultOneBucketBind) {
-    r_println!("BIND_{} => \"{}\"", result.index, result.url.trim().bold());
-}
-
-#[renderer]
-pub fn render_result_all_bucket_bind(result: ResultAllBucketBind) {
-    let list: Vec<String> = result
-        .bind_list
-        .iter()
-        .map(|b| {
-            format!(
-                "BIND_{} => \"{}\"",
-                b.get_index(),
-                b.get_url().trim().bold()
-            )
-        })
-        .collect();
-    for item in list {
-        r_println!("{}", item);
-    }
-}
-
-#[renderer]
-pub fn render_result_bucket_operated(result: ResultBucketOperated) {
-    let index = result.index;
-    let url = result.url.unwrap_or("".to_string());
-    match result.operation {
-        ResultEnumBucketOperation::Set => {
-            r_println!(
-                "{} BIND_{} => \"{}\"",
-                "+++".bold().bright_green(),
-                index,
-                url.bold().trim()
-            )
-        }
-        ResultEnumBucketOperation::Remove => {
-            r_println!("{} BIND_{}", "---".bold().bright_red(), index)
-        }
-        _ => {}
-    }
-}
-
-// Error Renderers
-
-#[renderer]
-pub fn render_error_bucket_bind_index_not_provided(
-    _err: ErrorBucketBindIndexNotProvided,
-    ec: &mut ResExitCode,
-) {
-    r_println!(
-        "{}",
-        markdown(I18nBucketManager::error_bind_index_not_provided().trim())
-    );
-    ec.exit_code = EC_BUCKET_BIND_INDEX_NOT_PROVIDED;
-}
-
-#[renderer]
-pub fn render_error_bucket_bind_index_not_found(
-    err: ErrorBucketBindIndexNotFound,
-    ec: &mut ResExitCode,
-) {
-    r_println!(
-        "{}",
-        markdown(I18nBucketManager::error_bind_index_not_found(err.info.to_string()).trim())
-    );
-    ec.exit_code = EC_BUCKET_BIND_INDEX_NOT_FOUND;
-}
diff --git a/rola-cli/src/bucket_mgr/bind/chains.rs b/rola-cli/src/bucket_mgr/bind/chains.rs
new file mode 100644
index 0000000..881e5ba
--- /dev/null
+++ b/rola-cli/src/bucket_mgr/bind/chains.rs
@@ -0,0 +1,136 @@
+use crate::{
+    Next,
+    bucket_mgr::{
+        EntryBucketBind, ErrorBucketBindIndexNotFound, ErrorBucketBindIndexNotProvided,
+        ResultAllBucketBind, ResultBucketOperated,
+        ResultEnumBucketOperation::{self, Set},
+        ResultOneBucketBind, StateBucketBindListAll, StateBucketBindListSpecified,
+        StateBucketBindRemove, StateBucketBindSet,
+    },
+    error::{ErrorRequireOverwrite, ErrorSpace},
+    res::{bucket::ResBucketWithoutProtocol, overwrite::ResOverwrite},
+};
+use mingling::{LazyRes, macros::chain};
+use rorolala::bucket::{self};
+use shared_functions::info;
+
+// Chains
+
+#[chain]
+pub fn handle_bucket_bind(args: EntryBucketBind) -> Next {
+    match args.index {
+        Some(op_idx) => {
+            if let Some(url) = args.set {
+                // bind idx --set url
+                return StateBucketBindSet::new((op_idx, url)).to_chain();
+            } else if args.remove {
+                // bind idx --remove
+                return StateBucketBindRemove::new(op_idx).to_chain();
+            } else {
+                // bind idx
+                return StateBucketBindListSpecified::new(op_idx).to_chain();
+            }
+        }
+        None => {
+            if !args.remove && args.set.is_none() {
+                // bind
+                return StateBucketBindListAll::new(()).to_chain();
+            } else {
+                // index not provided
+                // bind --set url
+                // or
+                // bind --remove
+                return ErrorBucketBindIndexNotProvided::default().to_render();
+            }
+        }
+    }
+}
+
+#[chain]
+pub fn handle_state_bucket_bind_set(
+    set: StateBucketBindSet,
+    bucket: &mut LazyRes<ResBucketWithoutProtocol>,
+    overwrite: &ResOverwrite,
+) -> Next {
+    let (index, url) = set.inner;
+    let bucket_space_ref = &bucket.get_ref().space;
+
+    let exist = match bucket::bind::check_bucket_bind_exists(bucket_space_ref, index) {
+        Ok(exists) => exists,
+        Err(e) => return ErrorSpace::from(e).to_chain(),
+    };
+
+    // When the bind already exists but overwrite is not specified
+    // Dispatch to ErrorRequireOverwrite
+    if exist && !overwrite.overwrite {
+        return ErrorRequireOverwrite::default().to_render();
+    }
+
+    if let Err(space_error) =
+        bucket::bind::write_bucket_bind(bucket_space_ref, index, url.clone().as_str())
+    {
+        ErrorSpace::from(space_error).to_chain();
+    }
+
+    ResultBucketOperated {
+        operation: Set,
+        index,
+        url: Some(url),
+    }
+    .to_render()
+}
+
+#[chain]
+pub fn handle_state_bucket_bind_remove(
+    remove: StateBucketBindRemove,
+    bucket: &mut LazyRes<ResBucketWithoutProtocol>,
+) -> Next {
+    let index = remove.inner;
+    let bucket_space_ref = &bucket.get_ref().space;
+
+    if let Err(space_error) = bucket::bind::remove_bucket_bind(bucket_space_ref, index) {
+        return ErrorSpace::from(space_error).to_chain();
+    }
+
+    ResultBucketOperated {
+        operation: ResultEnumBucketOperation::Remove,
+        index,
+        url: None,
+    }
+    .to_render()
+}
+
+#[chain]
+pub fn handle_state_bucket_bind_list_specified(
+    index: StateBucketBindListSpecified,
+    bucket: &mut LazyRes<ResBucketWithoutProtocol>,
+) -> Next {
+    let index = index.inner;
+    let bucket_space_ref = &bucket.get_ref().space;
+    let bind_info = match bucket::bind::read_bucket_bind(bucket_space_ref, index) {
+        Err(e) => return ErrorSpace::from(e).to_chain(),
+        Ok(None) => return ErrorBucketBindIndexNotFound::new(index).to_render(),
+        Ok(Some(r)) => r,
+    };
+
+    ResultOneBucketBind {
+        index: bind_info.get_index(),
+        url: bind_info.get_url().to_string(),
+    }
+    .to_render()
+}
+
+#[chain]
+pub fn handle_state_bucket_bind_list_all(
+    _p: StateBucketBindListAll,
+    bucket: &mut LazyRes<ResBucketWithoutProtocol>,
+) -> Next {
+    let bucket_space_ref = &bucket.get_ref().space;
+    info!("Reading all bucket binds from space");
+    let bind_list = match bucket::bind::read_bucket_binds(bucket_space_ref) {
+        Err(e) => return ErrorSpace::from(e).to_chain(),
+        Ok(r) => r,
+    };
+    info!("Read {} bucket binds", bind_list.len());
+    ResultAllBucketBind { bind_list }.to_render()
+}
diff --git a/rola-cli/src/bucket_mgr/bind/renderers.rs b/rola-cli/src/bucket_mgr/bind/renderers.rs
new file mode 100644
index 0000000..18ae092
--- /dev/null
+++ b/rola-cli/src/bucket_mgr/bind/renderers.rs
@@ -0,0 +1,94 @@
+use mingling::{
+    macros::{r_println, renderer},
+    res::ResExitCode,
+};
+
+use crate::{
+    bucket_mgr::{
+        EC_BUCKET_BIND_INDEX_NOT_FOUND, EC_BUCKET_BIND_INDEX_NOT_PROVIDED,
+        ErrorBucketBindIndexNotFound, ErrorBucketBindIndexNotProvided, ResultAllBucketBind,
+        ResultBucketOperated, ResultEnumBucketOperation, ResultOneBucketBind,
+    },
+    locale::I18nBucketManager,
+    output::{ansi_control::Colorize, display::markdown},
+};
+
+// Result Renderers
+
+fn format_bind(idx: u8) -> String {
+    format!("BIND_{:03}", idx).bold().white().to_string()
+}
+
+fn format_bind_to(idx: u8, url: impl AsRef<str>) -> String {
+    format!(
+        "{} {} {}",
+        // BIND
+        format_bind(idx),
+        // -->
+        "-->".bright_yellow(),
+        // DIR
+        format!("\"{}\"", url.as_ref()).bold().cyan()
+    )
+}
+
+#[renderer]
+pub fn render_result_one_bucket_bind(result: ResultOneBucketBind) {
+    r_println!("{}", format_bind_to(result.index, result.url.trim()));
+}
+
+#[renderer]
+pub fn render_result_all_bucket_bind(result: ResultAllBucketBind) {
+    let list: Vec<String> = result
+        .bind_list
+        .iter()
+        .map(|b| format_bind_to(b.get_index(), b.get_url().trim()))
+        .collect();
+    for item in list {
+        r_println!("{}", item);
+    }
+}
+
+#[renderer]
+pub fn render_result_bucket_operated(result: ResultBucketOperated) {
+    let index = result.index;
+    let url = result.url.unwrap_or("".to_string());
+    match result.operation {
+        ResultEnumBucketOperation::Set => {
+            r_println!(
+                "  {} {}",
+                "+++".bold().bright_green(),
+                format_bind_to(index, url.trim())
+            )
+        }
+        ResultEnumBucketOperation::Remove => {
+            r_println!("  {} {}", "---".bold().bright_red(), format_bind(index))
+        }
+        _ => {}
+    }
+}
+
+// Error Renderers
+
+#[renderer]
+pub fn render_error_bucket_bind_index_not_provided(
+    _err: ErrorBucketBindIndexNotProvided,
+    ec: &mut ResExitCode,
+) {
+    r_println!(
+        "{}",
+        markdown(I18nBucketManager::error_bind_index_not_provided().trim())
+    );
+    ec.exit_code = EC_BUCKET_BIND_INDEX_NOT_PROVIDED;
+}
+
+#[renderer]
+pub fn render_error_bucket_bind_index_not_found(
+    err: ErrorBucketBindIndexNotFound,
+    ec: &mut ResExitCode,
+) {
+    r_println!(
+        "{}",
+        markdown(I18nBucketManager::error_bind_index_not_found(err.info.to_string()).trim())
+    );
+    ec.exit_code = EC_BUCKET_BIND_INDEX_NOT_FOUND;
+}