Enum Commands

pub enum Commands {
    Build {

        path: String,
        config: Option<String>,
        no_ignore: bool,
        no_cache: bool,
        rebuild: bool,
        json: Option<String>,
        dot: Option<String>,
        svg: Option<String>,
        dot_clusters: String,
        dot_legend: String,
        dot_theme: String,
        dot_rankdir: String,
        dot_splines: String,
        dot_rounded: String,
        svg_interactive: String,
        save: Option<String>,
    
},
    Query {
        query: QueryCommands,
    },
}

Variants

Build

Build the knowledge graph from a source directory

Fields

path: String

Path to the Rust project root (directory containing src/)

config: Option<String>

Path to a TOML configuration file

no_ignore: bool

Bypass ignore rules (.gitignore/.ignore) when discovering files

no_cache: bool

Ignore cache when building (do not reuse cached files)

rebuild: bool

Rebuild cache from scratch (clears previous cache)

json: Option<String>

Output JSON file path

dot: Option<String>

Output DOT file path

svg: Option<String>

Output SVG file path

dot_clusters: String

DOT: enable/disable hierarchical clusters (default: on)

dot_legend: String

DOT: include legend (default: on)

dot_theme: String

DOT: theme (light or dark)

dot_rankdir: String

DOT: rank direction (LR or TB)

dot_splines: String

DOT: edge splines style (curved, ortho, polyline)

dot_rounded: String

DOT: rounded node corners (on/off)

svg_interactive: String

SVG: add interactive enhancements (on/off)

save: Option<String>

Save built graph to JSON file path

Query

Run queries over the knowledge graph

Fields

query: QueryCommands

Trait Implementations

impl Debug for Commands

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

Formats the value using the given formatter.

impl FromArgMatches for Commands

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Commands

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand