add-ed 0.14.0

Embeddable pure rust editor based on ED
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use crate::error::*;

pub enum Path<'a> {
  File(&'a str),
  Command(&'a str),
}

// Returns filepath or command if any given, else none
pub fn parse_path(input: &str)
  -> Option<Path<'_>>
{
  let trimmed = input.trim_start();
  if trimmed.is_empty() {
    None
  }
  else if let Some(stripped) = trimmed.strip_prefix('!') {
    Some(Path::Command(stripped))
  }
  else {
    Some(Path::File(trimmed))
  }
}

pub fn command_substitutions(
  command: &str,
  state_file: &str,
  prev_command: &str,
) -> Result<(bool, String)> {
  // In command we replace ! with previous command and % with state.file.
  // To not clash with other escape processing we only handle \% and \!,
  // for every other case we print the escaping \ and the escaped char.
  let mut escaped = false;
  let mut modified = false;
  let mut output = String::new();
  for ch in command.chars() {
    match ch {
      '\\' => if escaped {
        output.push_str("\\\\");
        escaped = false;
      } else {
        escaped = true;
      },
      '%' => if escaped {
        output.push(ch);
        escaped = false;
      } else {
        modified = true;
        if state_file.is_empty() { return Err(EdError::DefaultFileUnset); }
        output.push_str(state_file);
      },
      '!' => if escaped {
        output.push(ch);
        escaped = false;
      } else {
        modified = true;
        if prev_command.is_empty() {
          return Err(EdError::DefaultShellCommandUnset);
        }
        output.push_str(prev_command);
      },
      _ => {
        if escaped {
          output.push('\\');
          escaped = false;
        }
        output.push(ch);
      },
    }
  }
  Ok((modified, output))
}
#[cfg(test)]
mod test {
  use super::*;
  #[test]
  fn test_command_escapes() {
    assert_eq!(
      &command_substitutions(
        "%",
        "state.file",
        "prev_command",
      ).unwrap().1,
      "state.file",
      "command_substitutions didn't replace % with data from state_file."
    );
    assert_eq!(
      &command_substitutions(
        "\\%",
        "state.file",
        "prev_command",
      ).unwrap().1,
      "%",
      "command_substitutions didn't respect escape on %."
    );
    assert_eq!(
      &command_substitutions(
        "!",
        "state.file",
        "prev_command",
      ).unwrap().1,
      "prev_command",
      "command_substitutions didn't replace ! with data from prev_command."
    );
    assert_eq!(
      &command_substitutions(
        "\\!",
        "state.file",
        "prev_command",
      ).unwrap().1,
      "!",
      "command_substitutions didn't respect escape on !."
    );
    assert_eq!(
      &command_substitutions(
        "\\\\",
        "state.file",
        "prev_command",
      ).unwrap().1,
      "\\\\",
      "command_substitution handled escape on \\, it should be passed through."
    );
  }
}