test untested path funs (#373)

* test untested path funs

* cleanup + expect test

* better error messages

* print cwd, fix print order

* check ripgrep installed

* install ripgrep

* fix binary name

* more robust regex

Author: Anton-4

.github/workflows/ci.yml

@@ -45,9 +45,10 @@ jobs:
 
       - run: |
           sudo apt update
-          sudo apt install -y expect ncat valgrind
+          sudo apt install -y expect ncat valgrind ripgrep
       # expect for testing
       # ncat for tcp-client example
+      # ripgrep for ci/check_all_exposed_funs_tested.roc
 
       - run: expect -v
 

ci/all_tests.sh

@@ -38,6 +38,8 @@ for roc_file in $TESTS_DIR*.roc; do
     $ROC check $roc_file
 done
 
+$ROC ci/check_all_exposed_funs_tested.roc
+
 # roc build
 architecture=$(uname -m)
 
@@ -60,6 +62,15 @@ cd ci/rust_http_server
 cargo build --release
 cd ../..
 
+# Check for duplicate .roc file names between EXAMPLES_DIR and TESTS_DIR (this messes with checks)
+for example_file in $EXAMPLES_DIR*.roc; do
+    example_basename=$(basename "$example_file")
+    if [ -f "$TESTS_DIR$example_basename" ]; then
+        echo "ERROR: Duplicate file name found: $example_basename exists in both $EXAMPLES_DIR and $TESTS_DIR. Change the name of one of them." >&2
+        exit 1
+    fi
+done
+
 # check output with linux expect
 for roc_file in $EXAMPLES_DIR*.roc; do
     base_file=$(basename "$roc_file")

ci/check_all_exposed_funs_tested.roc

@@ -1,9 +1,12 @@
-app [main!] { pf: platform "https://github.com/roc-lang/basic-cli/releases/download/0.19.0/Hj-J_zxz7V9YurCSTFcFdu6cQJie4guzsPMUi5kBYUk.tar.br" }
+app [main!] { pf: platform "../platform/main.roc" }
 
 import pf.Stdout
 import pf.Arg exposing [Arg]
 import pf.File
 import pf.Cmd
+import pf.Env
+import pf.Path
+import pf.Sleep
 
 # This script performs the following tasks:
 # 1. Reads the file platform/main.roc and extracts the exposes list.
@@ -16,6 +19,9 @@ err_s = |err_msg| Err(StrErr(err_msg))
 
 main! : List Arg => Result {} _
 main! = |_args|
+    cwd = Env.cwd!({}) ? |err| FailedToGetCwd(err)
+    Stdout.line!("Current working directory: ${Path.display(cwd)}")?
+
     path_to_platform_main = "platform/main.roc"
 
     main_content =
@@ -67,34 +73,74 @@ main! = |_args|
             |function_name|
                 Stdout.line!(function_name),
         )?
+
+        # Sleep to fix print order
+        Sleep.millis!(1000)
         Err(Exit(1, "I found untested functions, see above."))
 
 is_function_unused! : Str, Str => Result Bool _
 is_function_unused! = |module_name, function_name|
     function_pattern = "${module_name}.${function_name}"
     search_dirs = ["examples", "tests"]
 
-    unused_in_dir =
-        search_dirs
-        |> List.map_try!( |search_dir|
-            # Use ripgrep to search for the function pattern
-            cmd =
-                Cmd.new("rg")
-                |> Cmd.arg("-q") # Quiet mode - we only care about exit code
-                |> Cmd.arg(function_pattern)
-                |> Cmd.arg(search_dir)
-
-            status_res = Cmd.status!(cmd)
-
-            # ripgrep returns status 0 if matches were found, 1 if no matches
-            when status_res is
-                Ok(0) -> Ok(Bool.false) # Function is used (not unused)
-                _ -> Ok(Bool.true)
-        )?
+    # Check current working directory
+    cwd = Env.cwd!({}) ? |err| FailedToGetCwd2(err)
+
+    # Check if directories exist
+    List.for_each_try!(
+        search_dirs,
+        |search_dir|
+            is_dir_res = File.is_dir!(search_dir)
+
+            when is_dir_res is
+                Ok is_dir ->
+                    if !is_dir then
+                        err_s("Error: Path '${search_dir}' inside ${Path.display(cwd)} is not a directory.")
+                    else
+                        Ok({})
+
+                Err (PathErr NotFound) ->
+                    err_s("Error: Directory '${search_dir}' does not exist in ${Path.display(cwd)}")
+                Err err ->
+                    err_s("Error checking directory '${search_dir}': ${Inspect.to_str(err)}")
+    )?
+
+    # Check if ripgrep is installed
+    rg_check_cmd = Cmd.new("rg") |> Cmd.arg("--version")
+    rg_check_output = Cmd.output!(rg_check_cmd)
+
+    when rg_check_output.status is
+        Ok(0) ->
+                unused_in_dir =
+                    search_dirs
+                    |> List.map_try!( |search_dir|
+                        # Skip searching if directory doesn't exist
+                        dir_exists = File.is_dir!(search_dir)?
+                        if !dir_exists then
+                            Ok(Bool.true) # Consider unused if we can't search
+                        else
+                            # Use ripgrep to search for the function pattern
+                            cmd =
+                                Cmd.new("rg")
+                                |> Cmd.arg("-q") # Quiet mode - we only care about exit code
+                                |> Cmd.arg(function_pattern)
+                                |> Cmd.arg(search_dir)
+
+                            status_res = Cmd.status!(cmd)
+
+                            # ripgrep returns status 0 if matches were found, 1 if no matches
+                            when status_res is
+                                Ok(0) -> Ok(Bool.false) # Function is used (not unused)
+                                _ -> Ok(Bool.true)
+                    )?
+
+                unused_in_dir
+                |> List.walk!(Bool.true, |state, is_unused_res| state && is_unused_res)
+                |> Ok
+        _ ->
+            err_s("Error: ripgrep (rg) is not installed or not available in PATH. Please install ripgrep to use this script. Full output: ${Inspect.to_str(rg_check_output)}")
+
 
-    unused_in_dir
-    |> List.walk!(Bool.true, |state, is_unused_res| state && is_unused_res)
-    |> Ok
 
 process_module! : Str => Result { module_name : Str, exposed_functions : List Str } _
 process_module! = |module_name|

ci/expect_scripts/file.exp

@@ -58,7 +58,7 @@ expect "Testing some File functions..." {
                                                                                                                 expect "✓ Deleted all files." {
 
                                                                                                                     # Final completion message
-                                                                                                                    expect "✓ All File function tests completed! ✓" {
+                                                                                                                    expect "I ran all file function tests." {
                                                                                                                         expect eof {
                                                                                                                             check_exit_and_segfault
                                                                                                                         }