feat(core): add more IO extensions (create-dir, remove-dir, get-cwd, set-cwd)

sqrew · sqrew · commit 3e539294807c · 2026-03-25T18:59:20.000-04:00
Adds cross-platform wrappers for mkdir, rmdir, getcwd, and chdir to IO.Raw
and high-level Result-returning versions to the IO module. Also fixes several
typos in existing IO documentation and updates tests to cover new functionality.
diff --git a/core/IO.carp b/core/IO.carp
@@ -97,7 +97,7 @@
     (register fread- (Fn [a Int Int (Ptr FILE)] Int) "fread")
 
     (doc fread
-      "Reads a given numebr of bytes from a file into C-String."
+      "Reads a given number of bytes from a file into C-String."
       "Wraps `fread` from the C standard library."
       "Consider using [`read-file`](#read-file) or"
       "[`unsafe-read-file`](#unsafe-read-file) instead.")
@@ -115,7 +115,7 @@
 
     (doc fflush!
       "Flushes buffered data via [`fflush`](#fflush)"
-      ", but discards the result, making this function appropraite for use as"
+      ", but discards the result, making this function appropriate for use as"
       "a side effect in `do` forms.")
     (defn fflush! [file]
       (ignore (fflush file)))
@@ -227,6 +227,21 @@
       "Returns an array containing the names of the entries in the directory"
       "designated by `path`, skipping `.` and `..`.")
     (register list-dir (Fn [&String] (Array String)) "IO_Raw_list_MINUS_dir")
+
+    (doc mkdir
+      "Creates a directory at the given path."
+      "Returns an integer indicating success (0) or failure (-1)."
+      "Wraps `mkdir` from the C standard library.")
+    (register mkdir (Fn [&String] Int) "IO_mkdir")
+
+    (doc rmdir
+      "Removes a directory at the given path."
+      "Returns an integer indicating success (0) or failure (-1)."
+      "Wraps `rmdir` from the C standard library.")
+    (register rmdir (Fn [&String] Int) "IO_rmdir")
+
+    (register get-cwd (Fn [] (Ptr CChar)) "IO_Raw_get_MINUS_cwd")
+    (register set-cwd (Fn [&String] Int) "IO_Raw_set_MINUS_cwd")
   )
 
   (doc file-exists? "Checks if a file exists at the given path.")
@@ -235,6 +250,46 @@
   (doc dir-exists? "Checks if a directory exists at the given path.")
   (register dir-exists? (Fn [&String] Bool))
 
