Struct CommandIndex 

pub struct CommandIndex<A> { /* private fields */ }

A name-to-action index with front-prefix completion.

Stores an arbitrary number of named commands, each mapped to a caller-defined action A. The primary use case is a vim-style command palette: bind names with bind, look up an exact name with get, and enumerate candidates for a partial name with complete.

Case sensitivity and whitespace are the caller’s concern: the index stores names byte-for-byte as given. Trim and case-fold before calling bind / get / complete if uniformity is desired.

Lexicographic order is a specification, not just an implementation detail. complete and iter both return results in ascending byte order (the order of the underlying BTreeMap), so callers may rely on this for stable, deterministic output.

Implementations

impl<A> CommandIndex<A>

pub fn new() -> Self

Creates an empty index.

Examples found in repository

examples/command_palette.rs (line 36)

fn main() {
    let mut idx = CommandIndex::new();
    idx.bind("write", Action::Write);
    idx.bind("write-quit", Action::WriteQuit);
    idx.bind("write-quit-all", Action::WriteQuitAll);
    idx.bind("quit", Action::Quit);
    idx.bind("quit-all", Action::QuitAll);

    // --- Full palette listing (e.g. user opens the palette with no text yet) ---
    println!("All commands:");
    for (name, action) in idx.iter() {
        println!("  {name:20} -> {action:?}");
    }

    // --- Prefix completion: user has typed "w" ---
    println!("\nCompletions for \"w\":");
    for (name, action) in idx.complete("w") {
        println!("  {name:20} -> {action:?}");
    }

    // --- Prefix completion: user has typed "write-q" ---
    println!("\nCompletions for \"write-q\":");
    for (name, action) in idx.complete("write-q") {
        println!("  {name:20} -> {action:?}");
    }

    // --- Exact lookup after the user presses Enter on "write" ---
    println!("\nExact lookup:");
    match idx.get("write") {
        Some(action) => println!("  \"write\" -> {action:?}"),
        None => println!("  \"write\" -> unknown"),
    }

    // --- Case normalization is the caller's responsibility ---
    //
    // The index stores names byte-for-byte. If the user typed "Write" (capital
    // W), the caller normalizes to lowercase before calling get/complete:
    let user_input = "Write";
    let normalized = user_input.to_lowercase();
    println!("\nUser typed {user_input:?}, normalized to {normalized:?}:");
    match idx.get(&normalized) {
        Some(action) => println!("  -> {action:?}"),
        None => println!("  -> unknown"),
    }

    // --- Non-exclusive: ":w" can be both exact and a prefix ---
    //
    // In a vim-style command line `:w` executes "write" and `:wq` executes
    // "write-quit". Both can coexist because get and complete are orthogonal:
    // get(":w") is exact, complete(":w") enumerates ":w" and ":wq" and ":wqa".
    let mut vim = CommandIndex::new();
    vim.bind(":w", "write");
    vim.bind(":wq", "write-quit");
    vim.bind(":wqa", "write-quit-all");

    println!("\nVim-style coexistence:");
    println!("  get(\":w\") = {:?}", vim.get(":w"));
    let completions: Vec<&str> = vim.complete(":w").map(|(n, _)| n).collect();
    println!("  complete(\":w\") = {completions:?}");
}

pub fn bind(&mut self, name: impl Into<String>, action: A) -> Option<A>

Binds name to action, returning the action previously bound to that name, if any (last-wins — same semantic as Keymap::bind).

The name is stored byte-for-byte; no trimming or case-folding is applied.

use keymap_core::cmd::CommandIndex;

let mut idx: CommandIndex<&str> = CommandIndex::new();
assert_eq!(idx.bind(":w", "write"), None);
// Rebinding returns the old action.
assert_eq!(idx.bind(":w", "write-force"), Some("write"));
assert_eq!(idx.get(":w"), Some(&"write-force"));

Examples found in repository

examples/command_palette.rs (line 37)

