read() and recite() overhaul

Rebuilt the LR parser (i.e. read()) from the ground up. This required
that some changes be made to recite(), in order to accomodate the new
data structures. These data structures were each split out into their
own file, in order to make working with each component a bit easier.

In addition to reworking the parts of the parser already present, some
new features were also added, such as:
  - Support for strings (' and ")
  - Support for environment variables ($)
  - Support for interpreting tild as $HOME (~)
  - Support for sub-reading and sub-reciting (`)

1 files changed, 134 insertions, 0 deletions

diff --git a/src/poem/recite/ps.rs b/src/poem/recite/ps.rs
new file mode 100644
index 0000000..61ed66d
--- /dev/null
+++ b/src/poem/recite/ps.rs
@@ -0,0 +1,134 @@
+/// Fork into a process from a Verse
+///
+/// Figures out whether or not the given Verse is a couplet. If it is, fork
+/// into a process, and pipe the contents of out `out` into STDIN. If not, then
+/// simply fork into the process.
+///
+/// # Arguments
+/// * `$verse: &Verse` - The verse to fork into
+/// * `$out: &mut String` - If the $verse is a couplet, the contents of STDOUT from the last verse
+#[macro_export]
+macro_rules! task {
+    ($verse:expr, $out:expr) => {
+        if $verse.couplet {
+            let mut child = Command::new($verse.verb())
+                .args($verse.clause().unwrap_or(vec![]))
+                .stdin(Stdio::piped())
+                .spawn()?;
+
+            let stdin = child.stdin.as_mut().ok_or(io::ErrorKind::BrokenPipe)?;
+            stdin.write_all(&$out.as_bytes())?;
+            $out.clear();
+
+            child
+        } else {
+            Command::new($verse.verb())
+                .args($verse.clause().unwrap_or(vec![]))
+                .spawn()?
+        }
+    };
+}
+
+/// Fork into a process from a Verse, and capture STDOUT
+///
+/// Figures out whether or not the given Verse is a couplet. If it is, fork
+/// into a process, and pipe the contents of out `out` into STDIN. If not, then
+/// simply fork into the process. Additionally, this function will capture
+/// STDOUT of the process specified by the Verse, and store it in `out`.
+///
+/// # Arguments
+/// * `$verse: &Verse` - The verse to fork into
+/// * `$out: &mut String` - If the $verse is a couplet, the contents of STDOUT from the last verse
+#[macro_export]
+macro_rules! ctask {
+    ($verse:expr, $out:expr) => {
+        if $verse.couplet {
+            let mut child = Command::new($verse.verb())
+                .args($verse.clause().unwrap_or(vec![]))
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .spawn()?;
+
+            let stdin = child.stdin.as_mut().ok_or(io::ErrorKind::BrokenPipe)?;
+            stdin.write_all(&$out.as_bytes())?;
+            $out.clear();
+
+            child
+        } else {
+            Command::new($verse.verb())
+                .args($verse.clause().unwrap_or(vec![]))
+                .stdout(Stdio::piped())
+                .spawn()?
+        }
+    };
+}
+
+/// Fork into a background process from a Verse
+///
+/// Figures out whether or not the given Verse is a couplet. If it is, fork
+/// into a backgournd process, and pipe the contents of out `out` into STDIN.
+/// If not, then simply fork into the background process.
+///
+/// # Arguments
+/// * `$verse: &Verse` - The verse to fork into
+/// * `$out: &mut String` - If the $verse is a couplet, the contents of STDOUT from the last verse
+#[macro_export]
+macro_rules! btask {
+    ($verse:expr, $out:expr) => {
+        if $verse.couplet {
+            let mut child = Command::new($verse.verb())
+                .args($verse.clause().unwrap_or(vec![]))
+                .stdin(Stdio::piped())
+                .process_group(0)
+                .spawn()?;
+
+            let stdin = child.stdin.as_mut().ok_or(io::ErrorKind::BrokenPipe)?;
+            stdin.write_all(&$out.as_bytes())?;
+            $out.clear();
+
+            child
+        } else {
+            Command::new($verse.verb())
+                .args($verse.clause().unwrap_or(vec![]))
+                .process_group(0)
+                .spawn()?
+        }
+    };
+}
+
+/// Fork into a background process from a Verse, and capture STDOUT
+///
+/// Figures out whether or not the given Verse is a couplet. If it is, fork
+/// into a backgournd process, and pipe the contents of out `out` into STDIN.
+/// If not, then simply fork into the background process. This captures the
+/// output of STDOUT, in order to redirect it to a file when the program
+/// finishes running.
+///
+/// # Arguments
+/// * `$verse: &Verse` - The verse to fork into
+/// * `$out: &mut String` - If the $verse is a couplet, the contents of STDOUT from the last verse
+#[macro_export]
+macro_rules! iobtask {
+    ($verse:expr, $out:expr) => {
+        if $verse.couplet {
+            let mut child = Command::new($verse.verb())
+                .args($verse.clause().unwrap_or(vec![]))
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .process_group(0)
+                .spawn()?;
+
+            let stdin = child.stdin.as_mut().ok_or(io::ErrorKind::BrokenPipe)?;
+            stdin.write_all(&$out.as_bytes())?;
+            $out.clear();
+
+            child
+        } else {
+            Command::new($verse.verb())
+                .args($verse.clause().unwrap_or(vec![]))
+                .stdout(Stdio::piped())
+                .process_group(0)
+                .spawn()?
+        }
+    };
+}