+  (doc get-cwd
+    "Returns the current working directory."
+    ""
+    "Returns a (Result String String) indicating success or failure.")
+  (defn get-cwd []
+    (let [res (IO.Raw.get-cwd)]
+      (if (null? res)
+        (Result.Error (fmt "Failed to get current working directory: %s" &(System.error-text)))
+        (let [s (String.from-cstr res)]
+          (do
+            (Pointer.free res)
+            (Result.Success s))))))
+
+  (doc set-cwd
+    "Sets the current working directory to `path`."
+    ""
+    "Returns a (Result Bool String) indicating success or failure.")
+  (defn set-cwd [path]
+    (if (Int.= (IO.Raw.set-cwd path) 0)
+      (Result.Success true)
+      (Result.Error (fmt "Failed to set current working directory to '%s': %s" path &(System.error-text)))))
+
+  (doc create-dir
+    "Creates a directory at the given path."
+    ""
+    "Returns a (Result Bool String) indicating success or failure.")
+  (defn create-dir [path]
+    (if (Int.= (IO.Raw.mkdir path) 0)
+      (Result.Success true)
+      (Result.Error (fmt "Failed to create directory '%s': %s" path &(System.error-text)))))
+
+  (doc remove-dir
+    "Removes a directory at the given path."
+    ""
+    "Returns a (Result Bool String) indicating success or failure.")
+  (defn remove-dir [path]
+    (if (Int.= (IO.Raw.rmdir path) 0)
+      (Result.Success true)
+      (Result.Error (fmt "Failed to remove directory '%s': %s" path &(System.error-text)))))
+
   (doc list-dir
     "Returns an array containing the names of the entries in the directory"
     "designated by `path`, skipping `.` and `..`."
@@ -278,7 +333,7 @@
 
   (doc open-file
     "Opens a [FILE](#file) with the given name using a designated mode"
-    "(e.g. [r]ead, [w]rite, [a]ppend),  [rb] read binary...)."
+    "(e.g. [r]ead, [w]rite, [a]ppend),  [rb] read binary...."
     "See `fopen` from the C standard library for a description of valid mode parameters.")
   (defn open-file [filename mode]
     (let [ptr (IO.Raw.fopen filename mode)]
@@ -423,7 +478,7 @@
   `(IO.println %(build-str* forms)))
 
 (doc print*
-  "Prints any number of values to [`stdout`](#stdout), using thier"
+  "Prints any number of values to [`stdout`](#stdout), using their"
   "`str` implementations."
   ""
   "```"
diff --git a/core/carp_io.h b/core/carp_io.h
@@ -1,5 +1,12 @@
 #include <sys/stat.h>
 #include <dirent.h>
+#ifdef _WIN32
+#include <direct.h>
+#define getcwd _getcwd
+#define chdir _chdir
+#else
+#include <unistd.h>
+#endif
 
 void IO_println(String* s) {
     puts(*s);
@@ -95,3 +102,34 @@ Array IO_Raw_list_MINUS_dir(const String* path) {
     }
     return result;
 }
+
+int IO_mkdir(const String* path) {
+#ifdef _WIN32
+    return _mkdir(*path);
+#else
+    return mkdir(*path, 0777);
+#endif
+}
+
+int IO_rmdir(const String* path) {
+#ifdef _WIN32
+    return _rmdir(*path);
+#else
+    return rmdir(*path);
+#endif
+}
+
+String IO_Raw_get_MINUS_cwd() {
+    char* buffer = getcwd(NULL, 0);
+    if (buffer) {
+        String result = CARP_MALLOC(strlen(buffer) + 1);
+        strcpy(result, buffer);
+        free(buffer);
+        return result;
+    }
+    return NULL;
+}
+
+int IO_Raw_set_MINUS_cwd(const String* path) {
+    return chdir(*path);
+}
diff --git a/test/io.carp b/test/io.carp
@@ -9,7 +9,8 @@
         (IO.Raw.unlink! file-name)
         (if (Result.error? &read?)
           (Result.unsafe-from-error   read?)
-          (Result.unsafe-from-success read?)  )))))
+          (let [res (Result.unsafe-from-success read?)]
+            res))))))
 
 (deftest test
   (assert-nothing test
@@ -21,20 +22,94 @@
                "getenv works on existant variable"
   )
   (let [ data "Icke\n\tdette\n\tkieke mal,\nOochen, Flesch und Beene." ]  ; include \n in test data!
-    (assert-equal test
-                  data
-                  &(write-then-read data "io_carp_testdata.txt")
-                  "write-file then read-file"  ))
+    (let [res (write-then-read data "io_carp_testdata.txt")]
+      (assert-equal test
+                    data
+                    &res
+                    "write-file then read-file"  )))
   (let [ file-name "io_carp_append_testdata.txt"
          first     "hello"
          second    " world" ]
     (do
       (ignore (IO.write-file first file-name))
       (ignore (IO.append-file second file-name))
       (let-do [ result (IO.read-file file-name) ]
-        (IO.Raw.unlink! file-name)
-        (assert-equal test
-                      "hello world"
-                      &(Result.unsafe-from-success result)
-                      "append-file appends to existing file"))))
+        (do
+          (IO.Raw.unlink! file-name)
+          (let [s (Result.unsafe-from-success result)]
+            (assert-equal test
+                          "hello world"
+                          &s
+                          "append-file appends to existing file"))))))
+
+  (assert-true test (IO.file-exists? "core/IO.carp") "file-exists? works for existing file")
+  (assert-false test (IO.file-exists? "nonexistent_file_xyz.txt") "file-exists? returns false for non-existent file")
+  (assert-true test (IO.dir-exists? "core") "dir-exists? works for existing directory")
+  (assert-false test (IO.dir-exists? "nonexistent_dir_xyz") "dir-exists? returns false for non-existent directory")
+
+  (let [old-file "test_move_old.txt"
+        new-file "test_move_new.txt"]
+    (do
+      (ignore (IO.write-file "test move content" old-file))
+      (let [move-res (IO.move-file old-file new-file)]
+        (let-do [t1 (assert-true test (Result.success? &move-res) "move-file success")
+                 t2 (assert-true (ref t1) (IO.file-exists? new-file) "new file exists after move")
+                 t3 (assert-false (ref t2) (IO.file-exists? old-file) "old file does not exist after move")]
+          (do
+            (ignore (IO.remove-file new-file))
+            t3)))))
+
+  (let [src-file "test_copy_src.txt"
+        dest-file "test_copy_dest.txt"]
+    (do
+      (ignore (IO.write-file "test copy content" src-file))
+      (let [copy-res (IO.copy-file src-file dest-file)]
+        (let-do [t1 (assert-true test (Result.success? &copy-res) "copy-file success")
+                 t2 (assert-true (ref t1) (IO.file-exists? dest-file) "dest file exists after copy")
+                 t3 (assert-true (ref t2) (IO.file-exists? src-file) "src file still exists after copy")]
+          (do
+            (ignore (IO.remove-file src-file))
+            (ignore (IO.remove-file dest-file))
+            t3)))))
+
+  (let [dir-res (IO.list-dir "core")]
+    (do
+      (let [t1 (assert-true test (Result.success? &dir-res) "list-dir success")]
+        (if (Result.success? &dir-res)
+          (let [entries (Result.unsafe-from-success dir-res)]
+            (assert-true (ref t1) (Array.contains? &entries &@"IO.carp") "list-dir contains IO.carp"))
+          t1))))
+
+  (let [dir-path "test_dir_xyz"]
+    (do
+      (let [create-res (IO.create-dir dir-path)]
+        (let-do [t1 (assert-true test (Result.success? &create-res) "create-dir success")
+                 t2 (assert-true (ref t1) (IO.dir-exists? dir-path) "dir exists after create")]
+          (let [remove-res (IO.remove-dir dir-path)]
+            (let-do [t3 (assert-true (ref t2) (Result.success? &remove-res) "remove-dir success")
+                     t4 (assert-false (ref t3) (IO.dir-exists? dir-path) "dir gone after remove")]
+              t4))))))
+
+  (let [cwd-res (IO.get-cwd)]
+    (do
+      (let [t1 (assert-true test (Result.success? &cwd-res) "get-cwd success")]
+        (if (Result.success? &cwd-res)
+          (let [cwd (Result.unsafe-from-success cwd-res)]
+            (assert-true (ref t1) (Int.> (String.length &cwd) 0) "cwd not empty"))
+          t1))))
+
+  (let [old-cwd (Result.unsafe-from-success (IO.get-cwd))
+        new-dir "test_cwd_change"]
+    (do
+      (ignore (IO.create-dir new-dir))
+      (let [set-res (IO.set-cwd new-dir)]
+        (let-do [t1 (assert-true test (Result.success? &set-res) "set-cwd success")
+                 curr-cwd-res (IO.get-cwd)
+                 t2 (assert-true (ref t1) (Result.success? &curr-cwd-res) "get-cwd after set success")]
+          (let [curr-cwd (Result.unsafe-from-success curr-cwd-res)
+                t3 (assert-true (ref t2) (String.ends-with? &curr-cwd new-dir) "cwd changed")]
+            (do
+              (ignore (IO.set-cwd &old-cwd))
+              (ignore (IO.remove-dir new-dir))
+              t3))))))
 )
