image never works with bytes directly so just make it accept the alre…

…ady parsed data

src/image.rs

@@ -1,16 +1,12 @@
 use factor::factor::factor;
 
-use crate::{parser, RawGrid};
+use crate::RawGrid;
 
-pub struct Image(RawGrid);
+pub struct Image(pub RawGrid);
 
 impl Image {
     const MAX_WIDTH: usize = 320;
 
-    pub fn new(buffer: &[u8], width: usize, parser: parser::ParserType) -> Self {
-        Self(parser.process_input(buffer, width))
-    }
-
     pub fn data(&self) -> RawGrid {
         self.0.clone()
     }
@@ -91,7 +87,9 @@ mod tests {
     #[test]
     fn basic_properties() {
         let data: u32 = 0b00011011000110110001101100011011;
-        let mut image = Image::new(&data.to_be_bytes(), 4, ParserType::type_str("cga"));
+        let parser = ParserType::type_str("cga");
+        let parsed = parser.process_input(&data.to_be_bytes(), 4);
+        let mut image = Image(parsed);
 
         assert_eq!(image.pixel_count(), 16);
         assert_eq!(image.width(), 4);
@@ -100,11 +98,12 @@ mod tests {
         assert_eq!(image.width_factors(), [2, 4, 8]);
         assert_eq!(image.height_factors(), [2]);
         assert!(!image.is_tall());
-        image = Image::new(
+
+        let parsed = parser.process_input(
             &0b0001101100011011000110110001101100011011000110110001101100011011_u64.to_be_bytes(),
             2,
-            ParserType::type_str("cga"),
         );
+        image = Image(parsed);
         assert!(image.is_tall());
     }
 
@@ -129,20 +128,18 @@ mod tests {
     //rework these tests to actually be wider than max_width, or do something clever to overwrite it
     fn tiling() {
         let data: u32 = 0b00011011000110110001101100011011;
-        let tiled = image::tile(
-            Image::new(&data.to_be_bytes(), 2, ParserType::type_str("cga")).data(),
-            2,
-        );
+        let parser = ParserType::type_str("cga");
+        let parsed = parser.process_input(&data.to_be_bytes(), 2);
+
+        let tiled = image::tile(Image(parsed).data(), 2);
         assert_eq!(
             tiled,
             [vec![0, 1, 0, 1, 0, 1, 0, 1], vec![2, 3, 2, 3, 2, 3, 2, 3],]
         );
 
         let data: u64 = 0b0001101100011011000110110001101100011011000110110001101100011011;
-        let tiled = image::tile(
-            Image::new(&data.to_be_bytes(), 2, ParserType::type_str("cga")).data(),
-            2,
-        );
+        let parsed = parser.process_input(&data.to_be_bytes(), 2);
+        let tiled = image::tile(Image(parsed).data(), 2);
         assert_eq!(
             tiled,
             vec![

src/lib.rs

@@ -1,6 +1,7 @@
 #![doc = include_str!("../README.md")]
 
 pub mod color;
+pub mod file_data;
 pub mod image;
 pub mod parser;
 

src/terminal/main.rs

@@ -6,6 +6,7 @@ use std::path::Path;
 use clap::Parser;
 
 use cega::color::palette::palette_from_abbr;
+//use cega::file_data::Raw;
 use cega::image::{self, Image};
 use cega::parser::ParserType;
 #[cfg(feature = "png")]
@@ -18,9 +19,9 @@ use cega::ImageType;
 pub fn main() -> Result<(), Box<dyn std::error::Error>> {
     let args = args::Args::parse();
 
-    let reader = std::fs::read(Path::new(&args.image))?;
+    let file_data = &std::fs::read(Path::new(&args.image))?;
     let parser = ParserType::type_str(&args.image_parser);
-    let image = Image::new(&reader, args.width, parser);
+    let image = Image(parser.process_input(&file_data, args.width));
 
     let image_data = if args.tile_height.is_some() {
         image::tile(image.data(), args.tile_height.unwrap())

src/wasm/image.rs

@@ -39,7 +39,9 @@ impl ImageFile<'_> {
         if self.file_input.mime_type.contains("image") {
             self.file_input.data.clone()
         } else {
-            let image = Image::new(&self.file_input.data, self.width, ParserType::CGA);
+            let parser = ParserType::CGA;
+            let parsed = parser.process_input(&self.file_input.data, self.width);
+            let image = Image(parsed);
             let palette = palette_from_abbr("cga0");
             let mut bytes: Vec<u8> = Vec::new();