file time functions (#350)

* file time functions

* musl changes

Author: Anton-4

ci/all_tests.sh

@@ -60,6 +60,11 @@ for roc_file in $EXAMPLES_DIR*.roc; do
         continue
     fi
 
+    ## Skip file-accessed-modified-created-time.roc when IS_MUSL=1
+    if [ "$IS_MUSL" == "1" ] && [ "$base_file" == "file-accessed-modified-created-time.roc" ]; then
+        continue
+    fi
+
     roc_file_only="$(basename "$roc_file")"
     no_ext_name=${roc_file_only%.*}
 
@@ -100,6 +105,8 @@ for roc_file in $EXAMPLES_DIR*.roc; do
         DB_PATH=${EXAMPLES_DIR}todos.db $ROC dev $roc_file $ROC_BUILD_FLAGS
     elif [ "$base_file" == "temp-dir.roc" ]; then
         $ROC dev $roc_file $ROC_BUILD_FLAGS --linker=legacy
+    elif [ "$base_file" == "file-accessed-modified-created-time.roc" ] && [ "$IS_MUSL" == "1" ]; then
+        continue
     else
 
         $ROC dev $roc_file $ROC_BUILD_FLAGS

ci/expect_scripts/file-accessed-modified-created-time.exp

@@ -0,0 +1,25 @@
+#!/usr/bin/expect
+
+# uncomment line below for debugging
+# exp_internal 1
+
+set timeout 7
+
+source ./ci/expect_scripts/shared-code.exp
+
+spawn $env(EXAMPLES_DIR)file-accessed-modified-created-time
+
+expect {
+    -re {LICENSE file time metadata:\r\n    Modified: "20.*"\r\n    Accessed: "20.*"\r\n    Created: "20.*"\r\n} {
+        expect eof {
+            check_exit_and_segfault
+        }
+    }
+    timeout {
+        puts stderr "\nError: timed out waiting for expected output."
+        exit 1
+    }
+}
+
+puts stderr "\nError: output was different from expected value."
+exit 1

crates/roc_file/src/lib.rs

@@ -265,6 +265,84 @@ pub fn file_is_writable(roc_path: &RocList<u8>) -> RocResult<bool, IOErr> {
     }
 }
 
