Merge branch 'ci-ui-not-tui'

Makefile.am

@@ -32,7 +32,7 @@ nobase_data_DATA = rules/casile.mk $(reverse_lang_key_files)
 nobase_dist_data_DATA = rules/rules.mk rules/functions.mk rules/translation.mk rules/utilities.mk $(lang_key_files)
 nobase_dist_data_DATA += rules/ebooks.mk rules/mdbook.mk rules/renderings.mk rules/zola.mk
 nobase_dist_pkgdata_DATA = $(LUALIBRARIES)
-_casile_libs = src/lib.rs src/cli.rs src/config.rs src/i18n.rs src/tui.rs
+_casile_libs = src/lib.rs src/cli.rs src/config.rs src/i18n.rs src/ui.rs src/ui_indicatif.rs src/ui_ascii.rs
 _casile_modules = src/make/mod.rs src/run/mod.rs src/setup/mod.rs src/status/mod.rs
 _casile_assets = assets/en-US/cli.ftl assets/tr-TR/cli.ftl
 bin_PROGRAMS = casile

src/lib.rs

@@ -16,7 +16,9 @@ use std::{error, fmt, path, result, str};
 pub mod cli;
 pub mod config;
 pub mod i18n;
-pub mod tui;
+pub mod ui;
+pub mod ui_ascii;
+pub mod ui_indicatif;
 
 // Subcommands
 pub mod make;

src/main.rs

@@ -2,7 +2,7 @@ use clap::{Args, Command, FromArgMatches as _};
 
 use casile::cli::{Cli, Commands};
 use casile::config::CONF;
-use casile::tui::*;
+use casile::ui::{UserInterface, CASILEUI};
 use casile::{make, run, setup, status};
 use casile::{Result, VERSION};
 
@@ -15,15 +15,14 @@ fn main() -> Result<()> {
     let matches = cli.get_matches();
     let args = Cli::from_arg_matches(&matches).expect("Unable to parse arguments");
     CONF.merge_args(&args)?;
-    let command_status = CommandStatus::new();
-    command_status.welcome();
+    CASILEUI.welcome();
     let subcommand = Commands::from_arg_matches(&matches)?;
     let ret = match subcommand {
         Commands::Make { target } => make::run(target),
         Commands::Run { name, arguments } => run::run(name, arguments),
         Commands::Setup {} => setup::run(),
         Commands::Status {} => status::run(),
     };
-    command_status.farewell();
+    CASILEUI.farewell();
     ret
 }

src/make/mod.rs

@@ -1,9 +1,8 @@
 use crate::i18n::LocalText;
-use crate::tui::*;
+use crate::ui::*;
 use crate::*;
 
 use console::style;
-use indicatif::{ProgressBar, ProgressStyle};
 use regex::Regex;
 use std::collections::HashMap;
 use std::io::prelude::*;