fn main() {
    let mut idx = CommandIndex::new();
    idx.bind("write", Action::Write);
    idx.bind("write-quit", Action::WriteQuit);
    idx.bind("write-quit-all", Action::WriteQuitAll);
    idx.bind("quit", Action::Quit);
    idx.bind("quit-all", Action::QuitAll);

    // --- Full palette listing (e.g. user opens the palette with no text yet) ---
    println!("All commands:");
    for (name, action) in idx.iter() {
        println!("  {name:20} -> {action:?}");
    }

    // --- Prefix completion: user has typed "w" ---
    println!("\nCompletions for \"w\":");
    for (name, action) in idx.complete("w") {
        println!("  {name:20} -> {action:?}");
    }

    // --- Prefix completion: user has typed "write-q" ---
    println!("\nCompletions for \"write-q\":");
    for (name, action) in idx.complete("write-q") {
        println!("  {name:20} -> {action:?}");
    }

    // --- Exact lookup after the user presses Enter on "write" ---
    println!("\nExact lookup:");
    match idx.get("write") {
        Some(action) => println!("  \"write\" -> {action:?}"),
        None => println!("  \"write\" -> unknown"),
    }

    // --- Case normalization is the caller's responsibility ---
    //
    // The index stores names byte-for-byte. If the user typed "Write" (capital
    // W), the caller normalizes to lowercase before calling get/complete:
    let user_input = "Write";
    let normalized = user_input.to_lowercase();
    println!("\nUser typed {user_input:?}, normalized to {normalized:?}:");
    match idx.get(&normalized) {
        Some(action) => println!("  -> {action:?}"),
        None => println!("  -> unknown"),
    }

    // --- Non-exclusive: ":w" can be both exact and a prefix ---
    //
    // In a vim-style command line `:w` executes "write" and `:wq` executes
    // "write-quit". Both can coexist because get and complete are orthogonal:
    // get(":w") is exact, complete(":w") enumerates ":w" and ":wq" and ":wqa".
    let mut vim = CommandIndex::new();
    vim.bind(":w", "write");
    vim.bind(":wq", "write-quit");
    vim.bind(":wqa", "write-quit-all");

    println!("\nVim-style coexistence:");
    println!("  get(\":w\") = {:?}", vim.get(":w"));
    let completions: Vec<&str> = vim.complete(":w").map(|(n, _)| n).collect();
    println!("  complete(\":w\") = {completions:?}");
}

pub fn get(&self, name: &str) -> Option<&A>

Returns the action bound to name, or None if no exact match exists.

This is a complete-match lookup. For prefix enumeration (e.g. :w<Tab>), use complete.

use keymap_core::cmd::CommandIndex;

let mut idx: CommandIndex<u8> = CommandIndex::new();
idx.bind(":w", 1);
idx.bind(":wq", 2);

assert_eq!(idx.get(":w"), Some(&1));
assert_eq!(idx.get(":wq"), Some(&2));
// Prefix is not an exact match.
assert_eq!(idx.get(":"), None);

Examples found in repository

examples/command_palette.rs (line 63)

fn main() {
    let mut idx = CommandIndex::new();
    idx.bind("write", Action::Write);
    idx.bind("write-quit", Action::WriteQuit);
    idx.bind("write-quit-all", Action::WriteQuitAll);
    idx.bind("quit", Action::Quit);
    idx.bind("quit-all", Action::QuitAll);

    // --- Full palette listing (e.g. user opens the palette with no text yet) ---
    println!("All commands:");
    for (name, action) in idx.iter() {
        println!("  {name:20} -> {action:?}");
    }

    // --- Prefix completion: user has typed "w" ---
    println!("\nCompletions for \"w\":");
    for (name, action) in idx.complete("w") {
        println!("  {name:20} -> {action:?}");
    }

    // --- Prefix completion: user has typed "write-q" ---
    println!("\nCompletions for \"write-q\":");
    for (name, action) in idx.complete("write-q") {
        println!("  {name:20} -> {action:?}");
    }

    // --- Exact lookup after the user presses Enter on "write" ---
    println!("\nExact lookup:");
    match idx.get("write") {
        Some(action) => println!("  \"write\" -> {action:?}"),
        None => println!("  \"write\" -> unknown"),
    }

    // --- Case normalization is the caller's responsibility ---
    //
    // The index stores names byte-for-byte. If the user typed "Write" (capital
    // W), the caller normalizes to lowercase before calling get/complete:
    let user_input = "Write";
    let normalized = user_input.to_lowercase();
    println!("\nUser typed {user_input:?}, normalized to {normalized:?}:");
    match idx.get(&normalized) {
        Some(action) => println!("  -> {action:?}"),
        None => println!("  -> unknown"),
    }

    // --- Non-exclusive: ":w" can be both exact and a prefix ---
    //
    // In a vim-style command line `:w` executes "write" and `:wq` executes
    // "write-quit". Both can coexist because get and complete are orthogonal:
    // get(":w") is exact, complete(":w") enumerates ":w" and ":wq" and ":wqa".
    let mut vim = CommandIndex::new();
    vim.bind(":w", "write");
    vim.bind(":wq", "write-quit");
    vim.bind(":wqa", "write-quit-all");

    println!("\nVim-style coexistence:");
    println!("  get(\":w\") = {:?}", vim.get(":w"));
    let completions: Vec<&str> = vim.complete(":w").map(|(n, _)| n).collect();
    println!("  complete(\":w\") = {completions:?}");
}

