romulus 0.3.0

a stream editor like sed
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use super::op::Valuable;
use super::RangeCap;
use super::{RangeScopeTracker, Scope};
use crate::ast::Seq;
use regex::{Regex, Split};
use std::collections::HashMap;
use std::io::{copy, Read, Write};

/// An event to be processed
#[derive(PartialEq, Debug)]
pub enum Event {
    /// The beginning of processing
    Begin,

    /// A line to be processed
    Line(String),

    /// The end of processing
    End,
}

/// Embodies the current state of the program
///
pub struct Environment<'a> {
    /// The current line number being processed
    pub lineno: i64,

    /// Current event being handled
    pub event: Event,

    pub(crate) tracker: RangeScopeTracker,

    globals: HashMap<String, String>,

    seperator: Regex,
    scope_stack: Vec<Scope>,
    out: &'a mut dyn Write,
    quit: bool,
}

impl<'a> Environment<'a> {
    /// Creates a new environment
    pub fn new<W: Write>(w: &'a mut W, node: &Seq, seperator: Regex) -> Environment<'a> {
        Environment {
            lineno: 0,
            event: Event::Begin,
            scope_stack: Vec::new(),
            quit: false,
            seperator,
            out: w,
            globals: HashMap::new(),
            tracker: RangeScopeTracker::new(node.num_ranges()),
        }
    }
}

impl<'a> Environment<'a> {
    /// Looks up a variable from the stack of scopes
    pub fn lookup(&self, key: &str) -> Option<String> {
        if key == "_" {
            match self.event {
                Event::Line(ref s) => return Some(s.clone()),
                _ => return Some(String::new()),
            };
        }

        for scope in self.scope_stack.iter().rev() {
            if let Some(value) = scope.get(key) {
                return Some(value.to_string());
            }
        }

        if let Some(value) = self.globals.get(key) {
            return Some(value.to_string());
        }

        None
    }

    pub(crate) fn push(&mut self, scope: Scope) {
        self.scope_stack.push(scope);
    }

    pub(crate) fn pop(&mut self) {
        self.scope_stack.pop();
    }

    pub(crate) fn print(&mut self, reader: &mut dyn Read) {
        let _ = copy(reader, self.out);
    }

    pub(crate) fn quit(&mut self) {
        self.quit = true
    }

    pub(crate) fn finished(&self) -> bool {
        self.quit
    }

    pub(crate) fn split_line<F, T>(&self, handle: F) -> Option<T>
    where
        F: Fn(&mut Split) -> T,
    {
        if let Event::Line(line) = &self.event {
            Some(handle(&mut self.seperator.split(line)))
        } else {
            None
        }
    }

    pub(crate) fn eval<V: Valuable>(&mut self, scope: Scope, val: &V) -> String {
        self.push(scope);
        let result = val.to_value(self);
        self.pop();
        result
    }

    pub(crate) fn replace_line<F>(&mut self, handle: F)
    where
        F: Fn(&mut Self, String) -> String,
    {
        let line = if let Event::Line(line) = &mut self.event {
            line.clone()
        } else {
            return;
        };

        self.event = Event::Line(handle(self, line));
    }

    pub(crate) fn print_event(&mut self) {
        if let Event::Line(line) = &self.event {
            let buf = format!("{}{}", line, nl!());
            let _ = copy(&mut buf.as_bytes(), self.out);
        }
    }

    #[cfg(feature = "bind")]
    pub(crate) fn bind_variable(&mut self, key: &str) {
        if let Some(value) = self.lookup(key) {
            self.globals.insert(key.to_string(), value);
        }
    }
}