separating out stdout

Cargo.lock

@@ -14,6 +14,12 @@ version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
 
+[[package]]
+name = "camino"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@@ -65,6 +71,7 @@ name = "look_at_that"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "camino",
  "tempfile",
 ]
 

Cargo.toml

@@ -13,6 +13,7 @@ path = "src/main.rs"
 
 [dependencies]
 anyhow = { version = "1.0.97" }
+camino = "1.1.9"
 
 [dev-dependencies]
 tempfile = "3.19.1"

src/main.rs

@@ -1,5 +1,6 @@
-use anyhow::{Context as _, Result, bail};
+use anyhow::{Context as _, Result};
 use std::{
+    borrow::Cow,
     fs,
     io::{Read as _, Write as _},
 };
@@ -10,63 +11,65 @@ fn main() -> Result<()> {
 }
 
 struct App {
-    filenames: Vec<String>,
     is_terminal: bool,
+    paths: Vec<Cow<'static, str>>,
 }
 
 impl App {
     fn try_new() -> Result<Self> {
         use std::io::IsTerminal as _;
-
         let is_terminal = std::io::stdout().is_terminal();
+
         let mut args = std::env::args();
         let _exe_name = args.next().context("How do we not have an exe name?")?;
-        let mut filenames = vec![];
+        let mut paths = vec![];
         for arg in args {
-            filenames.push(arg);
+            paths.push(arg.into());
         }
+        let paths = if paths.is_empty() {
+            vec![".".into()]
+        } else {
+            paths
+        };
 
-        Ok(App {
-            filenames,
-            is_terminal,
-        })
+        Ok(App { is_terminal, paths })
     }
 
     fn run(&self) -> Result<()> {
-        if self.filenames.is_empty() {
-            return self.ls(".");
-        }
-        for filename in &self.filenames {
-            let metadata = fs::metadata(filename)?;
-            if metadata.is_dir() {
-                self.ls(filename)?;
+        for path in &self.paths {
+            let metadata = fs::metadata(&**path)?;
+            let mut lk = if metadata.is_dir() {
+                Lk::try_new_ls(path)?
             } else {
-                self.cat(filename)?;
+                Lk::try_new_cat(path)?
+            };
+            while let Some(buf) = lk.poll()? {
+                std::io::stdout().write_all(&buf)?;
             }
         }
         Ok(())
     }
+}
 
-    fn cat(&self, filename: &str) -> Result<()> {
-        let mut cat = Cat::try_new(filename)?;
-        while let Some(buf) = cat.poll()? {
-            std::io::stdout().write_all(buf)?;
-        }
-        Ok(())
+enum Lk {
+    Cat(Cat),
+    Ls(Ls),
+}
+
+impl Lk {
+    fn try_new_cat(path: &str) -> Result<Self> {
+        Ok(Self::Cat(Cat::try_new(path)?))
     }
 
-    fn ls(&self, filename: &str) -> Result<()> {
-        // Use `/usr/bin` just in case for some weird reason we're symlinked as ls,
-        // we don't want to recurse into ourselves
-        let mut command = std::process::Command::new("/usr/bin/ls");
-        if self.is_terminal {
-            command.arg("--color=always");
+    fn try_new_ls(path: &str) -> Result<Self> {
+        Ok(Self::Ls(Ls::try_new(path)?))
+    }
+
+    fn poll(&mut self) -> Result<Option<Cow<[u8]>>> {
+        match self {
+            Lk::Cat(x) => x.poll(),
+            Lk::Ls(x) => x.poll(),
         }
-        let status = command.arg(filename).status()?;
-        if !status.success() {
-            bail!("subprocess `ls` failed");
-        }
-        Ok(())
     }
 }
 
@@ -76,19 +79,40 @@ struct Cat {
 }
 
 impl Cat {
-    fn try_new(filename: &str) -> Result<Self> {
-        let f = fs::File::open(filename)?;
+    fn try_new(path: &str) -> Result<Self> {
+        let f = fs::File::open(path)?;
         let buf = vec![0u8; 4_096];
         Ok(Self { f, buf })
     }
 
-    fn poll(&mut self) -> Result<Option<&[u8]>> {
+    fn poll(&mut self) -> Result<Option<Cow<[u8]>>> {
         let bytes_read = self.f.read(&mut self.buf)?;
         let buf = &self.buf[0..bytes_read];
         if bytes_read == 0 {
             return Ok(None);
         }
-        Ok(Some(buf))
+        Ok(Some(buf.into()))
+    }
+}
+
+struct Ls {
+    d: fs::ReadDir,
+}
+
+impl Ls {
+    fn try_new(path: &str) -> Result<Self> {
+        let d = fs::read_dir(path)?;
+        Ok(Self { d })
+    }
+
+    fn poll(&mut self) -> Result<Option<Cow<[u8]>>> {
+        let Some(entry) = self.d.next() else {
+            return Ok(None);
+        };
+        let entry = entry?;
+        let path = entry.file_name();
+        let path = path.to_str().context("file name is not valid Unicode")?;
+        Ok(Some(format!("{path}\n").into_bytes().into()))
     }
 }