pub fn complete<'a>( &'a self, prefix: &str, ) -> impl Iterator<Item = (&'a str, &'a A)>

Enumerates every command whose name starts with prefix, in lexicographic (byte) order.

An empty prefix is equivalent to iter — it yields every bound command. Lexicographic order is a specification: callers may rely on it for stable, deterministic output.

Note that a name can be both an exact match for one call and a prefix for another: :w completes under the prefix : and is itself exact under get(":w"). There is no closed result enum merging these two cases.

use keymap_core::cmd::CommandIndex;

let mut idx: CommandIndex<u8> = CommandIndex::new();
idx.bind(":w", 1);
idx.bind(":wq", 2);
idx.bind(":wqa", 3);
idx.bind(":q", 4);

// Prefix ":w" matches ":w", ":wq", ":wqa" in lexicographic order.
let completions: Vec<(&str, &u8)> = idx.complete(":w").collect();
assert_eq!(completions, vec![(":w", &1), (":wq", &2), (":wqa", &3)]);

// Empty prefix enumerates everything.
assert_eq!(idx.complete("").count(), 4);

Examples found in repository

examples/command_palette.rs (line 51)

fn main() {
    let mut idx = CommandIndex::new();
    idx.bind("write", Action::Write);
    idx.bind("write-quit", Action::WriteQuit);
    idx.bind("write-quit-all", Action::WriteQuitAll);
    idx.bind("quit", Action::Quit);
    idx.bind("quit-all", Action::QuitAll);

    // --- Full palette listing (e.g. user opens the palette with no text yet) ---
    println!("All commands:");
    for (name, action) in idx.iter() {
        println!("  {name:20} -> {action:?}");
    }

    // --- Prefix completion: user has typed "w" ---
    println!("\nCompletions for \"w\":");
    for (name, action) in idx.complete("w") {
        println!("  {name:20} -> {action:?}");
    }

    // --- Prefix completion: user has typed "write-q" ---
    println!("\nCompletions for \"write-q\":");
    for (name, action) in idx.complete("write-q") {
        println!("  {name:20} -> {action:?}");
    }

    // --- Exact lookup after the user presses Enter on "write" ---
    println!("\nExact lookup:");
    match idx.get("write") {
        Some(action) => println!("  \"write\" -> {action:?}"),
        None => println!("  \"write\" -> unknown"),
    }

    // --- Case normalization is the caller's responsibility ---
    //
    // The index stores names byte-for-byte. If the user typed "Write" (capital
    // W), the caller normalizes to lowercase before calling get/complete:
    let user_input = "Write";
    let normalized = user_input.to_lowercase();
    println!("\nUser typed {user_input:?}, normalized to {normalized:?}:");
    match idx.get(&normalized) {
        Some(action) => println!("  -> {action:?}"),
        None => println!("  -> unknown"),
    }

    // --- Non-exclusive: ":w" can be both exact and a prefix ---
    //
    // In a vim-style command line `:w` executes "write" and `:wq` executes
    // "write-quit". Both can coexist because get and complete are orthogonal:
    // get(":w") is exact, complete(":w") enumerates ":w" and ":wq" and ":wqa".
    let mut vim = CommandIndex::new();
    vim.bind(":w", "write");
    vim.bind(":wq", "write-quit");
    vim.bind(":wqa", "write-quit-all");

    println!("\nVim-style coexistence:");
    println!("  get(\":w\") = {:?}", vim.get(":w"));
    let completions: Vec<&str> = vim.complete(":w").map(|(n, _)| n).collect();
    println!("  complete(\":w\") = {completions:?}");
}

