Struct AppRunner 

pub struct AppRunner<'a> { /* private fields */ }

Reusable runner that keeps an App paired with a borrowed UI sink.

Prefer App::run_with_sink for one-shot calls. This type exists for scoped reuse when the same sink should back multiple invocations.

Lifetime

'a is the lifetime of the mutable borrow of the sink passed to App::with_sink. That means the runner cannot outlive the borrowed sink and is mainly useful as a stack-scoped helper. It is not a good cross-thread or async handoff type in its current form because it stores &'a mut dyn UiSink.

Examples

use osp_cli::App;
use osp_cli::app::BufferedUiSink;

let mut sink = BufferedUiSink::default();
let mut runner = App::new().with_sink(&mut sink);

let first = runner.run_from(["osp", "--help"])?;
let second = runner.run_process(["osp", "--help"]);

assert_eq!(first, 0);
assert_eq!(second, 0);
assert!(!sink.stdout.is_empty());
assert!(sink.stderr.is_empty());

Implementations

impl<'a> AppRunner<'a>

pub fn run_from<I, T>(&mut self, args: I) -> Result<i32>

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

Runs the application and returns a structured exit status.

This is the bound-sink counterpart to App::run_with_sink. The borrowed sink stays attached so later calls on the same runner append to the same buffered or redirected output destination.

pub fn run_process<I, T>(&mut self, args: I) -> i32

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

Runs the application and converts execution failures into process exit codes.

This is the bound-sink counterpart to App::run_process_with_sink. User-facing failures are rendered into the already-bound sink before the numeric exit code is returned.