rename user-facing commands and crates to gsf

cli/src/main.rs

@@ -0,0 +1,198 @@
+use anyhow::Context;
+use clap::{CommandFactory, Parser};
+use gsf_core::{
+    fixedptc::Fpt,
+    persist::{ParamStore, SysFsStore},
+    subcommads::*,
+    AccelMode, NoAccelParamArgs, Param, ALL_COMMON_PARAMS, ALL_LINEAR_PARAMS, ALL_NATURAL_PARAMS,
+    ALL_SYNCHRONOUS_PARAMS,
+};
+use gsf_tui::run_tui;
+
+#[derive(Parser)]
+#[clap(author, about, version)]
+/// CLI to control acceleration parameters (used by gotta-scroll-fast daemon).
+struct Cli {
+    #[clap(subcommand)]
+    command: Option<CLiCommands>,
+}
+
+#[derive(clap::Subcommand, Default)]
+enum CLiCommands {
+    /// Open the Terminal UI to manage the parameters
+    /// and see a graph of the sensitivity
+    #[default]
+    Tui,
+    /// Set the value for a parameter
+    Set {
+        #[clap(subcommand)]
+        command: CliSubcommandSetParams,
+    },
+    /// Get parameter values
+    Get {
+        #[clap(subcommand)]
+        command: CliSubcommandGetParams,
+    },
+    /// Generate a completions file for a specified shell
+    Completion {
+        // The shell for which to generate completions
+        shell: clap_complete::Shell,
+    },
+
+    #[cfg(debug_assertions)]
+    Debug {
+        #[clap(subcommand)]
+        command: DebugCommands,
+    },
+}
+
+#[cfg(debug_assertions)]
+#[derive(Debug, clap::Subcommand)]
+enum DebugCommands {
+    Print { nums: Vec<f64> },
+}
+
+fn main() -> anyhow::Result<()> {
+    let args = Cli::parse();
+
+    // tracing_subscriber::fmt()
+    //     .with_max_level(Level::DEBUG)
+    //     .with_writer(File::create("./gsf.log")?)
+    //     .init();
+
+    let mut param_store = SysFsStore;
+
+    match args.command.unwrap_or_default() {
+        CLiCommands::Set { command } => match command {
+            CliSubcommandSetParams::Param { name, value } => param_store.set(name, value)?,
+            CliSubcommandSetParams::All { command } => match command {
+                SetParamByModesSubcommands::Linear(param_args) => {
+                    param_store.set_all_linear(param_args)?
+                }
+                SetParamByModesSubcommands::Natural(param_args) => {
+                    param_store.set_all_natural(param_args)?
+                }
+                SetParamByModesSubcommands::Common(param_args) => {
+                    param_store.set_all_common(param_args)?
+                }
+                SetParamByModesSubcommands::Synchronous(param_args) => {
+                    param_store.set_all_synchronous(param_args)?
+                }
+                SetParamByModesSubcommands::NoAccel(NoAccelParamArgs {}) => {
+                    eprintln!(
+                        "NOTE: There are no parameters specific here except for the common ones."
+                    );
+                    eprintln!();
+                }
+            },
+            CliSubcommandSetParams::Mode { mode } => SysFsStore.set_current_accel_mode(mode)?,
+        },
+        CLiCommands::Get { command } => match command {
+            CliSubcommandGetParams::Param { name } => {
+                let value = param_store.get(name)?;
+                let string_value: &str = (&value).try_into()?;
+                println!("{}", string_value);
+            }
+            CliSubcommandGetParams::All {
+                oneline,
+                quiet,
+                command,
+            } => match command {
+                GetParamsByModesSubcommands::Linear => {
+                    print_all_params(ALL_LINEAR_PARAMS.iter(), oneline, quiet)?;
+                }
+                GetParamsByModesSubcommands::Natural => {
+                    print_all_params(ALL_NATURAL_PARAMS.iter(), oneline, quiet)?;
+                }
+                GetParamsByModesSubcommands::Common => {
+                    print_all_params(ALL_COMMON_PARAMS.iter(), oneline, quiet)?;
+                }
+                GetParamsByModesSubcommands::Synchronous => {
+                    print_all_params(ALL_SYNCHRONOUS_PARAMS.iter(), oneline, quiet)?;
+                }
+                GetParamsByModesSubcommands::NoAccel => {
+                    eprintln!(
+                        "NOTE: There are no parameters specific here except for the common ones."
+                    );
+                    eprintln!();
+                    print_all_params(ALL_COMMON_PARAMS.iter(), oneline, quiet)?;
+                }
+            },
+            CliSubcommandGetParams::Mode => {
+                let mode = SysFsStore.get_current_accel_mode()?;
+                println!("{}\n", mode.as_title());
+                match mode {
+                    AccelMode::Linear => {
+                        print_all_params(ALL_LINEAR_PARAMS.iter(), false, false)?;
+                    }
+                    AccelMode::Natural => {
+                        print_all_params(ALL_NATURAL_PARAMS.iter(), false, false)?;
+                    }
+                    AccelMode::Synchronous => {
+                        print_all_params(ALL_SYNCHRONOUS_PARAMS.iter(), false, false)?;
+                    }
+                    AccelMode::NoAccel => {
+                        eprintln!(
+                            "NOTE: There are no parameters specific here except for the common ones."
+                        );
+                        eprintln!();
+                        print_all_params(ALL_COMMON_PARAMS.iter(), false, false)?;
+                    }
+                }
+            }
+        },
+        CLiCommands::Tui => run_tui()?,
+        CLiCommands::Completion { shell } => {
+            clap_complete::generate(shell, &mut Cli::command(), "gsf", &mut std::io::stdout())
+        }
+        #[cfg(debug_assertions)]
+        CLiCommands::Debug { command } => match command {
+            DebugCommands::Print { nums } => {
+                if nums.is_empty() {
+                    for n in std::io::stdin()
+                        .lines()
+                        .map_while(Result::ok)
+                        .flat_map(|s| s.parse::<f64>())
+                    {
+                        println!("{}", Fpt::from(n).0);
+                    }
+                }
+
+                for n in nums {
+                    println!("{}", Fpt::from(n).0);
+                }
+            }
+        },
+    }
+
+    Ok(())
+}
+
+fn print_all_params<'p>(
+    params: impl Iterator<Item = &'p Param>,
+    oneline: bool,
+    quiet: bool,
+) -> anyhow::Result<()> {
+    let delimiter = if oneline { " " } else { "\n" };
+
+    let params = params
+        .map(|&p| {
+            SysFsStore.get(p).and_then(|_p: Fpt| {
+                let value: &str = (&_p).try_into()?;
+                Ok((p.display_name(), value.to_string()))
+            })
+        })
+        .collect::<anyhow::Result<Vec<_>>>()
+        .context("failed to get all parameters")?;
+
+    for (name, value) in params {
+        if !quiet {
+            print!("{}:  \t", name);
+        }
+        print!("{}", value);
+
+        print!("{}", delimiter);
+    }
+
+    Ok(())
+}