frost-builtins 0.1.0

Built-in shell commands for frost
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! The `print` builtin — zsh-style print command.
//!
//! Supports `-n` (no newline), `-r` (raw/no escapes), `-l` (one arg per line).

use crate::{Builtin, ShellEnvironment};

pub struct Print;

impl Builtin for Print {
    fn name(&self) -> &str {
        "print"
    }

    fn execute(&self, args: &[&str], _env: &mut dyn ShellEnvironment) -> i32 {
        let mut newline = true;
        let mut raw = false;
        let mut one_per_line = false;
        let mut text_start = 0;

        for (i, arg) in args.iter().enumerate() {
            if !arg.starts_with('-') || arg.len() < 2 || *arg == "--" {
                if *arg == "--" {
                    text_start = i + 1;
                }
                break;
            }
            let flag_bytes = &arg.as_bytes()[1..];
            let all_known = flag_bytes
                .iter()
                .all(|b| matches!(b, b'n' | b'r' | b'l' | b'R'));
            if all_known {
                for &b in flag_bytes {
                    match b {
                        b'n' => newline = false,
                        b'r' | b'R' => raw = true,
                        b'l' => one_per_line = true,
                        _ => {}
                    }
                }
                text_start = i + 1;
            } else {
                break;
            }
        }

        let text_args = &args[text_start..];

        if one_per_line {
            for arg in text_args {
                println!("{arg}");
            }
        } else {
            let joined = text_args.join(" ");
            if raw {
                print!("{joined}");
            } else {
                print!("{}", expand_escapes(&joined));
            }
            if newline {
                println!();
            }
        }

        0
    }
}

fn expand_escapes(s: &str) -> String {
    let mut out = String::with_capacity(s.len());
    let mut chars = s.chars();

    while let Some(c) = chars.next() {
        if c == '\\' {
            match chars.next() {
                Some('n') => out.push('\n'),
                Some('t') => out.push('\t'),
                Some('r') => out.push('\r'),
                Some('a') => out.push('\x07'),
                Some('b') => out.push('\x08'),
                Some('\\') => out.push('\\'),
                Some('e') | Some('E') => out.push('\x1B'),
                Some('c') => break,
                Some(other) => {
                    out.push('\\');
                    out.push(other);
                }
                None => out.push('\\'),
            }
        } else {
            out.push(c);
        }
    }

    out
}