+pub fn file_time_accessed(roc_path: &RocList<u8>) -> RocResult<roc_std::U128, IOErr> {
+    let rust_path = path_from_roc_path(roc_path);
+    let metadata_res = std::fs::metadata(rust_path);
+
+    match metadata_res {
+        Ok(metadata) => {
+            let accessed = metadata.accessed();
+            match accessed {
+                Ok(time) => {
+                    RocResult::ok(
+                        roc_std::U128::from(
+                            time.duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+                        )
+                    )
+                }
+                Err(err) => {
+                    RocResult::err(err.into())
+                }
+            }
+        }
+        Err(err) => {
+            RocResult::err(err.into())
+        }
+    }
+}
+
+pub fn file_time_modified(roc_path: &RocList<u8>) -> RocResult<roc_std::U128, IOErr> {
+    let rust_path = path_from_roc_path(roc_path);
+    let metadata_res = std::fs::metadata(rust_path);
+
+    match metadata_res {
+        Ok(metadata) => {
+            let modified = metadata.modified();
+            match modified {
+                Ok(time) => {
+                    RocResult::ok(
+                        roc_std::U128::from(
+                            time.duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+                        )
+                    )
+                }
+                Err(err) => {
+                    RocResult::err(err.into())
+                }
+            }
+        }
+        Err(err) => {
+            RocResult::err(err.into())
+        }
+    }
+}
+
+pub fn file_time_created(roc_path: &RocList<u8>) -> RocResult<roc_std::U128, IOErr> {
+    let rust_path = path_from_roc_path(roc_path);
+    let metadata_res = std::fs::metadata(rust_path);
+
+    match metadata_res {
+        Ok(metadata) => {
+            let created = metadata.created();
+            match created {
+                Ok(time) => {
+                    RocResult::ok(
+                        roc_std::U128::from(
+                            time.duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
+                        )
+                    )
+                }
+                Err(err) => {
+                    RocResult::err(err.into())
+                }
+            }
+        }
+        Err(err) => {
+            RocResult::err(err.into())
+        }
+    }
+}
+
 pub fn dir_list(roc_path: &RocList<u8>) -> RocResult<RocList<RocList<u8>>, IOErr> {
     let path = path_from_roc_path(roc_path);
 

crates/roc_host/src/lib.rs

@@ -318,6 +318,9 @@ pub fn init() {
         roc_fx_file_is_executable as _,
         roc_fx_file_is_readable as _,
         roc_fx_file_is_writable as _,
+        roc_fx_file_time_accessed as _,
+        roc_fx_file_time_modified as _,
+        roc_fx_file_time_created as _,
         roc_fx_cwd as _,
         roc_fx_posix_time as _,
         roc_fx_sleep_millis as _,
@@ -540,6 +543,27 @@ pub extern "C" fn roc_fx_file_is_writable(
     roc_file::file_is_writable(roc_path)
 }
 
+#[no_mangle]
+pub extern "C" fn roc_fx_file_time_accessed(
+    roc_path: &RocList<u8>,
+) -> RocResult<roc_std::U128, roc_io_error::IOErr> {
+    roc_file::file_time_accessed(roc_path)
+}
+
+#[no_mangle]
+pub extern "C" fn roc_fx_file_time_modified(
+    roc_path: &RocList<u8>,
+) -> RocResult<roc_std::U128, roc_io_error::IOErr> {
+    roc_file::file_time_modified(roc_path)
+}
+
+#[no_mangle]
+pub extern "C" fn roc_fx_file_time_created(
+    roc_path: &RocList<u8>,
+) -> RocResult<roc_std::U128, roc_io_error::IOErr> {
+    roc_file::file_time_created(roc_path)
+}
+
 
 #[no_mangle]
 pub extern "C" fn roc_fx_cwd() -> RocResult<RocList<u8>, ()> {

examples/.gitignore

@@ -12,6 +12,7 @@ file-read-buffered
 file-read-memory-map
 file-size
 file-permissions
+file-accessed-modified-created-time
 form
 hello-world
 http-get

examples/file-accessed-modified-created-time.roc

@@ -0,0 +1,29 @@
+app [main!] { pf: platform "../platform/main.roc" }
+
+# To run this example: check the README.md in this folder
+
+import pf.Stdout
+import pf.File
+import pf.Utc
+
+main! = |_args|
+    file = "LICENSE"
+
+    # NOTE: these functions will not work if basic-cli was built with musl, which is the case for the normal tar.br URL release.
+    # See https://github.com/roc-lang/basic-cli?tab=readme-ov-file#running-locally to build basic-cli without musl.
+
+    time_modified = Utc.to_iso_8601(File.time_modified!(file)?)
+
+    time_accessed = Utc.to_iso_8601(File.time_accessed!(file)?)
+
+    time_created = Utc.to_iso_8601(File.time_created!(file)?)
+
+
+    Stdout.line!(
+        """
+        ${file} file time metadata:
+            Modified: ${Inspect.to_str(time_modified)}
+            Accessed: ${Inspect.to_str(time_accessed)}
+            Created: ${Inspect.to_str(time_created)}
+        """
+    )

platform/File.roc

@@ -13,6 +13,9 @@ module [
     is_executable!,
     is_readable!,
     is_writable!,
+    time_accessed!,
+    time_modified!,
+    time_created!,
     type!,
     open_reader!,
     open_reader_with_capacity!,
@@ -25,6 +28,7 @@ import Path exposing [Path]
 import InternalIOErr
 import Host
 import InternalPath
+import Utc exposing [Utc]
 
 ## Tag union of possible errors when reading and writing a file or directory.
 ##
@@ -213,28 +217,65 @@ is_sym_link! = |path_str|
 
 ## Checks if the file has the execute permission for the current process.
 ##
-## This uses rust [std::fs::Metadata](https://doc.rust-lang.org/std/fs/struct.Metadata.html)
+## This uses rust [std::fs::Metadata](https://doc.rust-lang.org/std/fs/struct.Metadata.html).
 is_executable! : Str => Result Bool [PathErr IOErr]
 is_executable! = |path_str|
     Host.file_is_executable!(InternalPath.to_bytes(Path.from_str(path_str)))
     |> Result.map_err(|err| PathErr(InternalIOErr.handle_err(err)))
 
 ## Checks if the file has the readable permission for the current process.
 ##
-## This uses rust [std::fs::Metadata](https://doc.rust-lang.org/std/fs/struct.Metadata.html)
+## This uses rust [std::fs::Metadata](https://doc.rust-lang.org/std/fs/struct.Metadata.html).
 is_readable! : Str => Result Bool [PathErr IOErr]
 is_readable! = |path_str|
     Host.file_is_readable!(InternalPath.to_bytes(Path.from_str(path_str)))
     |> Result.map_err(|err| PathErr(InternalIOErr.handle_err(err)))
 
 ## Checks if the file has the writeable permission for the current process.
 ##
-## This uses rust [std::fs::Metadata](https://doc.rust-lang.org/std/fs/struct.Metadata.html)
+## This uses rust [std::fs::Metadata](https://doc.rust-lang.org/std/fs/struct.Metadata.html).
 is_writable! : Str => Result Bool [PathErr IOErr]
 is_writable! = |path_str|
     Host.file_is_writable!(InternalPath.to_bytes(Path.from_str(path_str)))
     |> Result.map_err(|err| PathErr(InternalIOErr.handle_err(err)))
 
+## Returns the time when the file was last accessed.
+##
+## This uses [rust's std::fs::Metadata::accessed](https://doc.rust-lang.org/std/fs/struct.Metadata.html#method.accessed).
+## Note that this is [not guaranteed to be correct in all cases](https://doc.rust-lang.org/std/fs/struct.Metadata.html#method.accessed).
+##
+## NOTE: these functions will not work if basic-cli was built with musl, which is the case for the normal tar.br URL release.
+## See https://github.com/roc-lang/basic-cli?tab=readme-ov-file#running-locally to build basic-cli without musl.
+time_accessed! : Str => Result Utc [PathErr IOErr]
+time_accessed! = |path_str|
+    Host.file_time_accessed!(InternalPath.to_bytes(Path.from_str(path_str)))
+    |> Result.map_ok(|time_u128| Num.to_i128(time_u128) |> Utc.from_nanos_since_epoch)
+    |> Result.map_err(|err| PathErr(InternalIOErr.handle_err(err)))
+
+## Returns the time when the file was last modified.
+##
+## This uses [rust's std::fs::Metadata::modified](https://doc.rust-lang.org/std/fs/struct.Metadata.html#method.modified).
+##
+## NOTE: these functions will not work if basic-cli was built with musl, which is the case for the normal tar.br URL release.
+## See https://github.com/roc-lang/basic-cli?tab=readme-ov-file#running-locally to build basic-cli without musl.
+time_modified! : Str => Result Utc [PathErr IOErr]
+time_modified! = |path_str|
+    Host.file_time_modified!(InternalPath.to_bytes(Path.from_str(path_str)))
+    |> Result.map_ok(|time_u128| Num.to_i128(time_u128) |> Utc.from_nanos_since_epoch)
+    |> Result.map_err(|err| PathErr(InternalIOErr.handle_err(err)))
+
+## Returns the time when the file was created.
+##
+## This uses [rust's std::fs::Metadata::created](https://doc.rust-lang.org/std/fs/struct.Metadata.html#method.created).
+##
+## NOTE: these functions will not work if basic-cli was built with musl, which is the case for the normal tar.br URL release.
+## See https://github.com/roc-lang/basic-cli?tab=readme-ov-file#running-locally to build basic-cli without musl.
+time_created! : Str => Result Utc [PathErr IOErr]
+time_created! = |path_str|
+    Host.file_time_created!(InternalPath.to_bytes(Path.from_str(path_str)))
+    |> Result.map_ok(|time_u128| Num.to_i128(time_u128) |> Utc.from_nanos_since_epoch)
+    |> Result.map_err(|err| PathErr(InternalIOErr.handle_err(err)))
+
 ## Return the type of the path if the path exists on disk.
 ## This uses [rust's std::path::is_symlink](https://doc.rust-lang.org/std/path/struct.Path.html#method.is_symlink).
 ##

platform/Host.roc

@@ -23,6 +23,9 @@ hosted [
     file_is_executable!,
     file_is_readable!,
     file_is_writable!,
+    file_time_accessed!,
+    file_time_modified!,
+    file_time_created!,
     get_locale!,
     get_locales!,
     hard_link!,
@@ -61,7 +64,6 @@ import InternalCmd
 import InternalPath
 import InternalIOErr
 import InternalSqlite
-
 # COMMAND
 command_status! : InternalCmd.Command => Result I32 InternalIOErr.IOErrFromHost
 command_output! : InternalCmd.Command => InternalCmd.OutputFromHost
@@ -75,6 +77,9 @@ file_size_in_bytes! : List U8 => Result U64 InternalIOErr.IOErrFromHost
 file_is_executable! : List U8 => Result Bool InternalIOErr.IOErrFromHost
 file_is_readable! : List U8 => Result Bool InternalIOErr.IOErrFromHost
 file_is_writable! : List U8 => Result Bool InternalIOErr.IOErrFromHost
+file_time_accessed! : List U8 => Result U128 InternalIOErr.IOErrFromHost
+file_time_modified! : List U8 => Result U128 InternalIOErr.IOErrFromHost
+file_time_created! : List U8 => Result U128 InternalIOErr.IOErrFromHost
 
 FileReader := Box {}
 file_reader! : List U8, U64 => Result FileReader InternalIOErr.IOErrFromHost