Skip to main content

Crate dekopon_shell

Crate dekopon_shell 

Source
Expand description
use std::io::Write;

use dekopon_shell::{
    CapabilityCallResult, CapabilityInvoker, Interpreter, Streams,
};
use dekopon_process::{Limits, ShellThreads};
use serde_json::json;

/// One provider word, `probe`, whose `upper --text <s>` proposes `cli-probe.upper`.
struct Fixture;

impl CapabilityInvoker for Fixture {
    fn granted(&self) -> Vec<String> {
        vec!["cli-probe.upper".to_owned()]
    }

    fn command_words(&self) -> Vec<String> {
        vec!["probe".to_owned()]
    }

    fn run(&self, call: dekopon_shell::RunCall, streams: Streams, tree: &dekopon_process::TreeContext) -> dekopon_shell::RunResult {
        let argv = call.argv.iter().map(ToString::to_string).collect::<Vec<_>>();
        match argv.as_slice() {
            [command, flag, text] if call.word == "probe" && command == "upper" && flag == "--text" => {
                let capability = "cli-probe.upper".to_owned();
                let input = json!({ "text": text });
                let result = self.invoke(dekopon_shell::CommandProposal::new(capability.clone(), input.clone(), None), streams, tree);
                dekopon_shell::RunResult::Invoked { capability, input, secret_use: None, result }
            }
            _ => dekopon_shell::render_command(streams, "", "usage: probe upper --text <text>".to_owned(), 2),
        }
    }

    fn invoke(
        &self,
        proposal: dekopon_shell::CommandProposal,
        streams: Streams,
        _tree: &dekopon_process::TreeContext,
    ) -> CapabilityCallResult {
        let dekopon_shell::CommandProposal { capability, input, secret_use, .. } = proposal;
        if secret_use.is_some() {
            return dekopon_shell::secret_use_unsupported();
        }
        assert_eq!(capability, "cli-probe.upper");
        let text = input["text"].as_str().unwrap_or_default().to_uppercase();
        let mut stdout = std::os::unix::net::UnixStream::from(streams.stdout);
        match writeln!(stdout, "{text}") {
            Ok(()) => CapabilityCallResult::Succeeded,
            Err(_) => CapabilityCallResult::Exited {
                status: std::num::NonZeroU8::new(141).unwrap(),
                stderr: String::new(),
            },
        }
    }
}

let runtime = tokio::runtime::Runtime::new().unwrap();
let threads = ShellThreads::new(16, runtime.handle().clone());
let outcome = Interpreter::new(Limits::default(), threads)
    .run("probe upper --text hi | cat", &Fixture);
assert_eq!(outcome.exit_code.get(), 0);
assert_eq!(outcome.output, "HI");

Modules§

limits
value

Structs§

CapabilityDescription
ChildStdin
CommandProposal
CommandReport
Interpreter
JobSeed
RunCall
ScriptOutcome
Streams

Enums§

Arg
CapabilityCallResult
CommandReportOutcome
CommandRun
JobRefusal
RunResult

Traits§

CapabilityInvoker
JobControl

Functions§

render_command
render_run
run_jq_worker_if_requested
secret_use_unsupported
set_jq_worker_executable