Files and Folders

Navigating trough files and folders is quite simple, and makes use of only two utilities FileWalker and File.

ls (list files) utility function

The File type has an ls() method to simplify file navigation.

• the first argument is the directory path
• the second argument is the file extension to filter by or null,
• the third wether or not to make it recursive

The Following directory

data/
├── raw/
│   ├── data1.csv
│   ├── other.bin
├── processed/
│   ├── cleaned_data.csv
│   ├── rest.xml

fn run(){
  var files = File::ls("data","csv", true);
  pprint(files);
}

Output:

Array<File> {
  File {
    path: "./data/raw/data1.csv",
    size: 0,
    last_modification: '2025-01-14T10:33:01.236197+00:00'
  },
  File {
    path: "./data/processed/cleaned_data.csv",
    size: 0,
    last_modification: '2025-01-14T10:33:34.441148+00:00'
  }
}

Manual iteration

To navigate a folder, you want to use a FileWalker. You initialize the walker with the path of your folder. A loop will then allow you to go through all the content of the folder.

fn run() {
  var walker = FileWalker{ path:"./dataFolder" };
  while(!walker.isEmpty()) {
    var file = walker.next();
    //Do something with the file.
  }
}

To recurse into the directories, you have various options:

1. The recursive calls: this will work as long as you don’t have a great depth of nesting. The order of processing the file (prefix, infix or postfix) will depend on how you implement the recursion.

fn processFileOrDirectory(path: String) {
  var walker = FileWalker { path:path };
  while(!walker.isEmpty()) {
    var file = walker.next();
    if(file != null && file.isDir()) {
      //Recurse
      processFileOrDirectory(file.path);
    } else {
      //Do something with the file.
    }
  }
}

fn run() {
  processFileOrDirectory("./dataFolder");
}

2. Iterative, depth-first or breadth-first: this approach will work the same way as the recursion, but it is guaranteed to scale whatever your nesting depth (no stack-overflow). Here below a breadth-first example.

fn run() {
  var dirToProcess = Queue<String> {};
  dirToProcess.enqueue("./dataFolder");

  while(dirToProcess.size() != 0) {
    var fileWalker = FileWalker { path:dirToProcess.dequeue() as String };
    while(!fileWalker.isEmpty()) {
      var file = fileWalker.next();
      if(file != null) {
        println("Processing ${file.path}");
        if(file.isDir()) {
          dirToProcess.enqueue(file.path);
        } else {
          //Do something with the file.
        }
      }
    }
  }
}

Files & Directories

The type File provides mostly static utility methods to help the handling of files and directories.

Create Directory

Just call the following with the full path:

File::mkdir("./path/to/my/directory"): bool;

Copy file or directory

You can copy files by specifying the source first, then the path of the destination.

File::copy("./origin.txt", "./copy.txt"): bool;

Delete file of directory

Files or directories can be deleted from their path

File::delete("./file/to/delete.txt"): bool;

Rename file or directory

Directories and files can also be renamed

File::rename("./oldName", "./newName"): bool;

Path utilities

Depending on your context of execution, it might not be easy to figure the base path for writing or reading files.

The File type provides three utility static functions providing some base paths.

/// returns the relative path, from the executable working dir, to the `files` folder in GreyCat
static native fn baseDir(): String;

/// returns the relative path, from the executable working dir, to the directory in GreyCat for the current user
static native fn userDir(): String;

/// returns the relative path, from the executable working dir, to the directory in GreyCat for the task currently executing
static native fn taskDir(): String;