refactor: simplify api

Author: wfxr

examples/simple.rs

@@ -1,7 +1,6 @@
 use std::io;
-use std::io::BufReader;
 
 fn main() {
-    let reader = Box::new(BufReader::new(io::stdin()));
-    code_minimap::print(reader, 1.0, 1.0, None).unwrap();
+    let stdin = io::stdin();
+    code_minimap::printstd(stdin.lock(), 1.0, 1.0, None).unwrap();
 }

examples/write_to_string.rs

@@ -1,8 +1,7 @@
 use std::io;
-use std::io::BufReader;
 
 fn main() {
-    let reader = Box::new(BufReader::new(io::stdin()));
-    let s = code_minimap::write_to_string(reader, 1.0, 1.0, None).unwrap();
-    print!("{}", s);
+    let stdin = io::stdin();
+    let minimap = code_minimap::write_to_string(stdin.lock(), 1.0, 1.0, None).unwrap();
+    print!("{}", minimap);
 }

src/bin/code-minimap/main.rs

@@ -20,11 +20,12 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
             Opt::clap().gen_completions_to(env!("CARGO_PKG_NAME"), *shell, &mut std::io::stdout());
         }
         None => {
+            let stdin = io::stdin();
             let reader: Box<dyn BufRead> = match &opt.file {
                 Some(path) => Box::new(BufReader::new(File::open(path)?)),
-                None => Box::new(BufReader::new(io::stdin())),
+                None => Box::new(stdin.lock()),
             };
-            code_minimap::print(reader, opt.hscale, opt.vscale, opt.padding)?;
+            code_minimap::printstd(reader, opt.hscale, opt.vscale, opt.padding)?;
         }
     }
     Ok(())

src/core.rs

@@ -1,15 +1,12 @@
 use itertools::Itertools;
-use std::cell::RefCell;
 use std::cmp;
 use std::io::{self, BufRead, Write};
 use std::ops::Range;
-use std::rc::Rc;
-use std::vec::Vec;
 
-/// Write minimap to output
+/// Write minimap to the writer.
 pub fn write(
-    output: Rc<RefCell<dyn Write>>,
-    reader: Box<dyn BufRead>,
+    mut writer: impl Write,
+    reader: impl BufRead,
     hscale: f64,
     vscale: f64,
     padding: Option<usize>,
@@ -36,12 +33,12 @@ pub fn write(
         }
         frame.iter_mut().skip(chunk_size).for_each(|row| *row = 0..0);
         scale_frame(&mut frame, hscale);
-        write_frame(output.clone(), &frame, padding)?;
+        write_frame(&mut writer, &frame, padding)?;
     }
     Ok(())
 }
 
-/// Print minimap to stdout
+/// Print minimap to the stdout.
 ///
 /// # Examples
 ///
@@ -51,14 +48,14 @@ pub fn write(
 /// use std::io;
 /// use std::io::BufReader;
 ///
-/// let reader = Box::new(BufReader::new(io::stdin()));
-/// code_minimap::print(reader, 1.0, 1.0, None).unwrap();
+/// let stdin = io::stdin();
+/// code_minimap::printstd(stdin.lock(), 1.0, 1.0, None).unwrap();
 /// ```
-pub fn print(reader: Box<dyn BufRead>, hscale: f64, vscale: f64, padding: Option<usize>) -> io::Result<()> {
-    write(Rc::new(RefCell::new(io::stdout())), reader, hscale, vscale, padding)
+pub fn printstd(reader: impl BufRead, hscale: f64, vscale: f64, padding: Option<usize>) -> io::Result<()> {
+    write(io::stdout(), reader, hscale, vscale, padding)
 }
 
-/// Write minimap to string
+/// Write minimap to a string.
 ///
 /// # Examples
 ///
@@ -68,23 +65,17 @@ pub fn print(reader: Box<dyn BufRead>, hscale: f64, vscale: f64, padding: Option
 /// use std::io;
 /// use std::io::BufReader;
 ///
-/// let reader = Box::new(BufReader::new(io::stdin()));
-/// let s = code_minimap::write_to_string(reader, 1.0, 1.0, None).unwrap();
+/// let stdin = io::stdin();
+/// let s = code_minimap::write_to_string(stdin.lock(), 1.0, 1.0, None).unwrap();
 /// print!("{}", s);
 /// ```
-pub fn write_to_string(
-    reader: Box<dyn BufRead>,
-    hscale: f64,
-    vscale: f64,
-    padding: Option<usize>,
-) -> io::Result<String> {
-    let buf = Rc::new(RefCell::new(Vec::new()));
-    write(buf.clone(), reader, hscale, vscale, padding)?;
-    let buf = Rc::try_unwrap(buf).unwrap().into_inner();
+pub fn write_to_string(reader: impl BufRead, hscale: f64, vscale: f64, padding: Option<usize>) -> io::Result<String> {
+    let mut buf = Vec::new();
+    write(&mut buf, reader, hscale, vscale, padding)?;
     Ok(String::from_utf8(buf).unwrap())
 }
 
-fn write_frame(output: Rc<RefCell<dyn Write>>, frame: &[Range<usize>], padding: Option<usize>) -> std::io::Result<()> {
+fn write_frame(mut output: impl Write, frame: &[Range<usize>], padding: Option<usize>) -> std::io::Result<()> {
     let idx = |pos| {
         frame
             .iter()
@@ -97,8 +88,8 @@ fn write_frame(output: Rc<RefCell<dyn Write>>, frame: &[Range<usize>], padding:
         .map(|i| BRAILLE_MATRIX[(idx(i)) + (idx(i + 1) << 4)])
         .collect();
     match padding {
-        Some(padding) => writeln!(output.borrow_mut(), "{0:<1$}", line, padding),
-        None => writeln!(output.borrow_mut(), "{}", line),
+        Some(padding) => writeln!(output, "{0:<1$}", line, padding),
+        None => writeln!(output, "{}", line),
     }
 }
 
@@ -147,7 +138,7 @@ mod test {
         case("  a  b c\n d efg  \n    h  i\n jk", "⢐⡛⠿⠭")
     )]
     fn test_write_to_string(input: &'static str, expected: &str) {
-        let actual = write_to_string(Box::new(input.as_bytes()), 1.0, 1.0, None).unwrap();
+        let actual = write_to_string(input.as_bytes(), 1.0, 1.0, None).unwrap();
         assert_eq!(expected, actual.trim());
     }
 }