Enum pace_rs::commands::PaceCmd

pub enum PaceCmd {
    Begin(BeginCmd),
    End(EndCmd),
    Export(ExportCmd),
    Craft(CraftCmd),
    Hold(HoldCmd),
    Now(NowCmd),
    Pomo(PomoCmd),
    Resume(ResumeCmd),
    Review(ReviewCmd),
    Set(SetCmd),
    Tasks(TasksCmd),
}

Pace Subcommands Subcommands need to be listed in an enum.

Variants

Begin(BeginCmd)

Starts tracking time for the specified task. You can optionally specify a category or project to help organize your tasks.

End(EndCmd)

Stops time tracking for the specified task, marking it as completed or finished for the day.

Export(ExportCmd)

Exports your tracked data and reviews in JSON or CSV format, suitable for analysis or record-keeping.

Craft(CraftCmd)

Crafts a pace configuration, a new project or shell completions

Hold(HoldCmd)

Pauses the time tracking for the specified task. This is useful for taking breaks without ending the task.

Now(NowCmd)

Displays the currently running task, showing you at a glance what you’re currently tracking.

Pomo(PomoCmd)

Starts a Pomodoro session for the specified task, integrating the Pomodoro technique directly with your tasks.

Resume(ResumeCmd)

Resumes time tracking for a previously paused task, allowing you to continue where you left off.

Review(ReviewCmd)

Get insights on your activities and tasks. You can specify the time frame for daily, weekly, or monthly insights.

Set(SetCmd)

Sets various application configurations, including Pomodoro lengths and preferred review formats.

Tasks(TasksCmd)

Lists all tasks with optional filters. Use this to view active, completed, or today’s tasks.

Trait Implementations

impl Command for PaceCmd

fn name() -> &'static str

Name of this program as a string

fn description() -> &'static str

Description of this program

fn authors() -> &'static str

Authors of this program

fn parse_args<T, I>(into_args: I) -> Self

where Self: Parser, I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse command-line arguments from an iterator

fn parse_env_args() -> Self

where Self: Parser,

Parse command-line arguments from the environment

impl CommandFactory for PaceCmd

fn command<'b>() -> Command

Build a [Command] that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a [Command] that can update self.

impl Debug for PaceCmd

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

Formats the value using the given formatter.

impl FromArgMatches for PaceCmd

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 Parser for PaceCmd

fn parse() -> Self

Parse from std::env::args_os(), [exit][Error::exit] on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, [exit][Error::exit] on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, [exit][Error::exit] on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.

impl Runnable for PaceCmd

fn run(&self)

Run this Runnable

impl Subcommand for PaceCmd

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

Append to [Command] so it can instantiate Self.

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

Append to [Command] so it can update self.

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand