From ddee48f9780ed716059bded8e539edfc433c2e04 Mon Sep 17 00:00:00 2001
From: Michael Murphy <mmstickman@gmail.com>
Date: Sat, 23 Jun 2018 17:19:03 -0600
Subject: [PATCH] Apply rustfmt on workspace members
---
members/braces/src/lib.rs | 12 +-
members/builtins/src/conditionals.rs | 12 +-
members/builtins/src/echo.rs | 2 +-
members/builtins/src/test.rs | 169 +++++++++++----
members/lexers/src/lib.rs | 3 +-
members/ranges/src/index.rs | 2 +-
members/ranges/src/lib.rs | 5 +-
members/ranges/src/select.rs | 5 +-
members/sys/src/sys/redox/mod.rs | 7 +-
members/sys/src/sys/unix/mod.rs | 8 +-
rustfmt.toml | 1 -
.../parser/{loops/for_grammar.rs => loops.rs} | 0
src/lib/parser/loops/mod.rs | 1 -
src/lib/parser/mod.rs | 2 +-
src/lib/parser/shell_expand/README.md | 17 --
src/lib/parser/shell_expand/braces.rs | 192 ------------------
16 files changed, 164 insertions(+), 274 deletions(-)
rename src/lib/parser/{loops/for_grammar.rs => loops.rs} (100%)
delete mode 100644 src/lib/parser/loops/mod.rs
delete mode 100644 src/lib/parser/shell_expand/README.md
delete mode 100644 src/lib/parser/shell_expand/braces.rs
diff --git a/members/braces/src/lib.rs b/members/braces/src/lib.rs
index 16b48149..a3029aba 100644
--- a/members/braces/src/lib.rs
+++ b/members/braces/src/lib.rs
@@ -20,7 +20,7 @@ pub fn expand<'a>(
Box::new(multiple_brace_expand)
} else if expanders.len() == 1 {
let single_brace_expand = SingleBraceExpand {
- elements: expanders[0].iter().map(|element| *element),
+ elements: expanders[0].iter().map(|element| *element),
tokens,
loop_count: 0,
};
@@ -53,18 +53,18 @@ fn escape_string(output: &mut SmallVec<[u8; 64]>, input: &str) {
pub struct MultipleBraceExpand<'a> {
permutator: Permutator<'a, str>,
tokens: &'a [BraceToken],
- buffer: Vec<&'a str>
+ buffer: Vec<&'a str>,
}
impl<'a> MultipleBraceExpand<'a> {
pub fn new(
tokens: &'a [BraceToken],
- expanders: &'a [&'a [&'a str]]
+ expanders: &'a [&'a [&'a str]],
) -> MultipleBraceExpand<'a> {
MultipleBraceExpand {
permutator: Permutator::new(expanders),
tokens,
- buffer: vec![""; expanders.len()]
+ buffer: vec![""; expanders.len()],
}
}
}
@@ -170,7 +170,7 @@ mod tests {
BraceToken::Normal("GH".to_owned()),
];
assert_eq!(
- MultipleBraceExpand ::new(tokens, expanders).collect::<Vec<String>>(),
+ MultipleBraceExpand::new(tokens, expanders).collect::<Vec<String>>(),
vec![
"AB1CD3EF5GH".to_owned(),
"AB1CD3EF6GH".to_owned(),
@@ -190,7 +190,7 @@ mod tests {
let tokens: &[BraceToken] = &[BraceToken::Normal("A=".to_owned()), BraceToken::Expander];
assert_eq!(
SingleBraceExpand {
- elements: elements.iter().map(|element| *element),
+ elements: elements.iter().map(|element| *element),
tokens,
loop_count: 0,
}.collect::<Vec<String>>(),
diff --git a/members/builtins/src/conditionals.rs b/members/builtins/src/conditionals.rs
index e4f5751c..677342c0 100644
--- a/members/builtins/src/conditionals.rs
+++ b/members/builtins/src/conditionals.rs
@@ -6,8 +6,16 @@ macro_rules! string_function {
eprintln!("ion: {}: two arguments must be supplied", args[0]);
return 2;
}
- 3 => if args[1].$method(&args[2]) { 0 } else { 1 },
- _ => if args[2..].iter().any(|arg| args[1].$method(arg)) { 0 } else { 1 }
+ 3 => if args[1].$method(&args[2]) {
+ 0
+ } else {
+ 1
+ },
+ _ => if args[2..].iter().any(|arg| args[1].$method(arg)) {
+ 0
+ } else {
+ 1
+ },
}
}
};
diff --git a/members/builtins/src/echo.rs b/members/builtins/src/echo.rs
index 52a2af0d..2aa8b5c2 100644
--- a/members/builtins/src/echo.rs
+++ b/members/builtins/src/echo.rs
@@ -1,5 +1,5 @@
-use std::io::{self, BufWriter, Write};
use smallvec::SmallVec;
+use std::io::{self, BufWriter, Write};
bitflags! {
struct Flags : u8 {
diff --git a/members/builtins/src/test.rs b/members/builtins/src/test.rs
index 9c034dc8..90dc0f5c 100644
--- a/members/builtins/src/test.rs
+++ b/members/builtins/src/test.rs
@@ -1,6 +1,9 @@
use smallstring::SmallString;
use std::{
- fs, os::unix::fs::{FileTypeExt, MetadataExt, PermissionsExt}, path::Path, time::SystemTime,
+ fs,
+ os::unix::fs::{FileTypeExt, MetadataExt, PermissionsExt},
+ path::Path,
+ time::SystemTime,
};
pub const MAN_TEST: &str = r#"NAME
@@ -372,53 +375,142 @@ fn test_strings() {
fn test_empty_str() {
let eval = |args: Vec<String>| evaluate_arguments(&args);
assert_eq!(eval(vec!["".to_owned()]), Ok(false));
- assert_eq!(eval(vec!["c".to_owned(), "=".to_owned(), "".to_owned()]), Ok(false));
+ assert_eq!(
+ eval(vec!["c".to_owned(), "=".to_owned(), "".to_owned()]),
+ Ok(false)
+ );
}
#[test]
fn test_integers_arguments() {
fn vec_string(args: &[&str]) -> Vec<String> {
- args.iter().map(|s| (*s).to_owned()).collect::<Vec<String>>()
+ args.iter()
+ .map(|s| (*s).to_owned())
+ .collect::<Vec<String>>()
}
// Equal To
- assert_eq!(evaluate_arguments(&vec_string(&["10", "-eq", "10"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["10", "-eq", "5"])), Ok(false));
- assert_eq!(evaluate_arguments(&vec_string(&["-10", "-eq", "-10"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["-10", "-eq", "10"])), Ok(false));
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["10", "-eq", "10"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["10", "-eq", "5"])),
+ Ok(false)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["-10", "-eq", "-10"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["-10", "-eq", "10"])),
+ Ok(false)
+ );
// Greater Than or Equal To
- assert_eq!(evaluate_arguments(&vec_string(&["10", "-ge", "10"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["10", "-ge", "5"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["5", "-ge", "10"])), Ok(false));
- assert_eq!(evaluate_arguments(&vec_string(&["-9", "-ge", "-10"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["-10", "-ge", "-10"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["-10", "-ge", "10"])), Ok(false));
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["10", "-ge", "10"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["10", "-ge", "5"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["5", "-ge", "10"])),
+ Ok(false)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["-9", "-ge", "-10"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["-10", "-ge", "-10"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["-10", "-ge", "10"])),
+ Ok(false)
+ );
// Less Than or Equal To
- assert_eq!(evaluate_arguments(&vec_string(&["5", "-le", "5"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["5", "-le", "10"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["10", "-le", "5"])), Ok(false));
- assert_eq!(evaluate_arguments(&vec_string(&["-11", "-le", "-10"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["-10", "-le", "-10"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["10", "-le", "-10"])), Ok(false));
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["5", "-le", "5"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["5", "-le", "10"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["10", "-le", "5"])),
+ Ok(false)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["-11", "-le", "-10"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["-10", "-le", "-10"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["10", "-le", "-10"])),
+ Ok(false)
+ );
// Less Than
- assert_eq!(evaluate_arguments(&vec_string(&["5", "-lt", "10"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["10", "-lt", "5"])), Ok(false));
- assert_eq!(evaluate_arguments(&vec_string(&["-11", "-lt", "-10"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["10", "-lt", "-10"])), Ok(false));
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["5", "-lt", "10"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["10", "-lt", "5"])),
+ Ok(false)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["-11", "-lt", "-10"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["10", "-lt", "-10"])),
+ Ok(false)
+ );
// Greater Than
- assert_eq!(evaluate_arguments(&vec_string(&["10", "-gt", "5"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["5", "-gt", "10"])), Ok(false));
- assert_eq!(evaluate_arguments(&vec_string(&["-9", "-gt", "-10"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["-10", "-gt", "10"])), Ok(false));
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["10", "-gt", "5"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["5", "-gt", "10"])),
+ Ok(false)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["-9", "-gt", "-10"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["-10", "-gt", "10"])),
+ Ok(false)
+ );
// Not Equal To
- assert_eq!(evaluate_arguments(&vec_string(&["10", "-ne", "5"])), Ok(true));
- assert_eq!(evaluate_arguments(&vec_string(&["5", "-ne", "5"])), Ok(false));
- assert_eq!(evaluate_arguments(&vec_string(&["-10", "-ne", "-10"])), Ok(false));
- assert_eq!(evaluate_arguments(&vec_string(&["-10", "-ne", "10"])), Ok(true));
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["10", "-ne", "5"])),
+ Ok(true)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["5", "-ne", "5"])),
+ Ok(false)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["-10", "-ne", "-10"])),
+ Ok(false)
+ );
+ assert_eq!(
+ evaluate_arguments(&vec_string(&["-10", "-ne", "10"])),
+ Ok(true)
+ );
}
#[test]
@@ -447,8 +539,14 @@ fn test_file_is_symlink() {
#[test]
fn test_file_has_execute_permission() {
- assert_eq!(file_has_execute_permission("../../testing/executable_file"), true);
- assert_eq!(file_has_execute_permission("../../testing/empty_file"), false);
+ assert_eq!(
+ file_has_execute_permission("../../testing/executable_file"),
+ true
+ );
+ assert_eq!(
+ file_has_execute_permission("../../testing/empty_file"),
+ false
+ );
}
#[test]
@@ -457,5 +555,8 @@ fn test_file_size_is_greater_than_zero() {
file_size_is_greater_than_zero("../../testing/file_with_text"),
true
);
- assert_eq!(file_size_is_greater_than_zero("../../testing/empty_file"), false);
+ assert_eq!(
+ file_size_is_greater_than_zero("../../testing/empty_file"),
+ false
+ );
}
diff --git a/members/lexers/src/lib.rs b/members/lexers/src/lib.rs
index 1b98f502..35638230 100644
--- a/members/lexers/src/lib.rs
+++ b/members/lexers/src/lib.rs
@@ -4,5 +4,4 @@ extern crate bitflags;
pub mod arguments;
pub mod designators;
-pub use self::arguments::*;
-pub use self::designators::*;
+pub use self::{arguments::*, designators::*};
diff --git a/members/ranges/src/index.rs b/members/ranges/src/index.rs
index 5dc172fe..cb5015a5 100644
--- a/members/ranges/src/index.rs
+++ b/members/ranges/src/index.rs
@@ -25,7 +25,7 @@ impl Index {
/// - A positive value `n` represents `Forward(n)`
/// - A negative value `-n` reprents `Backwards(n - 1)` such that:
/// ```ignore,rust
- /// assert_eq!(Index::new(-1), Index::Backward(0))
+ /// assert_eq!(Index::new(-1), Index::Backward(0))
/// ```
pub fn new(input: isize) -> Index {
if input < 0 {
diff --git a/members/ranges/src/lib.rs b/members/ranges/src/lib.rs
index 86d06ae7..c2b5997a 100644
--- a/members/ranges/src/lib.rs
+++ b/members/ranges/src/lib.rs
@@ -5,10 +5,7 @@ mod parse;
mod range;
mod select;
-pub use self::index::*;
-pub use self::parse::*;
-pub use self::range::*;
-pub use self::select::*;
+pub use self::{index::*, parse::*, range::*, select::*};
#[cfg(test)]
mod tests {
diff --git a/members/ranges/src/select.rs b/members/ranges/src/select.rs
index 2a6bad1b..083f1e78 100644
--- a/members/ranges/src/select.rs
+++ b/members/ranges/src/select.rs
@@ -1,8 +1,9 @@
+use super::{parse_index_range, Index, Range};
use smallstring::SmallString;
use std::{
- iter::{empty, FromIterator}, str::FromStr,
+ iter::{empty, FromIterator},
+ str::FromStr,
};
-use super::{parse_index_range, Index, Range};
/// Represents a filter on a vector-like object
#[derive(Debug, PartialEq, Clone)]
diff --git a/members/sys/src/sys/redox/mod.rs b/members/sys/src/sys/redox/mod.rs
index 71cc7736..e02527bc 100644
--- a/members/sys/src/sys/redox/mod.rs
+++ b/members/sys/src/sys/redox/mod.rs
@@ -65,7 +65,8 @@ pub fn waitpid(pid: i32, status: &mut i32, options: i32) -> Result<i32, i32> {
}
pub fn strerror(errno: i32) -> &'static str {
- syscall::error::STR_ERROR.get(errno as usize)
+ syscall::error::STR_ERROR
+ .get(errno as usize)
.map(|err| *err)
.unwrap_or("Unknown Error")
}
@@ -230,9 +231,7 @@ pub fn tcsetpgrp(tty_fd: RawFd, pgid: u32) -> io::Result<()> {
pub fn dup(fd: RawFd) -> io::Result<RawFd> { cvt(syscall::dup(fd, &[])) }
-pub fn dup2(old: RawFd, new: RawFd) -> io::Result<RawFd> {
- cvt(syscall::dup2(old, new, &[]))
-}
+pub fn dup2(old: RawFd, new: RawFd) -> io::Result<RawFd> { cvt(syscall::dup2(old, new, &[])) }
pub fn close(fd: RawFd) -> io::Result<()> { cvt(syscall::close(fd)).and(Ok(())) }
diff --git a/members/sys/src/sys/unix/mod.rs b/members/sys/src/sys/unix/mod.rs
index df0f0d71..59d7fa5f 100644
--- a/members/sys/src/sys/unix/mod.rs
+++ b/members/sys/src/sys/unix/mod.rs
@@ -54,9 +54,7 @@ pub fn strerror(errno: i32) -> &'static str {
return "Unknown Error";
}
- CStr::from_ptr(ptr)
- .to_str()
- .unwrap_or("Unknown Error")
+ CStr::from_ptr(ptr).to_str().unwrap_or("Unknown Error")
}
}
@@ -326,9 +324,7 @@ pub fn tcsetpgrp(fd: RawFd, pgrp: u32) -> io::Result<()> {
pub fn dup(fd: RawFd) -> io::Result<RawFd> { cvt(unsafe { libc::dup(fd) }) }
-pub fn dup2(old: RawFd, new: RawFd) -> io::Result<RawFd> {
- cvt(unsafe { libc::dup2(old, new) })
-}
+pub fn dup2(old: RawFd, new: RawFd) -> io::Result<RawFd> { cvt(unsafe { libc::dup2(old, new) }) }
pub fn close(fd: RawFd) -> io::Result<()> { cvt(unsafe { libc::close(fd) }).and(Ok(())) }
diff --git a/rustfmt.toml b/rustfmt.toml
index 9e639d7c..d6df6d66 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -12,5 +12,4 @@ reorder_impl_items = true
struct_field_align_threshold = 30
use_field_init_shorthand = true
wrap_comments = true
-write_mode = "overwrite"
merge_imports = true
diff --git a/src/lib/parser/loops/for_grammar.rs b/src/lib/parser/loops.rs
similarity index 100%
rename from src/lib/parser/loops/for_grammar.rs
rename to src/lib/parser/loops.rs
diff --git a/src/lib/parser/loops/mod.rs b/src/lib/parser/loops/mod.rs
deleted file mode 100644
index c6414c5d..00000000
--- a/src/lib/parser/loops/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub mod for_grammar;
diff --git a/src/lib/parser/mod.rs b/src/lib/parser/mod.rs
index deb1ad66..936decd0 100644
--- a/src/lib/parser/mod.rs
+++ b/src/lib/parser/mod.rs
@@ -7,6 +7,6 @@ mod statement;
pub use self::{assignments::Primitive, quotes::Terminator};
pub(crate) use self::{
- loops::for_grammar::ForExpression, shell_expand::{expand_string, Expander, Select},
+ loops::ForExpression, shell_expand::{expand_string, Expander, Select},
statement::{parse_and_validate, StatementSplitter},
};
diff --git a/src/lib/parser/shell_expand/README.md b/src/lib/parser/shell_expand/README.md
deleted file mode 100644
index 66a802cc..00000000
--- a/src/lib/parser/shell_expand/README.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# Shell Expand Module
-
-This module reduces statements into a set of word token primitives, and applies expansions to these tokens accordingly.
-In order to be modular, the expansion logic is supplied with a structure containing closure references, which are
-provided higher up by the shell.
-
-## Tokenizing Words
-
-The `words` module contains the `WordIterator` which reduces statments into set of `WordTokens`. The following are
-supported word tokens:
-
-- `Normal(&str)`: Normal words that do not require any expansion at all
-- `Whitespace(&str)`: Whitespace between words
-- `Variable(&str, bool)`: A variable name and an indication of if it was quoted
-- `Process(&str, bool)`: A subshell and an indication of if it was quoted
-- `Tilde(&str)`: A tilde expression such as ~ or ~user
-- `Brace(Vec<&str>)`: A brace expansion and each of its inner elements
diff --git a/src/lib/parser/shell_expand/braces.rs b/src/lib/parser/shell_expand/braces.rs
deleted file mode 100644
index c0040d15..00000000
--- a/src/lib/parser/shell_expand/braces.rs
+++ /dev/null
@@ -1,192 +0,0 @@
-use super::permutate::Permutator;
-use smallvec::SmallVec;
-
-#[derive(Debug)]
-/// A token primitive for the `expand_braces` function.
-pub(crate) enum BraceToken {
- Normal(String),
- Expander,
-}
-
-pub(crate) fn expand_braces<'a>(
- tokens: &'a [BraceToken],
- expanders: &'a [&'a [&'a str]],
-) -> Box<Iterator<Item = String> + 'a> {
- if expanders.len() > 1 {
- let multiple_brace_expand = MultipleBraceExpand::new(tokens, expanders);
- Box::new(multiple_brace_expand)
- } else if expanders.len() == 1 {
- let single_brace_expand = SingleBraceExpand {
- elements: expanders[0].iter().map(|element| *element),
- tokens,
- loop_count: 0,
- };
- Box::new(single_brace_expand)
- } else {
- Box::new(::std::iter::empty())
- }
-}
-
-fn escape_string(output: &mut SmallVec<[u8; 64]>, input: &str) {
- let mut backslash = false;
- for character in input.bytes() {
- if backslash {
- match character {
- b'{' | b'}' | b',' => output.push(character),
- _ => {
- output.push(b'\\');
- output.push(character);
- }
- }
- backslash = false;
- } else if character == b'\\' {
- backslash = true;
- } else {
- output.push(character);
- }
- }
-}
-
-pub struct MultipleBraceExpand<'a> {
- permutator: Permutator<'a, str>,
- tokens: &'a [BraceToken],
- buffer: Vec<&'a str>
-}
-
-impl<'a> MultipleBraceExpand<'a> {
- pub(crate) fn new(
- tokens: &'a [BraceToken],
- expanders: &'a [&'a [&'a str]]
- ) -> MultipleBraceExpand<'a> {
- MultipleBraceExpand {
- permutator: Permutator::new(expanders),
- tokens,
- buffer: vec![""; expanders.len()]
- }
- }
-}
-
-impl<'a> Iterator for MultipleBraceExpand<'a> {
- type Item = String;
-
- fn next(&mut self) -> Option<Self::Item> {
- if self.permutator.next_with_buffer(&mut self.buffer) {
- let mut strings = self.buffer.iter();
- let small_vec: SmallVec<[u8; 64]> = self.tokens.iter().fold(
- SmallVec::with_capacity(64),
- |mut small_vec, token| match *token {
- BraceToken::Normal(ref text) => {
- escape_string(&mut small_vec, text);
- small_vec
- }
- BraceToken::Expander => {
- escape_string(&mut small_vec, strings.next().unwrap());
- small_vec
- }
- },
- );
- Some(unsafe { String::from_utf8_unchecked(small_vec.to_vec()) })
- } else {
- None
- }
- }
-}
-
-pub struct SingleBraceExpand<'a, 'b, I>
-where
- I: Iterator<Item = &'a str>,
-{
- elements: I,
- tokens: &'b [BraceToken],
- loop_count: usize,
-}
-
-impl<'a, 'b, I> Iterator for SingleBraceExpand<'a, 'b, I>
-where
- I: Iterator<Item = &'a str>,
-{
- type Item = String;
-
- fn next(&mut self) -> Option<Self::Item> {
- match self.loop_count {
- 0 => {
- let small_vec: SmallVec<[u8; 64]> = self.tokens.iter().fold(
- SmallVec::with_capacity(64),
- |mut small_vec, token| match *token {
- BraceToken::Normal(ref text) => {
- escape_string(&mut small_vec, text);
- small_vec
- }
- BraceToken::Expander => {
- escape_string(&mut small_vec, self.elements.next().unwrap());
- small_vec
- }
- },
- );
- self.loop_count = 1;
- Some(unsafe { String::from_utf8_unchecked(small_vec.to_vec()) })
- }
- _ => {
- if let Some(element) = self.elements.next() {
- let small_vec: SmallVec<[u8; 64]> = self.tokens.iter().fold(
- SmallVec::with_capacity(64),
- |mut small_vec, token| match *token {
- BraceToken::Normal(ref text) => {
- escape_string(&mut small_vec, text);
- small_vec
- }
- BraceToken::Expander => {
- escape_string(&mut small_vec, element);
- small_vec
- }
- },
- );
- Some(unsafe { String::from_utf8_unchecked(small_vec.to_vec()) })
- } else {
- None
- }
- }
- }
- }
-}
-
-#[test]
-fn test_multiple_brace_expand() {
- let expanders: &[&[&str]] = &[&["1", "2"][..], &["3", "4"][..], &["5", "6"][..]];
- let tokens: &[BraceToken] = &[
- BraceToken::Normal("AB".to_owned()),
- BraceToken::Expander,
- BraceToken::Normal("CD".to_owned()),
- BraceToken::Expander,
- BraceToken::Normal("EF".to_owned()),
- BraceToken::Expander,
- BraceToken::Normal("GH".to_owned()),
- ];
- assert_eq!(
- MultipleBraceExpand ::new(tokens, expanders).collect::<Vec<String>>(),
- vec![
- "AB1CD3EF5GH".to_owned(),
- "AB1CD3EF6GH".to_owned(),
- "AB1CD4EF5GH".to_owned(),
- "AB1CD4EF6GH".to_owned(),
- "AB2CD3EF5GH".to_owned(),
- "AB2CD3EF6GH".to_owned(),
- "AB2CD4EF5GH".to_owned(),
- "AB2CD4EF6GH".to_owned(),
- ]
- );
-}
-
-#[test]
-fn test_single_brace_expand() {
- let elements = &["one", "two", "three"];
- let tokens: &[BraceToken] = &[BraceToken::Normal("A=".to_owned()), BraceToken::Expander];
- assert_eq!(
- SingleBraceExpand {
- elements: elements.iter().map(|element| *element),
- tokens,
- loop_count: 0,
- }.collect::<Vec<String>>(),
- vec!["A=one".to_owned(), "A=two".to_owned(), "A=three".to_owned()]
- );
-}
--
GitLab