feat: add new_screen and enable/disable/enabled/disabled

add support for ray!().new_screen("Hello 🦀") and stuff around enable/disable

Author: ALameLlama

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "ray-rust"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 authors = ["ALameLlama NicholasACiechanowski@gmail.com"]
 description = "Spatie Ray in Rust"

Cargo.toml

@@ -11,7 +11,9 @@ mod tests;
 macro_rules! ray {
     // If no arguments are passed, just create a new Ray instance
     () => {{
-        Ray::new()
+        let ray = Ray::new();
+
+        ray
     }};
     // If one or more arguments are passed, log them
     ($($arg:expr),*) => {{
@@ -116,6 +118,7 @@ impl RayMeta {
 
 pub struct Ray {
     request: RayPayload,
+    is_enabled: bool,
 }
 
 impl Ray {
@@ -126,10 +129,15 @@ impl Ray {
                 payloads: vec![],
                 meta: RayMeta::new(),
             },
+            is_enabled: true,
         }
     }
 
     pub fn send(&mut self) -> &mut Self {
+        if !self.is_enabled {
+            return self;
+        }
+
         let request = self.request.clone();
 
         let client = reqwest::blocking::Client::new();
@@ -139,6 +147,14 @@ impl Ray {
         self
     }
 
+    pub fn die(&mut self, status: i32) {
+        panic!("exited with code {}", status);
+
+        // TODO: I think we need to use process::exit here to actually exit the process since this
+        // doesn't stop threaded work but I can't see a nice way to test this. I'm going to leave it
+        // std::process::exit(status);
+    }
+
     pub fn clear_all(&mut self) -> &mut Self {
         let message = RayMessage::ClearAll(RayClearAll {
             label: RayMessageType::ClearAll,
@@ -155,6 +171,27 @@ impl Ray {
         self.send()
     }
 
+    pub fn new_screen(&mut self, name: Option<&str>) -> &mut Self {
+        let message = RayMessage::NewScreen(RayNewScreen {
+            label: RayMessageType::NewScreen,
+            name: name.unwrap_or("").to_string(),
+        });
+
+        let content = RayContent {
+            content_type: RayNewScreen::get_type(),
+            origin: RayOrigin::new(),
+            content: message,
+        };
+
+        self.request.payloads.push(content);
+
+        self.send()
+    }
+
+    pub fn clear_screen(&mut self) -> &mut Self {
+        self.new_screen(None)
+    }
+
     pub fn log(&mut self, values: Vec<String>) -> &mut Self {
         let message = RayMessage::Log(RayLog {
             label: RayMessageType::Log,
@@ -254,7 +291,7 @@ impl Ray {
         self.send()
     }
 
-    pub fn count(&mut self, name: &str) -> &mut Self {
+    pub fn count(&mut self, _name: &str) -> &mut Self {
         // create a new counter hashmap with the name?
         // increment the counter hashmap with the name?
         // return a custom message with "called name x times"
@@ -270,24 +307,24 @@ impl Ray {
         todo!();
     }
 
-    pub fn die(&mut self, status: i32) {
-        std::process::exit(status);
-    }
-
     pub fn disable(&mut self) -> &mut Self {
-        todo!();
+        self.is_enabled = false;
+
+        self
     }
 
-    pub fn disabled(&mut self) -> &mut Self {
-        todo!();
+    pub fn disabled(&mut self) -> bool {
+        !self.is_enabled
     }
 
     pub fn enable(&mut self) -> &mut Self {
-        todo!();
+        self.is_enabled = true;
+
+        self
     }
 
-    pub fn enabled(&mut self) -> &mut Self {
-        todo!();
+    pub fn enabled(&mut self) -> bool {
+        self.is_enabled
     }
 
     pub fn file(&mut self) -> &mut Self {
@@ -343,10 +380,6 @@ impl Ray {
         todo!();
     }
 
-    pub fn new_screen(&mut self) -> &mut Self {
-        todo!();
-    }
-
     pub fn notify(&mut self) -> &mut Self {
         todo!();
     }

src/lib.rs

@@ -10,6 +10,7 @@ pub enum RayMessage {
     ClearAll(RayClearAll),
     Confetti(RayConfetti),
     Charles(RayCharles),
+    NewScreen(RayNewScreen),
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -20,6 +21,7 @@ pub enum RayMessageType {
     ClearAll,
     Confetti,
     Charles,
+    NewScreen,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -29,6 +31,7 @@ pub enum RayContentType {
     Color,
     ClearAll,
     Confetti,
+    NewScreen,
 }
 
 impl RayContentType {
@@ -39,6 +42,7 @@ impl RayContentType {
             RayContentType::Color => "color".to_string(),
             RayContentType::ClearAll => "clear_all".to_string(),
             RayContentType::Confetti => "confetti".to_string(),
+            RayContentType::NewScreen => "new_screen".to_string(),
         }
     }
 }
@@ -155,3 +159,16 @@ impl RayCharles {
         RayContentType::Custom.to_string()
     }
 }
+
+// https://github.com/spatie/ray/blob/main/src/Payloads/NewScreenPayload.php
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct RayNewScreen {
+    pub label: RayMessageType,
+    pub name: String,
+}
+
+impl RayNewScreen {
+    pub fn get_type() -> String {
+        RayContentType::NewScreen.to_string()
+    }
+}

src/message.rs

@@ -1,34 +1,146 @@
 use super::*;
 
-// TODO: make these test actually test something,
-// this is just so I can see if they're coming into ray
+// TODO: Add mocking? look into the request body and add tests to ensure the correct data is being sent
 #[test]
-fn test_ray_log() {
-    ray!("Hello, Log!");
+fn test_ray_macro_no_args() {
+    let ray = ray!();
+    assert_eq!(ray.request.payloads.len(), 0);
 }
 
 #[test]
-fn test_ray_text() {
-    ray!().text("Hello, Text!");
+fn test_ray_macro_with_one_arg() {
+    let ray = ray!("Hello, Ray Macro");
+    assert_eq!(ray.request.payloads.len(), 1);
 }
 
 #[test]
-fn test_ray_color() {
-    ray!("Hello Color").color("green");
+fn test_ray_macro_with_multiple_args() {
+    let ray = ray!("Hello", "Ray Macro");
+    assert_eq!(ray.request.payloads.len(), 1);
 }
 
 #[test]
-fn test_ray_html() {
-    ray!().html("<strong>Hello, HTML!</strong>");
+#[should_panic(expected = "exited with code 1")]
+fn test_rd_marco_no_args() {
+    std::panic::set_hook(Box::new(|panic_info| {
+        if let Some(payload) = panic_info.payload().downcast_ref::<&str>() {
+            if *payload == "exited with code 1" {
+                std::process::exit(1);
+            }
+        }
+    }));
+
+    let ray = rd!();
+    assert_eq!(ray.request.payloads.len(), 0);
+}
+
+#[test]
+#[should_panic(expected = "exited with code 1")]
+fn test_rd_macro_with_one_arg() {
+    std::panic::set_hook(Box::new(|panic_info| {
+        if let Some(payload) = panic_info.payload().downcast_ref::<&str>() {
+            if *payload == "exited with code 1" {
+                std::process::exit(1);
+            }
+        }
+    }));
+
+    let ray = rd!("Hello, Rd Macro");
+    assert_eq!(ray.request.payloads.len(), 1);
+}
+
+#[test]
+#[should_panic(expected = "exited with code 1")]
+fn test_rd_macro_with_multiple_args() {
+    std::panic::set_hook(Box::new(|panic_info| {
+        if let Some(payload) = panic_info.payload().downcast_ref::<&str>() {
+            if *payload == "exited with code 1" {
+                std::process::exit(1);
+            }
+        }
+    }));
+
+    let ray = rd!("Hello", "Rd Macro");
+    assert_eq!(ray.request.payloads.len(), 1);
+}
+
+#[test]
+fn test_ray_log_function() {
+    let mut ray = Ray::new();
+    ray.log(vec!["Hello, Log!".to_string()]);
+    assert_eq!(ray.request.payloads.len(), 1);
+}
+
+#[test]
+fn test_ray_text_function() {
+    let mut ray = Ray::new();
+    ray.text("Hello, Text!");
+    assert_eq!(ray.request.payloads.len(), 1);
+}
+
+#[test]
+fn test_ray_color_function() {
+    let mut ray = Ray::new();
+    ray.text("Hello, Color").color("green");
+    assert_eq!(ray.request.payloads.len(), 2);
+}
+
+#[test]
+fn test_ray_html_function() {
+    let mut ray = Ray::new();
+    ray.html("<strong>Hello, HTML!</strong>");
+    assert_eq!(ray.request.payloads.len(), 1);
+}
+
+#[test]
+fn test_ray_clear_all_function() {
+    let mut ray = Ray::new();
+    ray.clear_all();
+    assert_eq!(ray.request.payloads.len(), 1);
+}
+
+#[test]
+fn test_ray_confetti_function() {
+    let mut ray = Ray::new();
+    ray.confetti();
+    assert_eq!(ray.request.payloads.len(), 1);
+}
+
+#[test]
+fn test_ray_charles_function() {
+    let mut ray = Ray::new();
+    ray.charles();
+    assert_eq!(ray.request.payloads.len(), 1);
+}
+
+#[test]
+fn test_ray_new_screen_function() {
+    let mut ray = Ray::new();
+    ray.new_screen(None);
+    assert_eq!(ray.request.payloads.len(), 1);
+}
+
+#[test]
+fn test_ray_new_screen_with_name_function() {
+    let mut ray = Ray::new();
+    ray.new_screen(Some("Hello, New Screen!"));
+    assert_eq!(ray.request.payloads.len(), 1);
 }
 
 #[test]
-fn test_ray_clear_all() {
-    ray!("Hello Clear");
-    ray!().clear_all();
+fn test_ray_disable() {
+    // TODO: Add a test to ensure the request is not sent
+    let mut ray = Ray::new();
+    ray.disable();
+    assert_eq!(ray.disabled(), true);
+    assert_eq!(ray.enabled(), false);
 }
 
 #[test]
-fn test_ray_conffiti() {
-    ray!().confetti();
+fn test_ray_enabled() {
+    // TODO: Add a test to ensure the request is sent
+    let mut ray = Ray::new();
+    ray.enable();
+    assert_eq!(ray.enabled(), true);
+    assert_eq!(ray.disabled(), false);
 }