feat(wfassoc): add query_ext method and improve CLI output

- Implement query_ext method to check default program associations
- Enhance CLI query command with tabular output showing associations
- Refactor program building into Composition struct for better organization
- Update documentation comments for clarity

wfassoc_exec/src/main.rs

@@ -2,14 +2,15 @@ pub(crate) mod cli;
 pub(crate) mod manifest;
 
 use clap::Parser;
+use cli::{Cli, Commands};
+use comfy_table::Table;
+use manifest::Manifest;
 use std::collections::HashMap;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::process;
 use std::str::FromStr;
 use thiserror::Error as TeError;
-use wfassoc::{Program, Token};
-use cli::{Cli, Commands};
-use manifest::Manifest;
+use wfassoc::{Program, Scope, Token, View};
 
 // region: Basic Types
 
@@ -25,10 +26,7 @@ enum Error {
 
     /// Error when specifying invalid manner name for extension.
     #[error("extension {ext} associated manner {manner} is invalid in manifest file")]
-    InvalidMannerName {
-        manner: String,
-        ext: String
-    },
+    InvalidMannerName { manner: String, ext: String },
 }
 
 /// Result type used in this executable.
@@ -38,27 +36,59 @@ type Result<T> = std::result::Result<T, Error>;
 
 // region: Correponding Runner
 
-fn build_program(cli: &Cli) -> Result<Program> {
-    // Open file and read manifest TOML file
-    let mf = Manifest::from_file(&cli.config_file)?;
-    // Create instance
-    let mut rv = Program::new(&mf.identifier, PathBuf::from_str(&cli.config_file).unwrap().as_path())?;
-    // Setup manner
-    let mut manners: HashMap<&str, Token> = HashMap::new();
-    for (k, v) in mf.manners.iter() {
-        let token = rv.add_manner(v.as_str())?;
-        manners.insert(k.as_str(), token);
+struct Composition {
+    program: Program,
+    ext_tokens: Vec<Token>,
+}
+
+impl Composition {
+    pub fn new(cli: &Cli) -> Result<Composition> {
+        // Open file and read manifest TOML file
+        let mf = Manifest::from_file(&cli.config_file)?;
+        // Create instance
+        let mut program = Program::new(
+            &mf.identifier,
+            PathBuf::from_str(&cli.config_file).unwrap().as_path(),
+        )?;
+        // Setup manner
+        let mut manner_token_map: HashMap<&str, Token> = HashMap::new();
+        for (k, v) in mf.manners.iter() {
+            let token = program.add_manner(v.as_str())?;
+            manner_token_map.insert(k.as_str(), token);
+        }
+        // Setup extension
+        let mut ext_tokens = Vec::new();
+        for (k, v) in mf.exts.iter() {
+            let token = match manner_token_map.get(v.as_str()) {
+                Some(v) => v,
+                None => {
+                    return Err(Error::InvalidMannerName {
+                        manner: v.to_string(),
+                        ext: k.clone(),
+                    });
+                }
+            };
+            let token = program.add_ext(k.as_str(), *token)?;
+            ext_tokens.push(token);
+        }
+        // Okey
+        Ok(Self {
+            program,
+            ext_tokens,
+        })
     }
-    // Setup extension
-    for (k, v) in mf.exts.iter() {
-        let token = match manners.get(v.as_str()) {
-            Some(v) => v,
-            None => return Err(Error::InvalidMannerName { manner: v.to_string(), ext: k.clone() }),
-        };
-        rv.add_ext(k.as_str(), *token)?;
+
+    pub fn get_program(&self) -> &Program {
+        &self.program
+    }
+
+    pub fn get_mut_program(&mut self) -> &mut Program {
+        &mut self.program
+    }
+
+    pub fn iter_ext_tokens(&self) -> impl Iterator<Item = Token> {
+        self.ext_tokens.iter().copied()
     }
-    // Okey
-    Ok(rv)
 }
 
 fn run_register(cli: &Cli) -> Result<()> {
@@ -75,8 +105,32 @@ fn run_unregister(cli: &Cli) -> Result<()> {
 }
 
 fn run_query(cli: &Cli) -> Result<()> {
-    let program = build_program(cli)?;
-    print!("{:?}", program);
+    let composition = Composition::new(cli)?;
+
+    let mut table = Table::new();
+    table.set_header(["Extension", "Hybrid", "User", "System"]);
+
+    let program = composition.get_program();
+    for token in composition.iter_ext_tokens() {
+        let cell_ext = program.get_ext_str(token).unwrap();
+        let cell_hybrid = program
+            .query_ext(token, View::Hybrid)?
+            .map(|pi| pi.to_string())
+            .unwrap_or_default();
+        let cell_user = program
+            .query_ext(token, View::User)?
+            .map(|pi| pi.to_string())
+            .unwrap_or_default();
+        let cell_system = program
+            .query_ext(token, View::System)?
+            .map(|pi| pi.to_string())
+            .unwrap_or_default();
+
+        table.add_row([cell_ext, cell_hybrid, cell_user, cell_system]);
+    }
+
+    println!("{table}");
+
     Ok(())
 }