ci(format): Action to check formatting

This action checks the formatting of the rust files

Signed-off-by: Vaishnav Sabari Girish <vaishnav.sabari.girish@gmail.com>

Author: Vaishnav-Sabari-Girish

.githooks/pre-commit

@@ -0,0 +1,8 @@
+#!/bin/sh
+set -e
+
+REPO_ROOT=$(git rev-parse --show-toplevel)
+
+cargo fmt --all
+
+git add -u

.github/workflows/fmt.yml

@@ -0,0 +1,17 @@
+name: Format the Rust Code
+
+on:
+    pull_request: 
+    push: 
+      branches: [ "main" ]
+
+jobs:
+  fmt: 
+      runs-on: ubuntu-latest
+      
+      steps:
+          - uses: actions/checkout@v6
+          - uses: dtolnay/rust-toolchain@stable
+            with:
+                components: rustfmt
+          - run: cargo fmt --all -- --check

crates/ns_io/src/input.rs

@@ -1,5 +1,5 @@
+use std::ffi::{c_double, c_float, c_int};
 use std::io::{self};
-use std::ffi::{c_int, c_float,c_double};
 
 // Helper function to read a line from stdin safely
 fn read_line_buffer() -> String {
@@ -12,7 +12,7 @@ fn read_line_buffer() -> String {
 
 // Read Integer
 #[unsafe(no_mangle)]
-/// # Safety 
+/// # Safety
 ///
 /// This function reads an integer input
 pub unsafe extern "C" fn ns_read_int(ptr: *mut c_int) {
@@ -25,17 +25,17 @@ pub unsafe extern "C" fn ns_read_int(ptr: *mut c_int) {
     // Try to parse. If it fails, default to 0
     let val: c_int = input.parse().unwrap_or(0);
 
-    // Unsafe: Write value to C memory address 
+    // Unsafe: Write value to C memory address
     unsafe {
         *ptr = val;
     }
 }
 
-// Read float 
+// Read float
 #[unsafe(no_mangle)]
-/// # Safety 
+/// # Safety
 ///
-/// This function reads a floating point input 
+/// This function reads a floating point input
 pub unsafe extern "C" fn ns_read_float(ptr: *mut c_float) {
     if ptr.is_null() {
         return;
@@ -46,17 +46,17 @@ pub unsafe extern "C" fn ns_read_float(ptr: *mut c_float) {
     // Try to parse. If it fails, default to 0
     let val: c_float = input.parse().unwrap_or(0.0);
 
-    // Unsafe: Write value to C memory address 
+    // Unsafe: Write value to C memory address
     unsafe {
         *ptr = val;
     }
 }
 
-// Read double 
+// Read double
 #[unsafe(no_mangle)]
-/// # Safety 
+/// # Safety
 ///
-/// This function reads a double input 
+/// This function reads a double input
 pub unsafe extern "C" fn ns_read_double(ptr: *mut c_double) {
     if ptr.is_null() {
         return;
@@ -67,9 +67,8 @@ pub unsafe extern "C" fn ns_read_double(ptr: *mut c_double) {
     // Try to parse. If it fails, default to 0
     let val: c_double = input.parse().unwrap_or(0.0);
 
-    // Unsafe: Write value to C memory address 
+    // Unsafe: Write value to C memory address
     unsafe {
         *ptr = val;
     }
 }
-

crates/ns_io/src/lib.rs

@@ -1,3 +1,3 @@
-// Print Module 
-pub mod print;
+// Print Module
 pub mod input;
+pub mod print;

crates/ns_io/src/print.rs

@@ -1,40 +1,39 @@
+use ns_string::NsString;
 use std::ffi::CStr;
-use std::os::raw::c_char;
 use std::io::{self, Write};
-use ns_string::NsString;
+use std::os::raw::c_char;
 
 // No Newline functions
 
-// Print Integer 
+// Print Integer
 #[unsafe(no_mangle)]
 pub extern "C" fn ns_print_int(val: i32) {
     // Adds newline by default
     print!("{}", val);
     io::stdout().flush().unwrap();
 }
 
-// Print Float 
+// Print Float
 #[unsafe(no_mangle)]
 pub extern "C" fn ns_print_float(val: f32) {
     // Adds newline by default
     print!("{}", val);
     io::stdout().flush().unwrap();
 }
 
-// Print Double 
+// Print Double
 #[unsafe(no_mangle)]
 pub extern "C" fn ns_print_double(val: f64) {
-    // Adds newline by default 
+    // Adds newline by default
     print!("{}", val);
     io::stdout().flush().unwrap();
 }
 
-
 // Print String
 #[unsafe(no_mangle)]
 // If the C string is not null terminaltes '\0' , the function will keep on reading memory until
 // the program crashes (Segfault)
-// The below suppression is to prevent that 
+// The below suppression is to prevent that
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 pub extern "C" fn ns_print_string(ptr: *const c_char) {
     // Never Dereference a NULL pointer
@@ -44,9 +43,7 @@ pub extern "C" fn ns_print_string(ptr: *const c_char) {
         return;
     }
 
-    let c_str = unsafe {
-        CStr::from_ptr(ptr)
-    };
+    let c_str = unsafe { CStr::from_ptr(ptr) };
 
     // Converting to Rust String
     // "to_string_lossy()" is best if the string has non-UTF-8 characters
@@ -56,33 +53,32 @@ pub extern "C" fn ns_print_string(ptr: *const c_char) {
 }
 
 // Newline functions
-// Print Integer 
+// Print Integer
 #[unsafe(no_mangle)]
 pub extern "C" fn ns_println_int(val: i32) {
     // Adds newline by default
     println!("{}", val);
 }
 
-// Print Float 
+// Print Float
 #[unsafe(no_mangle)]
 pub extern "C" fn ns_println_float(val: f32) {
     // Adds newline by default
     println!("{}", val);
 }
 
-// Print Double 
+// Print Double
 #[unsafe(no_mangle)]
 pub extern "C" fn ns_println_double(val: f64) {
-    // Adds newline by default 
+    // Adds newline by default
     println!("{}", val);
 }
 
-
 // Print String
 #[unsafe(no_mangle)]
 // If the C string is not null terminaltes '\0' , the function will keep on reading memory until
 // the program crashes (Segfault)
-// The below suppression is to prevent that 
+// The below suppression is to prevent that
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 pub extern "C" fn ns_println_string(ptr: *const c_char) {
     // Never Dereference a NULL pointer
@@ -91,9 +87,7 @@ pub extern "C" fn ns_println_string(ptr: *const c_char) {
         return;
     }
 
-    let c_str = unsafe {
-        CStr::from_ptr(ptr)
-    };
+    let c_str = unsafe { CStr::from_ptr(ptr) };
 
     // Converting to Rust String
     // "to_string_lossy()" is best if the string has non-UTF-8 characters
@@ -106,13 +100,9 @@ pub extern "C" fn ns_println_string(ptr: *const c_char) {
 #[unsafe(no_mangle)]
 pub extern "C" fn ns_print_ns_string(val: NsString) {
     let bytes = if val.is_heap {
-        unsafe {
-            std::slice::from_raw_parts(val.data.heap.ptr, val.len)
-        }
+        unsafe { std::slice::from_raw_parts(val.data.heap.ptr, val.len) }
     } else {
-        unsafe {
-            &val.data.inline_data[..val.len]
-        }
+        unsafe { &val.data.inline_data[..val.len] }
     };
 
     // COnvert to rust string (To handle non-UTF-8)
@@ -123,17 +113,13 @@ pub extern "C" fn ns_print_ns_string(val: NsString) {
     io::stdout().flush().unwrap();
 }
 
-// Newline 
+// Newline
 #[unsafe(no_mangle)]
 pub extern "C" fn ns_println_ns_string(val: NsString) {
     let bytes = if val.is_heap {
-        unsafe {
-            std::slice::from_raw_parts(val.data.heap.ptr, val.len)
-        }
+        unsafe { std::slice::from_raw_parts(val.data.heap.ptr, val.len) }
     } else {
-        unsafe {
-            &val.data.inline_data[..val.len]
-        }
+        unsafe { &val.data.inline_data[..val.len] }
     };
 
     // COnvert to rust string (To handle non-UTF-8)
@@ -142,4 +128,3 @@ pub extern "C" fn ns_println_ns_string(val: NsString) {
     // Print and flush
     println!("{}", rust_str);
 }
-

crates/ns_string/src/lib.rs

@@ -1,27 +1,27 @@
 use std::ffi::CStr;
-use std::os::raw::c_char;
 use std::mem::ManuallyDrop;
+use std::os::raw::c_char;
 
 // Heap allocation
 #[repr(C)]
 pub struct NsStringHeap {
     pub ptr: *mut u8,
-    pub capacity: usize
+    pub capacity: usize,
 }
 
 // Union: 24 bytes of inline chars or the heap struct
 #[repr(C)]
 pub union NsStringData {
     pub inline_data: [u8; 24],
-    pub heap: ManuallyDrop<NsStringHeap>, 
+    pub heap: ManuallyDrop<NsStringHeap>,
 }
 
 // Final string struct
 #[repr(C)]
 pub struct NsString {
     pub len: usize,
     pub is_heap: bool,
-    pub data: NsStringData
+    pub data: NsStringData,
 }
 
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
@@ -31,13 +31,13 @@ pub extern "C" fn ns_string_new(c_str: *const c_char) -> NsString {
         return NsString {
             len: 0,
             is_heap: false,
-            data: NsStringData { inline_data: [0; 24] }
+            data: NsStringData {
+                inline_data: [0; 24],
+            },
         };
     }
 
-    let rust_str = unsafe {
-        CStr::from_ptr(c_str)
-    }.to_bytes();
+    let rust_str = unsafe { CStr::from_ptr(c_str) }.to_bytes();
 
     let len = rust_str.len();
 
@@ -49,7 +49,9 @@ pub extern "C" fn ns_string_new(c_str: *const c_char) -> NsString {
         NsString {
             len,
             is_heap: false,
-            data: NsStringData { inline_data: inline }
+            data: NsStringData {
+                inline_data: inline,
+            },
         }
     } else {
         // If it is more than 24 bytes, put it on the heap
@@ -67,11 +69,8 @@ pub extern "C" fn ns_string_new(c_str: *const c_char) -> NsString {
         NsString {
             len,
             is_heap: true,
-            data: NsStringData { 
-                heap: ManuallyDrop::new(NsStringHeap {
-                    ptr, 
-                    capacity
-                })
+            data: NsStringData {
+                heap: ManuallyDrop::new(NsStringHeap { ptr, capacity }),
             },
         }
     }
@@ -84,9 +83,7 @@ pub extern "C" fn ns_string_free(s: *mut NsString) {
         return;
     }
 
-    let s_ref = unsafe {
-        &mut *s
-    };
+    let s_ref = unsafe { &mut *s };
 
     if s_ref.is_heap {
         unsafe {