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

2 files changed, 230 insertions, 0 deletions

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;
+}