@@ -13,9 +12,8 @@ use subprocess::{Exec, ExitStatus, Redirection};
 // FTL: help-subcommand-make
 /// Build specified target(s)
 pub fn run(target: Vec<String>) -> Result<()> {
-    let subcommand_status = SubcommandStatus::new("status-header", "status-good", "status-bad");
-    setup::is_setup(subcommand_status)?;
-    let subcommand_status = SubcommandStatus::new("make-header", "make-good", "make-bad");
+    setup::is_setup()?;
+    let subcommand_status = CASILEUI.new_subcommand("make");
     let mut makeflags: Vec<OsString> = Vec::new();
     let cpus = &num_cpus::get().to_string();
     makeflags.push(OsString::from(format!("--jobs={cpus}")));
@@ -96,7 +94,7 @@ pub fn run(target: Vec<String>) -> Result<()> {
             "CASILE" => match fields[1] {
                 "PRE" => {
                     let target = fields[2].to_owned();
-                    let target_status = MakeTargetStatus::new(target.clone());
+                    let target_status = CASILEUI.new_target(target.clone());
                     target_statuses.insert(target, target_status);
                 }
                 "STDOUT" => {
@@ -182,27 +180,27 @@ pub fn run(target: Vec<String>) -> Result<()> {
                         || targets.contains(&"debug".into())
                         || targets.contains(&"-p".into())
                     {
-                        dump_backlog(&backlog)
+                        subcommand_status.dump(&backlog)
                     };
                     Ok(())
                 }
                 1 => {
-                    dump_backlog(&backlog);
+                    subcommand_status.dump(&backlog);
                     Err(Box::new(io::Error::new(
                         io::ErrorKind::InvalidInput,
                         LocalText::new("make-error-unfinished").fmt(),
                     )))
                 }
                 2 => {
-                    dump_backlog(&backlog);
+                    subcommand_status.dump(&backlog);
                     Err(Box::new(io::Error::new(
                         io::ErrorKind::InvalidInput,
                         LocalText::new("make-error-build").fmt(),
                     )))
                 }
                 3 => {
                     if !CONF.get_bool("verbose")? {
-                        dump_backlog(&backlog);
+                        subcommand_status.dump(&backlog);
                     }
                     Err(Box::new(io::Error::new(
                         io::ErrorKind::InvalidInput,
@@ -211,15 +209,15 @@ pub fn run(target: Vec<String>) -> Result<()> {
                 }
                 137 => {
                     if !CONF.get_bool("verbose")? {
-                        dump_backlog(&backlog);
+                        subcommand_status.dump(&backlog);
                     }
                     Err(Box::new(io::Error::new(
                         io::ErrorKind::InvalidInput,
                         LocalText::new("make-error-oom").fmt(),
                     )))
                 }
                 _ => {
-                    dump_backlog(&backlog);
+                    subcommand_status.dump(&backlog);
                     Err(Box::new(io::Error::new(
                         io::ErrorKind::InvalidInput,
                         LocalText::new("make-error-unknown").fmt(),
@@ -235,21 +233,3 @@ pub fn run(target: Vec<String>) -> Result<()> {
     subcommand_status.end(ret.is_ok());
     Ok(ret?)
 }
-
-fn dump_backlog(backlog: &[String]) {
-    let bar = ProgressBar::new_spinner().with_style(ProgressStyle::with_template("{msg}").unwrap());
-    let bar = TUI.add(bar);
-    let mut dump = String::new();
-    let start = LocalText::new("make-backlog-start").fmt();
-    let start = format!("{} {start}\n", style(style("┄┄┄┄┄┄").cyan()));
-    dump.push_str(start.as_str());
-    for line in backlog.iter() {
-        dump.push_str(line.as_str());
-        dump.push('\n');
-    }
-    let end = LocalText::new("make-backlog-end").fmt();
-    let end = format!("{} {end}", style(style("┄┄┄┄┄").cyan()));
-    dump.push_str(end.as_str());
-    bar.set_message(dump);
-    bar.finish();
-}

src/run/mod.rs

@@ -1,4 +1,4 @@
-use crate::tui::*;
+use crate::ui::*;
 use crate::*;
 
 use std::io::prelude::*;
@@ -8,8 +8,8 @@ use subprocess::{Exec, Redirection};
 // FTL: help-subcommand-run
 /// Run helper script inside CaSILE environment
 pub fn run(name: String, arguments: Vec<OsString>) -> Result<()> {
-    let subcommand_status = SubcommandStatus::new("run-header", "run-good", "run-bad");
-    setup::is_setup(subcommand_status)?;
+    setup::is_setup()?;
+    let subcommand_status = CASILEUI.new_subcommand("run");
     let cpus = &num_cpus::get().to_string();
     let mut process = Exec::cmd(format!("{CONFIGURE_DATADIR}/scripts/{name}")).args(&arguments);
     let gitname = status::get_gitname()?;
@@ -40,5 +40,6 @@ pub fn run(name: String, arguments: Vec<OsString>) -> Result<()> {
     }
     let status = popen.wait().expect("Failed for foo");
     dbg!(status);
+    subcommand_status.end(true);
     Ok(())
 }

src/setup/mod.rs

@@ -1,5 +1,5 @@
 use crate::i18n::LocalText;
-use crate::tui::*;
+use crate::ui::*;
 use crate::*;
 
 use console::style;
@@ -13,7 +13,7 @@ use subprocess::{Exec, NullFile, Redirection};
 // FTL: help-subcommand-setup
 /// Setup a publishing project for use with CaSILE
 pub fn run() -> Result<()> {
-    let subcommand_status = SubcommandStatus::new("setup-header", "setup-good", "setup_bad");
+    let subcommand_status = CASILEUI.new_subcommand("setup");
     let path = &CONF.get_string("path")?;
     let metadata = fs::metadata(path)?;
     let ret = match metadata.is_dir() {
@@ -41,7 +41,8 @@ pub fn run() -> Result<()> {
 }
 
 /// Evaluate whether this project is properly configured
-pub fn is_setup(subcommand_status: SubcommandStatus) -> Result<bool> {
+pub fn is_setup() -> Result<bool> {
+    let subcommand_status = CASILEUI.new_subcommand("status");
     let results = Arc::new(RwLock::new(Vec::new()));
 
     // First round of tests, entirely independent
@@ -81,23 +82,23 @@ pub fn is_setup(subcommand_status: SubcommandStatus) -> Result<bool> {
 
 /// Are we in a git repo?
 pub fn is_repo() -> Result<bool> {
-    let status = SetupCheck::start("setup-is-repo");
+    let status = CASILEUI.new_check("setup-is-repo");
     let ret = get_repo().is_ok();
     (ret).then(|| status.pass());
     Ok(ret)
 }
 
 /// Is this repo a deep clone?
 pub fn is_deep() -> Result<bool> {
+    let status = CASILEUI.new_check("setup-is-deep");
     let ret = !get_repo()?.is_shallow();
-    let status = SetupCheck::start("setup-is-deep");
     (ret).then(|| status.pass());
     Ok(ret)
 }
 
 /// Are we not in the CaSILE source repo?
 pub fn is_not_casile_source() -> Result<bool> {
-    let status = SetupCheck::start("setup-is-not-casile");
+    let status = CASILEUI.new_check("setup-is-not-casile");
     let repo = get_repo()?;
     let workdir = repo.workdir().unwrap();
     let testfile = workdir.join("make-shell.zsh.in");
@@ -108,7 +109,7 @@ pub fn is_not_casile_source() -> Result<bool> {
 
 /// Is the git repo we are in writable?
 pub fn is_writable() -> Result<bool> {
-    let status = SetupCheck::start("setup-is-writable");
+    let status = CASILEUI.new_check("setup-is-writable");
     let repo = get_repo()?;
     let workdir = repo.workdir().unwrap();
     let testfile = workdir.join(".casile-write-test");
@@ -122,7 +123,7 @@ pub fn is_writable() -> Result<bool> {
 
 /// Check if we can execute the system's `make` utility
 pub fn is_make_exectuable() -> Result<bool> {
-    let status = SetupCheck::start("setup-is-make-executable");
+    let status = CASILEUI.new_check("setup-is-make-executable");
     let ret = Exec::cmd("make")
         .arg("-v")
         .stdout(NullFile)
@@ -135,7 +136,7 @@ pub fn is_make_exectuable() -> Result<bool> {
 
 /// Check that the system's `make` utility is GNU Make
 pub fn is_make_gnu() -> Result<bool> {
-    let status = SetupCheck::start("setup-is-make-gnu");
+    let status = CASILEUI.new_check("setup-is-make-gnu");
     let out = Exec::cmd("make")
         .arg("-v")
         .stdout(Redirection::Pipe)

src/status/mod.rs

@@ -1,4 +1,4 @@
-use crate::tui::*;
+use crate::ui::*;
 use crate::*;
 
 use git2::{DescribeFormatOptions, DescribeOptions};
@@ -8,9 +8,11 @@ use std::{env, path};
 // FTL: help-subcommand-status
 /// Dump what we know about the repo
 pub fn run() -> Result<()> {
-    let subcommand_status = SubcommandStatus::new("status-header", "status-good", "status-bad");
+    setup::is_setup()?;
+    let subcommand_status = CASILEUI.new_subcommand("status");
     CONF.set_bool("verbose", true)?;
-    setup::is_setup(subcommand_status)?;
+    eprintln!("foo");
+    subcommand_status.end(false);
     Ok(())
 }
 
@@ -32,16 +34,16 @@ fn run_as() -> RunAsMode {
 /// Check to see if we're running in GitHub Actions
 pub fn is_gha() -> Result<bool> {
     let ret = env::var("GITHUB_ACTIONS").is_ok();
-    // let status = SetupCheck::start("setup-is-gha");
-    // (ret).then(|| status.pass());
+    let status = CASILEUI.new_check("setup-is-gha");
+    (ret).then(|| status.pass());
     Ok(ret)
 }
 
 /// Check to see if we're running in GitLab CI
 pub fn is_glc() -> Result<bool> {
     let ret = env::var("GITLAB_CI").is_ok();
-    // let status = SetupCheck::start("setup-is-glc");
-    // (ret).then(|| status.pass());
+    let status = CASILEUI.new_check("setup-is-glc");
+    (ret).then(|| status.pass());
     Ok(ret)
 }