Add shell completion kind values and man page generation

Cargo.toml

@@ -38,6 +38,7 @@ anyhow        = "1.0"
 byte-unit     = "5.2"
 clap          = {version = "4.4", features = ["derive"]}
 clap_complete = "4.4"
+clap_mangen   = "0.2"
 console       = "0.16.2"
 chrono        = {version = "0.4.44", default-features = false, features = ["clock"]}
 directories   = "6.0.0"
@@ -57,6 +58,7 @@ unicode-width = "0.2"
 anyhow        = "1.0"
 clap          = {version = "4.4", features = ["derive"]}
 clap_complete = "4.4"
+clap_mangen   = "0.2"
 
 [target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
 pager         = "0.16.1"

build.rs

@@ -1,13 +1,30 @@
+use clap::CommandFactory;
+
 include!("src/opt.rs");
 
 fn main() {
     if let Ok(path) = std::env::var("COMPLETION_PATH") {
         let out_dir = PathBuf::from(path);
 
-        gen_completion(Shell::Bash, &out_dir).unwrap();
-        gen_completion(Shell::Elvish, &out_dir).unwrap();
-        gen_completion(Shell::Fish, &out_dir).unwrap();
-        gen_completion(Shell::PowerShell, &out_dir).unwrap();
-        gen_completion(Shell::Zsh, &out_dir).unwrap();
+        gen_completion(Shell::Bash, &out_dir, &mut Opt::command()).unwrap();
+        gen_completion(Shell::Elvish, &out_dir, &mut Opt::command()).unwrap();
+        gen_completion(Shell::Fish, &out_dir, &mut Opt::command()).unwrap();
+        gen_completion(Shell::PowerShell, &out_dir, &mut Opt::command()).unwrap();
+        gen_completion(Shell::Zsh, &out_dir, &mut Opt::command()).unwrap();
+    }
+
+    // MAN_PATH=./man cargo build
+    if let Ok(path) = std::env::var("MAN_PATH") {
+        let out_dir = std::path::Path::new(&path);
+        std::fs::create_dir_all(out_dir).unwrap();
+        let cmd = Opt::command();
+        let man = clap_mangen::Man::new(cmd);
+        let mut buf = Vec::new();
+        man.render(&mut buf).unwrap();
+        std::fs::write(out_dir.join("procs.1"), buf).unwrap();
+        println!(
+            "man page is generated: {}",
+            out_dir.join("procs.1").display()
+        );
     }
 }

src/main.rs

@@ -18,7 +18,9 @@ use crate::view::View;
 use crate::watcher::Watcher;
 use anyhow::{Context, Error};
 use clap::{CommandFactory, Parser};
+use clap_mangen::Man;
 use console::Term;
+use once_cell::sync::Lazy;
 use std::cmp;
 use std::collections::HashMap;
 use std::fs;
@@ -31,6 +33,29 @@ use unicode_width::UnicodeWidthStr;
 // Functions
 // ---------------------------------------------------------------------------------------------------------------------
 
+static KIND_NAMES_LOWER: Lazy<Vec<String>> = Lazy::new(|| {
+    KIND_LIST
+        .iter()
+        .map(|(_, (name, _))| name.to_lowercase())
+        .collect()
+});
+
+fn command_with_kind_values() -> clap::Command {
+    let kind_values: Vec<clap::builder::PossibleValue> = KIND_LIST
+        .iter()
+        .zip(KIND_NAMES_LOWER.iter())
+        .map(|((_, (_, desc)), lower)| {
+            clap::builder::PossibleValue::new(lower.as_str()).help(*desc)
+        })
+        .collect();
+    let parser = clap::builder::PossibleValuesParser::new(kind_values);
+    Opt::command()
+        .mut_arg("sorta", |a| a.value_parser(parser.clone()))
+        .mut_arg("sortd", |a| a.value_parser(parser.clone()))
+        .mut_arg("insert", |a| a.value_parser(parser.clone()))
+        .mut_arg("only", |a| a.value_parser(parser))
+}
+
 fn get_config(opt: &Opt) -> Result<Config, Error> {
     let dot_cfg_path = directories::BaseDirs::new()
         .map(|base| base.home_dir().join(".procs.toml"))
@@ -122,10 +147,19 @@ fn run() -> Result<(), Error> {
         run_list();
         Ok(())
     } else if let Some(shell) = opt.gen_completion {
-        gen_completion(shell, "./")
+        gen_completion(shell, "./", &mut command_with_kind_values())
     } else if let Some(shell) = opt.gen_completion_out {
-        //Opt::clap().gen_completions_to("procs", shell, &mut stdout());
-        clap_complete::generate(shell, &mut Opt::command(), "procs", &mut stdout());
+        clap_complete::generate(
+            shell,
+            &mut command_with_kind_values(),
+            "procs",
+            &mut stdout(),
+        );
+        Ok(())
+    } else if opt.gen_man_page {
+        let cmd = command_with_kind_values();
+        let man = Man::new(cmd);
+        man.render(&mut stdout())?;
         Ok(())
     } else {
         let config = get_config(&opt)?;

src/opt.rs

@@ -1,5 +1,4 @@
 use anyhow::{Error, anyhow};
-use clap::CommandFactory;
 use clap::builder::styling::{AnsiColor, Effects, Styles};
 use clap::{Parser, ValueEnum};
 use clap_complete::Shell;
@@ -173,6 +172,10 @@ pub struct Opt {
     #[clap(long = "gen-completion-out", value_name = "shell")]
     pub gen_completion_out: Option<Shell>,
 
+    /// Generate man page and write to stdout
+    #[clap(long = "gen-man-page")]
+    pub gen_man_page: bool,
+
     /// Suppress header
     #[clap(long = "no-header")]
     pub no_header: bool,
@@ -186,10 +189,13 @@ pub struct Opt {
     pub debug: bool,
 }
 
-pub fn gen_completion<P: AsRef<Path>>(shell: Shell, path: P) -> Result<(), Error> {
+pub fn gen_completion<P: AsRef<Path>>(
+    shell: Shell,
+    path: P,
+    cmd: &mut clap::Command,
+) -> Result<(), Error> {
     let path_str = path.as_ref().as_os_str();
-    //Opt::clap().gen_completions("procs", shell, path_str);
-    clap_complete::generate_to(shell, &mut Opt::command(), "procs", path_str)?;
+    clap_complete::generate_to(shell, cmd, "procs", path_str)?;
     let filename = match shell {
         Shell::Bash => "procs.bash",
         Shell::Elvish => "procs.elv",