Enum TemplateCommand 

pub enum TemplateCommand {
    List {
        remote: bool,
    },
    Fetch {
        repo: String,
        reference: Option<String>,
        force: bool,
    },
    Install {
        name: String,
        as_name: Option<String>,
    },
    Update {
        template: Option<String>,
        check: bool,
    },
    Create {
        name: String,
        output: Option<PathBuf>,
        project: PathBuf,
    },
    Remove {
        name: String,
        yes: bool,
    },
    Info {
        template: String,
        cache: bool,
    },
    Validate {
        path: PathBuf,
    },
}

Template subcommands

Variants

List

List available templates (local + cached)

Fields

remote: bool

Show remote templates too

Fetch

Fetch template from GitHub repository

Fields

repo: String

GitHub repository reference (e.g., gh:user/repo or user/repo)

reference: Option<String>

Branch, tag, or commit to fetch

force: bool

Force re-fetch even if already cached

Install

Install a cached template locally

Fields

name: String

Template name (from cache) or repository

as_name: Option<String>

Custom name for the installed template

Update

Update all installed templates or a specific one

Fields

template: Option<String>

Specific template to update

check: bool

Check for updates without installing

Create

Create a new template from current project

Fields

name: String

Name for the new template

output: Option<PathBuf>

Output directory for template

project: PathBuf

Project directory to template-ize

Remove

Remove a cached template

Fields

name: String

Template name to remove

yes: bool

Skip confirmation

Info

Show detailed information about a template

Fields

template: String

Template name

cache: bool

Show cache information

Validate

Validate a template manifest

Fields

path: PathBuf

Path to template directory or manifest

Implementations

impl TemplateCommand

pub async fn execute(&self) -> Result<()>

Execute the template command

Errors

Returns an error if the template cannot be found, variables are invalid, or the project files cannot be written.

Trait Implementations

impl Debug for TemplateCommand

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

Formats the value using the given formatter.

impl FromArgMatches for TemplateCommand

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 TemplateCommand

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