diff --git a/test/io_extensions.carp b/test/io_extensions.carp
@@ -42,3 +42,29 @@
       (let [entries (Result.unsafe-from-success dir-res)]
         (assert-true (ref t1) (Array.contains? &entries &@"IO.carp") "list-dir contains IO.carp"))
       t1)))
+
+(deftest test-dir-ops
+  (let-do [dir-path "test_dir_xyz"
+           create-res (IO.create-dir dir-path)
+           t1 (assert-true test-dir-ops (Result.success? &create-res) "create-dir success")
+           t2 (assert-true (ref t1) (IO.dir-exists? dir-path) "dir exists after create")
+           remove-res (IO.remove-dir dir-path)
+           t3 (assert-true (ref t2) (Result.success? &remove-res) "remove-dir success")
+           t4 (assert-false (ref t3) (IO.dir-exists? dir-path) "dir gone after remove")]
+    t4))
+
+(deftest test-cwd
+  (let-do [cwd-res (IO.get-cwd)
+           t1 (assert-true test-cwd (Result.success? &cwd-res) "get-cwd success")
+           old-cwd (Result.unsafe-from-success cwd-res)
+           new-dir "test_cwd_change"
+           _1 (IO.create-dir new-dir)
+           set-res (IO.set-cwd new-dir)
+           t2 (assert-true (ref t1) (Result.success? &set-res) "set-cwd success")
+           curr-cwd-res (IO.get-cwd)
+           t3 (assert-true (ref t2) (Result.success? &curr-cwd-res) "get-cwd after set success")
+           curr-cwd (Result.unsafe-from-success curr-cwd-res)
+           t4 (assert-true (ref t3) (String.ends-with? &curr-cwd new-dir) "cwd changed")
+           _2 (IO.set-cwd &old-cwd)
+           _3 (IO.remove-dir new-dir)]
+    t4))
