From 7677f754dcd7d693233790d26e5cbfe86aec293b Mon Sep 17 00:00:00 2001
From: Xavier L'Heureux <xavier.lheureux@icloud.com>
Date: Thu, 14 Mar 2019 22:36:59 -0400
Subject: [PATCH] Transform terminator to an iterator of bytes
---
members/lexers/src/arguments.rs | 22 +--
src/lib/builtins/mod.rs | 2 +-
src/lib/parser/assignments/checker.rs | 23 +--
src/lib/parser/quotes.rs | 252 ++++++++++++++------------
src/lib/parser/shell_expand/mod.rs | 4 +-
src/lib/shell/assignments.rs | 12 +-
src/lib/shell/binary/mod.rs | 17 +-
src/lib/shell/binary/readln.rs | 43 ++---
src/lib/shell/binary/terminate.rs | 7 +-
src/lib/shell/flow.rs | 6 +-
src/lib/shell/mod.rs | 20 +-
src/lib/shell/pipe_exec/mod.rs | 5 +-
src/lib/shell/variables/mod.rs | 17 +-
src/main.rs | 10 +-
14 files changed, 217 insertions(+), 223 deletions(-)
diff --git a/members/lexers/src/arguments.rs b/members/lexers/src/arguments.rs
index be53229e..d4a12f3e 100644
--- a/members/lexers/src/arguments.rs
+++ b/members/lexers/src/arguments.rs
@@ -21,7 +21,7 @@ pub enum Field {
use self::Field::*;
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
-struct Levels {
+pub struct Levels {
parens: i32,
array: i32,
braces: i32,
@@ -30,25 +30,23 @@ struct Levels {
impl Levels {
pub fn up(&mut self, field: Field) {
let level = match field {
- Proc => &mut self.parens,
- Array => &mut self.array,
- Braces => &mut self.braces,
- };
+ Proc => &mut self.parens,
+ Array => &mut self.array,
+ Braces => &mut self.braces,
+ };
*level += 1;
}
pub fn down(&mut self, field: Field) {
let level = match field {
- Proc => &mut self.parens,
- Array => &mut self.array,
- Braces => &mut self.braces,
- };
+ Proc => &mut self.parens,
+ Array => &mut self.array,
+ Braces => &mut self.braces,
+ };
*level -= 1;
}
- pub fn are_rooted(&self) -> bool {
- self.parens + self.array + self.braces == 0
- }
+ pub fn are_rooted(&self) -> bool { self.parens == 0 && self.array == 0 && self.braces == 0 }
pub fn check(&self) -> Result<(), &'static str> {
if self.parens > 0 {
diff --git a/src/lib/builtins/mod.rs b/src/lib/builtins/mod.rs
index 6e2b7d8b..151f1492 100644
--- a/src/lib/builtins/mod.rs
+++ b/src/lib/builtins/mod.rs
@@ -319,7 +319,7 @@ fn builtin_eval(args: &[small::String], shell: &mut Shell) -> i32 {
if check_help(args, MAN_EVAL) {
SUCCESS
} else {
- shell.execute_command(args[1..].join(" ")).unwrap_or_else(|_| {
+ shell.execute_command(&args[1..].join(" ")).unwrap_or_else(|_| {
eprintln!("ion: supplied eval expression was not terminated");
FAILURE
})
diff --git a/src/lib/parser/assignments/checker.rs b/src/lib/parser/assignments/checker.rs
index e540712b..d0a5980c 100644
--- a/src/lib/parser/assignments/checker.rs
+++ b/src/lib/parser/assignments/checker.rs
@@ -46,12 +46,10 @@ fn is_expected_with(expected_type: Primitive, value: &mut Value) -> Result<(), T
let checks_out = if let Value::Array(ref mut items) = value {
match expected_type {
Primitive::BooleanArray => items.iter_mut().all(|item| {
- is_expected_with(Primitive::Boolean, &mut Value::Str(item.to_owned()))
- .is_ok()
+ is_expected_with(Primitive::Boolean, &mut Value::Str(item.to_owned())).is_ok()
}),
Primitive::IntegerArray => items.iter_mut().all(|item| {
- is_expected_with(Primitive::Integer, &mut Value::Str(item.to_owned()))
- .is_ok()
+ is_expected_with(Primitive::Integer, &mut Value::Str(item.to_owned())).is_ok()
}),
Primitive::FloatArray => items.iter_mut().all(|item| {
is_expected_with(Primitive::Float, &mut Value::Str(item.to_owned())).is_ok()
@@ -94,10 +92,9 @@ fn get_map_of<E: Expander>(
let iter = array.into_iter().map(|string| {
match string.splitn(2, '=').collect::<Vec<_>>().as_slice() {
[key, value] => value_check(shell, value, inner_kind).and_then(|val| match val {
- Value::Str(_)
- | Value::Array(_)
- | Value::HashMap(_)
- | Value::BTreeMap(_) => Ok(((*key).into(), val)),
+ Value::Str(_) | Value::Array(_) | Value::HashMap(_) | Value::BTreeMap(_) => {
+ Ok(((*key).into(), val))
+ }
_ => Err(TypeError::BadValue((**inner_kind).clone())),
}),
_ => Err(TypeError::BadValue(*inner_kind.clone())),
@@ -192,17 +189,11 @@ mod test {
#[test]
fn is_integer_array_() {
assert_eq!(
- is_expected_with(
- Primitive::IntegerArray,
- &mut Value::Array(array!["1", "2", "3"])
- ),
+ is_expected_with(Primitive::IntegerArray, &mut Value::Array(array!["1", "2", "3"])),
Ok(())
);
assert_eq!(
- is_expected_with(
- Primitive::IntegerArray,
- &mut Value::Array(array!["1", "2", "three"])
- ),
+ is_expected_with(Primitive::IntegerArray, &mut Value::Array(array!["1", "2", "three"])),
Err(TypeError::BadValue(Primitive::IntegerArray))
);
}
diff --git a/src/lib/parser/quotes.rs b/src/lib/parser/quotes.rs
index f1c576a5..f0d4bc04 100644
--- a/src/lib/parser/quotes.rs
+++ b/src/lib/parser/quotes.rs
@@ -1,4 +1,4 @@
-use std::{iter::Peekable, mem, str};
+use std::{iter::Peekable, str};
#[derive(Debug, PartialEq, Eq, Hash)]
enum Quotes {
@@ -7,6 +7,31 @@ enum Quotes {
None,
}
+#[derive(Debug)]
+struct EofMatcher {
+ eof: Vec<u8>,
+ complete: bool,
+ match_idx: usize,
+}
+
+impl EofMatcher {
+ fn new() -> Self { EofMatcher { eof: Vec::with_capacity(10), complete: false, match_idx: 0 } }
+
+ #[inline]
+ fn next(&mut self, c: u8) -> bool {
+ if self.complete && self.eof.get(self.match_idx) == Some(&c) {
+ self.match_idx += 1;
+ } else if self.complete {
+ self.match_idx = 0;
+ } else if c == b'\n' {
+ self.complete = true;
+ } else {
+ self.eof.push(c);
+ }
+ self.complete && self.match_idx == self.eof.len()
+ }
+}
+
/// Serves as a buffer for storing a string until that string can be terminated.
///
/// # Examples
@@ -14,20 +39,18 @@ enum Quotes {
/// This example comes from the shell's REPL, which ensures that the user's input
/// will only be submitted for execution once a terminated command is supplied.
#[derive(Debug)]
-pub struct Terminator<I: Iterator<Item = T>, T: AsRef<str>> {
- inner: I,
- buffer: String,
- eof: Option<String>,
+pub struct Terminator<I: Iterator<Item = u8>> {
+ inner: RearPeekable<I>,
+ eof: Option<EofMatcher>,
array: usize,
read: usize,
- trim: bool,
+ skip_next: bool,
quotes: Quotes,
- comment: bool,
terminated: bool,
}
-impl<T: AsRef<str>> From<T> for Terminator<std::iter::Once<T>, T> {
- fn from(string: T) -> Self { Terminator::new(std::iter::once(string)) }
+impl<'a> From<&'a str> for Terminator<std::str::Bytes<'a>> {
+ fn from(string: &'a str) -> Self { Terminator::new(string.bytes()) }
}
#[derive(Clone, Debug)]
@@ -46,11 +69,14 @@ where
#[inline]
fn next(&mut self) -> Option<I::Item> {
- let next = self.iter.next();
- if next.is_some() {
- self.last = mem::replace(&mut self.now, next);
- }
- next
+ self.last = self.now;
+ self.now = self.iter.next();
+ self.now
+ }
+
+ #[inline]
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.iter.size_hint()
}
}
@@ -62,127 +88,127 @@ impl<I: Iterator> RearPeekable<I> {
pub fn prev(&self) -> Option<&I::Item> { self.last.as_ref() }
}
-impl<I: Iterator<Item = T>, T: AsRef<str>> Terminator<I, T> {
- fn pair_components(&mut self) {
- let bytes = self
- .buffer
- .bytes()
- .enumerate()
- .skip(self.read)
- .peekable();
-
- let mut bytes = RearPeekable { iter: bytes, now: None, last: None };
-
- while let Some((i, character)) = bytes.next() {
- self.read = i + 1;
-
- if self.eof.is_some() {
- } else if self.comment && character == b'\n' {
- self.comment = false;
- } else if self.trim {
- self.trim = false;
- } else if character == b'\\' {
- self.trim = true;
- } else if self.quotes != Quotes::None {
- match (character, &self.quotes) {
- (b'\'', Quotes::Single) | (b'"', Quotes::Double) => {
- self.quotes = Quotes::None;
- }
- _ => (),
- }
- } else {
- match character {
- b'\'' => {
- self.quotes = Quotes::Single;
- }
- b'"' => {
- self.quotes = Quotes::Double;
+impl<I: Iterator<Item = u8>> Iterator for Terminator<I> {
+ type Item = u8;
+
+ #[inline]
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.inner.size_hint()
+ }
+
+ #[inline]
+ fn next(&mut self) -> Option<Self::Item> {
+ if self.terminated {
+ return None;
+ }
+
+ let out = self
+ .inner
+ .next()
+ .and_then(|character| {
+ if let Some(matcher) = self.eof.as_mut() {
+ if matcher.next(character) {
+ self.eof = None;
}
- b'<' if bytes.prev() == Some(&(i - 1, b'<')) => {
- if let Some(&(_, b'<')) = bytes.peek() {
- bytes.next();
- } else {
- let bytes = &self.buffer.as_bytes()[self.read..];
- let eof_phrase = unsafe { str::from_utf8_unchecked(bytes) };
- self.eof = Some(eof_phrase.trim().to_owned());
+ } else if self.skip_next {
+ self.skip_next = false;
+ } else if self.quotes != Quotes::None && character != b'\\' {
+ match (character, &self.quotes) {
+ (b'\'', Quotes::Single) | (b'"', Quotes::Double) => {
+ self.quotes = Quotes::None;
}
+ _ => (),
}
- b'[' => {
- self.array += 1;
- }
- b']' => {
- if self.array > 0 {
- self.array -= 1;
+ } else {
+ match character {
+ b'\'' => {
+ self.quotes = Quotes::Single;
}
+ b'"' => {
+ self.quotes = Quotes::Double;
+ }
+ b'<' if self.inner.prev() == Some(&b'<') => {
+ if let Some(&b'<') = self.inner.peek() {
+ self.skip_next = true; // avoid falling in the else at the next pass
+ } else {
+ self.eof = Some(EofMatcher::new());
+ }
+ }
+ b'[' => {
+ self.array += 1;
+ }
+ b']' => {
+ if self.array > 0 {
+ self.array -= 1;
+ }
+ }
+ b'#' if self
+ .inner
+ .prev()
+ .filter(|&c| ![b' ', b'\n'].contains(c))
+ .is_none() =>
+ {
+ return self.inner.find(|&c| c == b'\n')
+ }
+ b'\\' => {
+ if self.inner.peek() == Some(&b'\n') {
+ return self.inner.find(|&c| !(c as char).is_whitespace());
+ } else {
+ self.skip_next = true;
+ }
+ }
+ _ => {}
}
- b'#' if bytes
- .prev()
- .filter(|&(_, c)| ![b' ', b'\n'].contains(c))
- .is_none() =>
- {
- self.comment = true;
- // self.buffer.truncate(self.read - 1);
- }
- _ => {},
}
- }
- let prev = bytes.prev().cloned();
- let next = bytes.peek();
- // println!("debug: \n\tnext: {:?}\n\tarray: {}\n\tquotes: {:?}\n\tcharacter: {:?}\n\tprev: {:?}\n\ttrim: {}", next, self.array, self.quotes, character as char, prev, self.trim);
- if (next == Some(&(i + 1, b'\n')) || next == None) &&
- !self.trim &&
- self.eof.is_none() &&
- self.array == 0 &&
- self.quotes == Quotes::None &&
- (![b'|', b'&'].contains(&character) || prev.filter(|&(_, c)| c == character).is_none()) {
+ Some(character)
+ })
+ .map(|c| if c == b'\n' && self.array > 0 { b' ' } else { c });
+
+ if let Some(character) = &out {
+ let prev = self.inner.prev().cloned();
+ let next = self.inner.peek();
+ // println!("debug: \n\tnext: {:?}\n\tarray: {}\n\tquotes: {:?}\n\tcharacter:
+ // {:?}\n\tprev: {:?}\n\ttrim: {}", next, self.array, self.quotes, character as char,
+ // prev, self.trim);
+ if (next == Some(&b'\n') || next == None)
+ && self.eof.is_none()
+ && self.array == 0
+ && self.quotes == Quotes::None
+ && (![b'|', b'&'].contains(&character) || prev.filter(|c| c == character).is_none())
+ {
self.terminated = true;
- // println!("statement: {:?}", self.buffer);
-
- return;
}
}
- }
- /// Consumes lines until a statement is formed or the iterator runs dry, and returns the underlying `String`.
- pub fn terminate(mut self) -> Result<String, ()> {
- while !self.is_terminated() {
- if let Some(command) = self.inner.next() {
- self.append(command.as_ref());
- } else {
- return Err(());
- }
- }
- Ok(self.buffer.replace("\\\n", ""))
+ out
}
+}
- fn is_terminated(&mut self) -> bool {
- if !self.terminated {
- self.pair_components();
- }
- self.terminated
+impl<I: Iterator<Item = u8>> Terminator<I> {
+ /// Consumes lines until a statement is formed or the iterator runs dry, and returns the
+ /// underlying `String`.
+ pub fn terminate(self) -> Result<String, ()> {
+ let stmt = self.collect::<Vec<_>>();
+ let stmt = unsafe { String::from_utf8_unchecked(stmt) };
+ // println!("statement {:?}", stmt);
+ Ok(stmt)
}
/// Appends a string to the internal buffer.
- fn append(&mut self, input: &str) {
- self.buffer.push(if self.array > 0 { ' ' } else { '\n' });
- self.buffer.push_str(if self.trim { input.trim_start() } else { input });
-
- if self.eof.as_ref().filter(|s| s.as_str() == input.trim()).is_some() {
- self.eof = None;
- }
- }
+ // fn append(&mut self, input: &str) {
+ // if self.eof.as_ref().filter(|s| s.as_str() == input.trim()).is_some() {
+ // self.eof = None;
+ //}
- pub fn new(inner: I) -> Terminator<I, T> {
+ pub fn new(inner: I) -> Terminator<I> {
Terminator {
- inner,
- buffer: String::new(),
+ inner: RearPeekable { iter: inner.peekable(), now: None, last: None },
eof: None,
array: 0,
read: 0,
- trim: false,
+ skip_next: false,
quotes: Quotes::None,
- comment: false,
terminated: false,
}
}
diff --git a/src/lib/parser/shell_expand/mod.rs b/src/lib/parser/shell_expand/mod.rs
index 9f7f08ec..7370379a 100644
--- a/src/lib/parser/shell_expand/mod.rs
+++ b/src/lib/parser/shell_expand/mod.rs
@@ -50,9 +50,7 @@ pub(crate) trait Expander: Sized {
Value::Str(types::Str::from(expand_string(value, self, false).join(" ")))
}
/// Get an array that exists in the shell.
- fn get_array(&self, value: &str) -> Value {
- Value::Array(expand_string(value, self, false))
- }
+ fn get_array(&self, value: &str) -> Value { Value::Array(expand_string(value, self, false)) }
}
fn expand_process<E: Expander>(
diff --git a/src/lib/shell/assignments.rs b/src/lib/shell/assignments.rs
index 35790e53..6243fd7c 100644
--- a/src/lib/shell/assignments.rs
+++ b/src/lib/shell/assignments.rs
@@ -93,8 +93,8 @@ impl VariableStore for Shell {
env::set_var(key.name, values.join(" "));
Ok(())
}
- Value::Array(_) => Err("arithmetic operators on array expressions \
- aren't supported yet."
+ Value::Array(_) => Err("arithmetic operators on array expressions aren't \
+ supported yet."
.to_string()),
Value::Str(rhs) => {
let key_name: &str = &key.name;
@@ -261,12 +261,8 @@ impl VariableStore for Shell {
value_check(self, index_name, index_kind)
.map_err(|why| format!("assignment error: {}: {}", key.name, why))
.and_then(|index| match index {
- Value::Array(_) => {
- Err("index variable cannot be an array".to_string())
- }
- Value::HashMap(_) => {
- Err("index variable cannot be a hmap".to_string())
- }
+ Value::Array(_) => Err("index variable cannot be an array".to_string()),
+ Value::HashMap(_) => Err("index variable cannot be a hmap".to_string()),
Value::BTreeMap(_) => {
Err("index variable cannot be a bmap".to_string())
}
diff --git a/src/lib/shell/binary/mod.rs b/src/lib/shell/binary/mod.rs
index 7db3f8af..1c57a77d 100644
--- a/src/lib/shell/binary/mod.rs
+++ b/src/lib/shell/binary/mod.rs
@@ -9,8 +9,9 @@ use self::{
readln::readln,
terminate::terminate_script_quotes,
};
-use super::{status::*, FlowLogic, Shell, ShellHistory, flags::UNTERMINATED};
-use crate::{types, parser::Terminator};
+use super::{flags::UNTERMINATED, status::*, FlowLogic, Shell, ShellHistory};
+use crate::{parser::Terminator, types};
+use itertools::Itertools;
use liner::{Buffer, Context};
use std::path::Path;
@@ -35,7 +36,7 @@ pub trait Binary {
/// Liner.
fn execute_interactive(self);
/// Ensures that read statements from a script are terminated.
- fn terminate_script_quotes<T: AsRef<str> + ToString, I: Iterator<Item = T>>(&mut self, lines: I) -> i32;
+ fn terminate_script_quotes<I: Iterator<Item = u8>>(&mut self, lines: I) -> i32;
/// Ion's interface to Liner's `read_line` method, which handles everything related to
/// rendering, controlling, and getting input from the prompt.
fn readln(&mut self) -> Option<String>;
@@ -95,14 +96,18 @@ impl Binary for Shell {
let line = self.readln();
self.flags |= UNTERMINATED;
line
- }).filter_map(|cmd| cmd).filter(|cmd| !cmd.starts_with('#'));
+ })
+ .filter_map(|cmd| cmd)
+ .filter(|cmd| !cmd.starts_with('#'))
+ .flat_map(|s| s.into_bytes().into_iter())
+ .intersperse(b'\n');
match Terminator::new(&mut lines).terminate().map(|stmt| stmt.to_string()).ok() {
Some(command) => {
self.flags &= !UNTERMINATED;
let cmd: &str = &designators::expand_designators(&self, command.trim_end());
self.on_command(&cmd);
self.save_command(&cmd);
- },
+ }
None => self.reset_flow(),
}
}
@@ -123,7 +128,7 @@ impl Binary for Shell {
}
}
- fn terminate_script_quotes<T: AsRef<str> + ToString, I: Iterator<Item = T>>(&mut self, lines: I) -> i32 {
+ fn terminate_script_quotes<I: Iterator<Item = u8>>(&mut self, lines: I) -> i32 {
terminate_script_quotes(self, lines)
}
diff --git a/src/lib/shell/binary/readln.rs b/src/lib/shell/binary/readln.rs
index a4a88493..48cebc6a 100644
--- a/src/lib/shell/binary/readln.rs
+++ b/src/lib/shell/binary/readln.rs
@@ -47,16 +47,15 @@ pub(crate) fn readln(shell: &mut Shell) -> Option<String> {
}
};
- let dir_completer = env::current_dir().ok().as_ref()
+ let dir_completer = env::current_dir()
+ .ok()
+ .as_ref()
.and_then(|dir| dir.to_str())
.map(|dir| IonFileCompleter::new(Some(dir), dirs_ptr, vars_ptr));
if filename {
if let Some(completer) = dir_completer {
- mem::replace(
- &mut editor.context().completer,
- Some(Box::new(completer)),
- );
+ mem::replace(&mut editor.context().completer, Some(Box::new(completer)));
}
} else {
// Creates a list of definitions from the shell environment that
@@ -104,10 +103,7 @@ pub(crate) fn readln(shell: &mut Shell) -> Option<String> {
// Replace the shell's current completer with the newly-created
// completer.
- mem::replace(
- &mut editor.context().completer,
- Some(Box::new(completer)),
- );
+ mem::replace(&mut editor.context().completer, Some(Box::new(completer)));
}
}
},
@@ -134,19 +130,18 @@ fn complete_as_file(current_dir: &PathBuf, filename: &str, index: usize) -> bool
let filename = filename.trim();
let mut file = current_dir.clone();
file.push(&filename);
- if filename.starts_with('.') || !filename.starts_with('$') || index > 0 || file.exists() {
- // If the user explicitly requests a file through this syntax then complete as a file
- // Or, if the file does not start with a dollar sign, it's also a file instead of variable
- // Or, once we are beyond the first string, assume its a file
- // Or, if we are referencing a file that exists then just complete to that file
- true
- } else if let Some(parent) = file.parent() {
- // If we have a partial file inside an existing directory, e.g. /foo/b when
- // /foo/bar exists, then treat it as file as long as `foo` isn't the
- // current directory, otherwise this would apply to any string `foo`
- parent.exists() && parent != current_dir
- } else {
- // By default assume its not a file
- false
- }
+ // If the user explicitly requests a file through this syntax then complete as
+ // a file
+ filename.starts_with('.') ||
+ // If the file starts with a dollar sign, it's a variable, not a file
+ (!filename.starts_with('$') &&
+ // Once we are beyond the first string, assume its a file
+ (index > 0 ||
+ // If we are referencing a file that exists then just complete to that file
+ file.exists() ||
+ // If we have a partial file inside an existing directory, e.g. /foo/b when
+ // /foo/bar exists, then treat it as file as long as `foo` isn't the
+ // current directory, otherwise this would apply to any string `foo`
+ file.parent().filter(|parent| parent.exists() && parent != current_dir).is_some()))
+ // By default assume its not a file
}
diff --git a/src/lib/shell/binary/terminate.rs b/src/lib/shell/binary/terminate.rs
index 007d0150..45fe5f46 100644
--- a/src/lib/shell/binary/terminate.rs
+++ b/src/lib/shell/binary/terminate.rs
@@ -3,11 +3,8 @@ use crate::{
shell::{status::*, FlowLogic, Shell},
};
-pub(crate) fn terminate_script_quotes<T: AsRef<str> + ToString, I: Iterator<Item = T>>(
- shell: &mut Shell,
- lines: I,
-) -> i32 {
- let mut lines = lines.filter(|cmd| !cmd.as_ref().starts_with('#') && !cmd.as_ref().is_empty()).peekable();
+pub(crate) fn terminate_script_quotes<I: Iterator<Item = u8>>(shell: &mut Shell, lines: I) -> i32 {
+ let mut lines = lines.peekable();
while lines.peek().is_some() {
match Terminator::new(&mut lines).terminate() {
Ok(stmt) => shell.on_command(&stmt),
diff --git a/src/lib/shell/flow.rs b/src/lib/shell/flow.rs
index d258b486..8efbb519 100644
--- a/src/lib/shell/flow.rs
+++ b/src/lib/shell/flow.rs
@@ -372,8 +372,7 @@ impl FlowLogic for Shell {
self.variables.get::<types::Array>(bind).map(Value::Array);
self.variables.set(&bind, value.clone());
} else {
- previous_bind =
- self.variables.get::<types::Str>(bind).map(Value::Str);
+ previous_bind = self.variables.get::<types::Str>(bind).map(Value::Str);
self.set(&bind, value.join(" "));
}
}
@@ -414,8 +413,7 @@ impl FlowLogic for Shell {
self.variables.get::<types::Array>(bind).map(Value::Array);
self.variables.set(&bind, value.clone());
} else {
- previous_bind =
- self.variables.get::<types::Str>(bind).map(Value::Str);
+ previous_bind = self.variables.get::<types::Str>(bind).map(Value::Str);
self.set(&bind, value.join(" "));
}
}
diff --git a/src/lib/shell/mod.rs b/src/lib/shell/mod.rs
index ea6f1c87..463af44b 100644
--- a/src/lib/shell/mod.rs
+++ b/src/lib/shell/mod.rs
@@ -215,7 +215,7 @@ impl Shell {
pub fn execute_file<P: AsRef<Path>>(&mut self, script: P) {
match fs::read_to_string(script.as_ref()) {
Ok(script) => {
- if self.terminate_script_quotes(script.lines()) == FAILURE {
+ if self.terminate_script_quotes(script.bytes()) == FAILURE {
self.previous_status = FAILURE;
}
}
@@ -230,11 +230,11 @@ impl Shell {
/// the command(s) in the command line REPL interface for Ion. If the supplied command is
/// not
/// terminated, then an error will be returned.
- pub fn execute_command<T>(&mut self, command: T) -> Result<i32, IonError>
+ pub fn execute_command<'a, T>(&mut self, command: &T) -> Result<i32, IonError>
where
- T: AsRef<str>,
+ T: 'a + AsRef<str> + std::clone::Clone + std::convert::From<&'a str>,
{
- let terminator: Terminator<_, T> = command.into();
+ let terminator: Terminator<_> = command.as_ref().into();
if let Ok(stmt) = terminator.terminate() {
self.on_command(&stmt);
Ok(self.previous_status)
@@ -257,9 +257,7 @@ impl Shell {
}
/// Sets a variable of `name` with the given `value` in the shell's variable map.
- pub fn set<T: Into<Value>>(&mut self, name: &str, value: T) {
- self.variables.set(name, value);
- }
+ pub fn set<T: Into<Value>>(&mut self, name: &str, value: T) { self.variables.set(name, value); }
/// Executes a pipeline and returns the final exit status of the pipeline.
pub(crate) fn run_pipeline(&mut self, pipeline: &mut Pipeline) -> Option<i32> {
@@ -481,9 +479,7 @@ impl<'a> Expander for Shell {
let f = format!("{}", value);
match *value {
Value::Str(_) => array.push(f.into()),
- Value::Array(_)
- | Value::HashMap(_)
- | Value::BTreeMap(_) => {
+ Value::Array(_) | Value::HashMap(_) | Value::BTreeMap(_) => {
for split in f.split_whitespace() {
array.push(split.into());
}
@@ -524,9 +520,7 @@ impl<'a> Expander for Shell {
let f = format!("{}", value);
match *value {
Value::Str(_) => array.push(f.into()),
- Value::Array(_)
- | Value::HashMap(_)
- | Value::BTreeMap(_) => {
+ Value::Array(_) | Value::HashMap(_) | Value::BTreeMap(_) => {
for split in f.split_whitespace() {
array.push(split.into());
}
diff --git a/src/lib/shell/pipe_exec/mod.rs b/src/lib/shell/pipe_exec/mod.rs
index 60248682..f399c456 100644
--- a/src/lib/shell/pipe_exec/mod.rs
+++ b/src/lib/shell/pipe_exec/mod.rs
@@ -589,7 +589,10 @@ impl PipelineExecution for Shell {
redirect_streams(&stdin_bk, &stdout_bk, &stderr_bk);
code
} else {
- eprintln!("ion: failed to `dup` STDOUT, STDIN, or STDERR: not running '{}'", job.long());
+ eprintln!(
+ "ion: failed to `dup` STDOUT, STDIN, or STDERR: not running '{}'",
+ job.long()
+ );
COULD_NOT_EXEC
}
diff --git a/src/lib/shell/variables/mod.rs b/src/lib/shell/variables/mod.rs
index c4a88e6a..f1e90589 100644
--- a/src/lib/shell/variables/mod.rs
+++ b/src/lib/shell/variables/mod.rs
@@ -163,10 +163,7 @@ impl Default for Variables {
// Initialize the HISTFILE variable
if let Ok(base_dirs) = BaseDirectories::with_prefix("ion") {
if let Ok(path) = base_dirs.place_data_file("history") {
- map.insert(
- "HISTFILE".into(),
- Value::Str(path.to_str().unwrap_or("?").into()),
- );
+ map.insert("HISTFILE".into(), Value::Str(path.to_str().unwrap_or("?").into()));
map.insert("HISTFILE_ENABLED".into(), Value::Str("1".into()));
}
}
@@ -428,11 +425,7 @@ impl Variables {
macro_rules! handle_type {
($name:tt, $input:ty, $preferred:tt) => {
- fn $name<'a>(
- name: &str,
- var: &Value,
- input: &'a mut $input,
- ) -> Option<Action<'a>> {
+ fn $name<'a>(name: &str, var: &Value, input: &'a mut $input) -> Option<Action<'a>> {
if !name.is_empty() {
match var {
Value::$preferred(var_value) => {
@@ -637,9 +630,9 @@ impl GetVariable<types::Str> for Variables {
// If the parsed name contains the '::' pattern, then a namespace was
// designated. Find it.
match name.find("::").map(|pos| (&name[..pos], &name[pos + 2..])) {
- Some(("c", variable)) | Some(("color", variable)) => Colors::collect(variable)
- .into_string()
- .map(|s| Str::from(Value::Str(s.into()))),
+ Some(("c", variable)) | Some(("color", variable)) => {
+ Colors::collect(variable).into_string().map(|s| Str::from(Value::Str(s.into())))
+ }
Some(("x", variable)) | Some(("hex", variable)) => {
match u8::from_str_radix(variable, 16) {
Ok(c) => Some(Str::from(Value::Str((c as char).to_string().into()))),
diff --git a/src/main.rs b/src/main.rs
index 16a51814..bf19a9f3 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -10,7 +10,7 @@ use smallvec::SmallVec;
use std::{
alloc::System,
env,
- io::{stdin, BufRead, BufReader},
+ io::{stdin, BufReader, Read},
};
#[global_allocator]
@@ -63,7 +63,9 @@ fn main() {
let command = matches.opt_str("c");
let parameters = matches.free.into_iter().map(small::String::from).collect::<SmallVec<_>>();
let script_path = parameters.get(0).cloned();
- if !parameters.is_empty() { shell.variables.set("args", parameters); }
+ if !parameters.is_empty() {
+ shell.variables.set("args", parameters);
+ }
let status = if let Some(command) = command {
shell.execute_script(&command);
@@ -77,9 +79,7 @@ fn main() {
shell.execute_interactive();
unreachable!();
} else {
- let reader = BufReader::new(stdin());
- let lines = reader.lines().filter_map(|line| line.ok());
- shell.terminate_script_quotes(lines)
+ shell.terminate_script_quotes(BufReader::new(stdin()).bytes().filter_map(|b| b.ok()))
};
shell.exit(status);
}
--
GitLab