feat(core): add IO.file-exists? and IO.dir-exists?

Author: sqrew

core/IO.carp

@@ -153,6 +153,24 @@
     (defn unlink! [file-name]
       (ignore (unlink file-name)))
 
+    (private rename-)
+    (hidden rename-)
+    (register rename- (Fn [(Ptr CChar) (Ptr CChar)] Int) "rename")
+
+    (doc rename
+      "Renames a file or directory from `old-name` to `new-name`."
+      "Returns an integer indicating success (0) or failure (-1)."
+      "Wraps `rename` from the C standard library.")
+    (defn rename [old-name new-name]
+      (rename- (String.cstr old-name) (String.cstr new-name)))
+
+    (doc rename!
+      "Renames a file via [`rename`](#rename), but discards the result,"
+      "making this function appropriate for use as a side effect in"
+      "`do` forms.")
+    (defn rename! [old-name new-name]
+      (ignore (rename old-name new-name)))
+
     (doc fseek
       "Sets the position indicator of a [FILE](#file) based on a given"
       "reference position and offset. The position indicator will be set to an"
@@ -204,8 +222,30 @@
       "given [FILE](#file)."
       "Wraps `ferror` from the C standard library.")
     (register ferror (Fn [(Ptr FILE)] Bool) "ferror")
+
+    (doc list-dir
+      "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 file-exists? "Checks if a file exists at the given path.")
+  (register file-exists? (Fn [&String] Bool))
+
+  (doc dir-exists? "Checks if a directory exists at the given path.")
+  (register dir-exists? (Fn [&String] Bool))
+
+  (doc list-dir
+    "Returns an array containing the names of the entries in the directory"
+    "designated by `path`, skipping `.` and `..`."
+    ""
+    "Returns a (Result (Array String) String) indicating success or failure.")
+  (defn list-dir [path]
+    (let [res (IO.Raw.list-dir path)]
+      (if (Int.= (Array.length &res) -1)
+        (Result.Error (fmt "Failed to list directory '%s': %s" path &(System.error-text)))
+        (Result.Success res))))
+
   (doc println
     "Prints a String ref to [`stdout`](#stdout), appends a newline.")
   (register println (Fn [(Ref String)] ()))
@@ -329,6 +369,32 @@
             (Result.Success true)
             (Result.Error (fmt "only %d of %d bytes were written" bytes-written bytes2write)))))))
 
+  (doc move-file
+    "Moves or renames a file or directory from `old-name` to `new-name`."
+    ""
+    "Returns a (Result Bool String) indicating success or failure.")
+  (defn move-file [old-name new-name]
+    (if (Int.= (IO.Raw.rename old-name new-name) 0)
+      (Result.Success true)
+      (Result.Error (fmt "Failed to move '%s' to '%s': %s" old-name new-name &(System.error-text)))))
+
+  (doc remove-file
+    "Deletes a file from the filesystem."
+    ""
+    "Returns a (Result Bool String) indicating success or failure.")
+  (defn remove-file [filename]
+    (if (Int.= (IO.Raw.unlink filename) 0)
+      (Result.Success true)
+      (Result.Error (fmt "Failed to remove file '%s': %s" filename &(System.error-text)))))
+
+  (doc copy-file
+    "Copies a file from `src` to `dest`. Overwrites `dest` if it already exists."
+    ""
+    "Returns a (Result Bool String) indicating success or failure.")
+  (defn copy-file [src dest]
+    (Result.and-then (read-file src)
+                     &(fn [content] (write-file &content dest))))
+
   (private getenv-)
   (hidden getenv-)
   (doc getenv- "gets the value of an environment variable (thin wrapper for the C standard library)")

core/carp_io.h

@@ -1,3 +1,6 @@
+#include <sys/stat.h>
+#include <dirent.h>
+
 void IO_println(String* s) {
     puts(*s);
 }
@@ -53,3 +56,42 @@ String IO_unsafe_MINUS_read_MINUS_file(const String* filename) {
 
     return buffer;
 }
+
+bool IO_file_MINUS_exists_QMARK_(const String* path) {
+    struct stat st;
+    if (stat(*path, &st) == 0) {
+        return S_ISREG(st.st_mode);
+    }
+    return false;
+}
+
+bool IO_dir_MINUS_exists_QMARK_(const String* path) {
+    struct stat st;
+    if (stat(*path, &st) == 0) {
+        return S_ISDIR(st.st_mode);
+    }
+    return false;
+}
+
+Array IO_Raw_list_MINUS_dir(const String* path) {
+    DIR *d;
+    struct dirent *dir;
+    d = opendir(*path);
+    Array result = {0, 0, NULL};
+    if (d) {
+        while ((dir = readdir(d)) != NULL) {
+            if (strcmp(dir->d_name, ".") == 0 || strcmp(dir->d_name, "..") == 0) {
+                continue;
+            }
+            String name = CARP_MALLOC(strlen(dir->d_name) + 1);
+            strcpy(name, dir->d_name);
+            result.len++;
+            result.data = CARP_REALLOC(result.data, sizeof(String) * result.len);
+            ((String*)result.data)[result.len - 1] = name;
+        }
+        closedir(d);
+    } else {
+        result.len = -1;
+    }
+    return result;
+}

test/io_extensions.carp

@@ -0,0 +1,44 @@
+(load "Test.carp")
+(use Test)
+
+(deftest test-existence
+  (let-do [t1 (assert-true test-existence (IO.file-exists? "core/IO.carp") "file-exists? works for existing file")
+           t2 (assert-false (ref t1) (IO.file-exists? "nonexistent_file_xyz.txt") "file-exists? returns false for non-existent file")
+           t3 (assert-false (ref t2) (IO.file-exists? "core") "file-exists? returns false for directory")
+           t4 (assert-true (ref t3) (IO.dir-exists? "core") "dir-exists? works for existing directory")
+           t5 (assert-false (ref t4) (IO.dir-exists? "core/IO.carp") "dir-exists? returns false for file")
+           t6 (assert-false (ref t5) (IO.dir-exists? "nonexistent_dir_xyz") "dir-exists? returns false for non-existent directory")]
+    t6))
+
+(deftest test-move-remove
+  (let-do [old-file "test_move_old.txt"
+           new-file "test_move_new.txt"
+           _1 (IO.write-file "test move content" old-file)
+           move-res (IO.move-file old-file new-file)
+           t1 (assert-true test-move-remove (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")
+           remove-res (IO.remove-file new-file)
+           t4 (assert-true (ref t3) (Result.success? &remove-res) "remove-file success")
+           t5 (assert-false (ref t4) (IO.file-exists? new-file) "file gone after remove")]
+    t5))
+
+(deftest test-copy
+  (let-do [src-file "test_copy_src.txt"
+           dest-file "test_copy_dest.txt"
+           _1 (IO.write-file "test copy content" src-file)
+           copy-res (IO.copy-file src-file dest-file)
+           t1 (assert-true test-copy (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")
+           _2 (IO.remove-file src-file)
+           _3 (IO.remove-file dest-file)]
+    t3))
+
+(deftest test-list-dir
+  (let-do [dir-res (IO.list-dir "core")
+           t1 (assert-true test-list-dir (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)))