pub fn iter(&self) -> impl Iterator<Item = (&str, &A)>

Iterates over every (name, action) pair in lexicographic (byte) order.

This is the discovery dual of complete (with an empty prefix) and mirrors Keymap::iter in purpose.

use keymap_core::cmd::CommandIndex;

let mut idx: CommandIndex<u8> = CommandIndex::new();
idx.bind(":q", 2);
idx.bind(":w", 1);

let all: Vec<(&str, &u8)> = idx.iter().collect();
// Lexicographic order: ":q" before ":w".
assert_eq!(all, vec![(":q", &2), (":w", &1)]);

Examples found in repository

examples/command_palette.rs (line 45)

fn main() {
    let mut idx = CommandIndex::new();
    idx.bind("write", Action::Write);
    idx.bind("write-quit", Action::WriteQuit);
    idx.bind("write-quit-all", Action::WriteQuitAll);
    idx.bind("quit", Action::Quit);
    idx.bind("quit-all", Action::QuitAll);

    // --- Full palette listing (e.g. user opens the palette with no text yet) ---
    println!("All commands:");
    for (name, action) in idx.iter() {
        println!("  {name:20} -> {action:?}");
    }

    // --- Prefix completion: user has typed "w" ---
    println!("\nCompletions for \"w\":");
    for (name, action) in idx.complete("w") {
        println!("  {name:20} -> {action:?}");
    }

    // --- Prefix completion: user has typed "write-q" ---
    println!("\nCompletions for \"write-q\":");
    for (name, action) in idx.complete("write-q") {
        println!("  {name:20} -> {action:?}");
    }

    // --- Exact lookup after the user presses Enter on "write" ---
    println!("\nExact lookup:");
    match idx.get("write") {
        Some(action) => println!("  \"write\" -> {action:?}"),
        None => println!("  \"write\" -> unknown"),
    }

    // --- Case normalization is the caller's responsibility ---
    //
    // The index stores names byte-for-byte. If the user typed "Write" (capital
    // W), the caller normalizes to lowercase before calling get/complete:
    let user_input = "Write";
    let normalized = user_input.to_lowercase();
    println!("\nUser typed {user_input:?}, normalized to {normalized:?}:");
    match idx.get(&normalized) {
        Some(action) => println!("  -> {action:?}"),
        None => println!("  -> unknown"),
    }

    // --- Non-exclusive: ":w" can be both exact and a prefix ---
    //
    // In a vim-style command line `:w` executes "write" and `:wq` executes
    // "write-quit". Both can coexist because get and complete are orthogonal:
    // get(":w") is exact, complete(":w") enumerates ":w" and ":wq" and ":wqa".
    let mut vim = CommandIndex::new();
    vim.bind(":w", "write");
    vim.bind(":wq", "write-quit");
    vim.bind(":wqa", "write-quit-all");

    println!("\nVim-style coexistence:");
    println!("  get(\":w\") = {:?}", vim.get(":w"));
    let completions: Vec<&str> = vim.complete(":w").map(|(n, _)| n).collect();
    println!("  complete(\":w\") = {completions:?}");
}

pub fn len(&self) -> usize

Returns the number of commands in the index.

pub fn is_empty(&self) -> bool

Returns true if the index contains no commands.

Trait Implementations

impl<A: Clone> Clone for CommandIndex<A>

fn clone(&self) -> CommandIndex<A>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: Debug> Debug for CommandIndex<A>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A> Default for CommandIndex<A>

fn default() -> Self

Returns the “default value” for a type.