repo: rename executor -> eval

crates/eval/src/debug/instructions/mod.rs

@@ -0,0 +1,44 @@
+pub mod read {
+    use image::{io::Reader as ImageReader, DynamicImage};
+    use ir::instruction::read::{Read, SourceType};
+
+    pub fn read(Read { source, .. }: Read) -> DynamicImage {
+        // TODO: actual error handling
+        let img = ImageReader::open(match source {
+            SourceType::File(path) => path,
+        })
+        .expect("something went wrong :(((");
+
+        img.decode().expect("couldn't decode image")
+    }
+}
+
+pub mod write {
+    use image::{DynamicImage, ImageFormat};
+    use ir::instruction::write::{TargetFormat, TargetType, Write};
+
+    pub fn write(Write { target, format }: Write, input_data: &DynamicImage) {
+        input_data
+            .save_with_format(
+                match target {
+                    TargetType::File(path) => path,
+                },
+                match format {
+                    TargetFormat::Jpeg => ImageFormat::Jpeg,
+                    TargetFormat::Png => ImageFormat::Png,
+                },
+            )
+            .expect("couldn't save file — come back later and handle me properly please uwu");
+    }
+}
+
+pub mod filters {
+    pub mod invert {
+        use image::DynamicImage;
+
+        pub fn invert(mut input_data: DynamicImage) -> DynamicImage {
+            input_data.invert();
+            input_data
+        }
+    }
+}

crates/eval/src/debug/mod.rs

@@ -0,0 +1,37 @@
+use ir::instruction::{Filter, Kind};
+
+use crate::value::Dynamic;
+mod instructions;
+
+pub struct Executor;
+
+impl crate::Executor for Executor {
+    fn execute(instruction: Kind, input: Option<Dynamic>) -> Option<Dynamic> {
+        match instruction {
+            Kind::Read(read_instruction) => {
+                Some(Dynamic::Image(instructions::read::read(read_instruction)))
+            }
+            Kind::Write(write_instruction) => {
+                instructions::write::write(
+                    write_instruction,
+                    match input {
+                        Some(Dynamic::Image(ref img)) => img,
+                        _ => panic!("awawwawwa"),
+                    },
+                );
+                None
+            }
+            Kind::Math(_) => todo!(),
+            Kind::Blend(_) => todo!(),
+            Kind::Noise(_) => todo!(),
+            Kind::Filter(filter_instruction) => match filter_instruction {
+                Filter::Invert => Some(Dynamic::Image(instructions::filters::invert::invert(
+                    match input {
+                        Some(Dynamic::Image(img)) => img,
+                        _ => panic!("invalid value type for invert"),
+                    },
+                ))),
+            },
+        }
+    }
+}