Implement EditorBuffer::open_file()

core/src/editor_buffer/mod.rs

@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use crate::{Point, TextBuffer};
+use crate::{Point, TextBuffer, TextBufferWriter};
 
 mod command;
 pub use command::{Command, Movement, Unit};
@@ -12,7 +12,11 @@ pub struct EditorBuffer {
     filepath: Option<PathBuf>,
 }
 
-pub enum CommandResponse {}
+#[derive(Debug)]
+pub enum CommandResponse {
+    Success(String),
+    Failure(String),
+}
 
 impl EditorBuffer {
     /// Create new empty [EditorBuffer]
@@ -35,8 +39,35 @@ impl EditorBuffer {
         }
     }
 
-    fn open_file(&mut self, _filepath: PathBuf) -> CommandResponse {
+    fn open_file(&mut self, filepath: PathBuf) -> CommandResponse {
-        todo!()
+        match std::fs::File::open(&filepath) {
+            Ok(mut file) => {
+                let mut buffer = TextBuffer::new();
+                match std::io::copy(&mut file, &mut TextBufferWriter::new(&mut buffer)) {
+                    Ok(bytes_read) => {
+                        let msg = format!(
+                            "Read {bytes_read} bytes from \"{}\"",
+                            filepath.to_string_lossy()
+                        );
+                        self.filepath = Some(filepath);
+                        self.cursor = Point::default();
+                        self.buffer = buffer;
+                        CommandResponse::Success(msg)
+                    }
+                    Err(err) => CommandResponse::Failure(format!("{}", err)),
+                }
+            }
+            Err(err) => {
+                if err.kind() == std::io::ErrorKind::NotFound {
+                    CommandResponse::Failure(format!(
+                        "File not found: \"{}\"",
+                        filepath.to_string_lossy()
+                    ))
+                } else {
+                    CommandResponse::Failure(format!("{}", err))
+                }
+            }
+        }
     }
 
     fn save_file(&mut self, _filepath: Option<PathBuf>) -> CommandResponse {
@@ -67,3 +98,46 @@ impl EditorBuffer {
         todo!()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::TextBufferReader;
+    use std::io::Read;
+
+    #[test]
+    fn load_file_loads_expected_contents() {
+        let test_file_path: PathBuf = [
+            env!("CARGO_MANIFEST_DIR"),
+            r"test_data/Les_Trois_Mousquetaires.txt",
+        ]
+        .iter()
+        .collect();
+        let expected_text = std::fs::read_to_string(&test_file_path).unwrap();
+        let mut target = EditorBuffer::new();
+        assert!(matches!(
+            target.execute(Command::OpenFile(test_file_path)),
+            CommandResponse::Success(_)
+        ));
+
+        let mut buffer_bytes = Vec::new();
+        TextBufferReader::new(&target.buffer)
+            .read_to_end(&mut buffer_bytes)
+            .unwrap();
+        let buffer_text = String::from_utf8(buffer_bytes).unwrap();
+        assert_eq!(&expected_text, &buffer_text);
+    }
+
+    #[test]
+    fn load_file_reports_error_with_missing_file() {
+        let test_file_path: PathBuf = [env!("CARGO_MANIFEST_DIR"), r"test_data/Not_a_File.txt"]
+            .iter()
+            .collect();
+        let expected_message = format!("File not found: \"{}\"", test_file_path.to_string_lossy());
+        let mut target = EditorBuffer::new();
+        match target.execute(Command::OpenFile(test_file_path)) {
+            CommandResponse::Failure(s) => assert_eq!(expected_message, s),
+            _ => panic!(),
+        }
+    }
+}