#file #directory #filesystem #tree #yaml

bin+lib build-fs-tree

Generate a filesystem tree from a macro or a YAML tree

6 releases

0.3.0 Jun 1, 2021
0.2.6 May 17, 2021
0.2.4 Apr 17, 2021
0.1.3 Apr 11, 2021
0.0.0 Apr 11, 2021

#104 in Development tools

Download history 230/week @ 2021-04-11 46/week @ 2021-04-18 68/week @ 2021-04-25 174/week @ 2021-05-02 289/week @ 2021-05-09 450/week @ 2021-05-16 438/week @ 2021-05-23 323/week @ 2021-05-30 76/week @ 2021-06-06 61/week @ 2021-06-13 74/week @ 2021-06-20 8/week @ 2021-06-27 49/week @ 2021-07-04 19/week @ 2021-07-11 196/week @ 2021-07-18 139/week @ 2021-07-25

599 downloads per month
Used in parallel-disk-usage

MIT license

32KB
434 lines

build-fs-tree

Test Crates.io Version

Generate a filesystem tree from a macro or a YAML tree.

Description

When I write integration tests, I often find myself needing to create temporary files and directories. Therefore, I created this crate which provides both a library to use in a Rust code and a CLI program that generates a filesystem tree according to a YAML structure.

Usage Examples

The Library

Go to docs.rs for the full API reference.

FileSystemTree

FileSystemTree::build is faster than MergeableFileSystemTree::build but it does not write over an existing directory and it does not create parent directories when they don't exist.

use build_fs_tree::{FileSystemTree, Build, dir, file};
let tree: FileSystemTree<&str, &str> = dir! {
    "index.html" => file!(r#"
        <!DOCTYPE html>
        <link rel="stylesheet" href="styles/style.css" />
        <script src="scripts/main.js"></script>
    "#)
    "scripts" => dir! {
        "main.js" => file!(r#"document.write('Hello World')"#)
    }
    "styles" => dir! {
        "style.css" => file!(r#":root { color: red; }"#)
    }
};
tree.build(&"public".into()).unwrap();

MergeableFileSystemTree

Unlike FileSystemTree::build, MergeableFileSystemTree::build can write over an existing directory and create parent directories that were not exist before at the cost of performance.

You can convert a FileSystemTree into a MergeableFileSystemTree via From::from/Into::into and vice versa.

use build_fs_tree::{MergeableFileSystemTree, Build, dir, file};
let tree = MergeableFileSystemTree::<&str, &str>::from(dir! {
    "public" => dir! {
        "index.html" => file!(r#"
            <!DOCTYPE html>
            <link rel="stylesheet" href="styles/style.css" />
            <script src="scripts/main.js"></script>
        "#)
        "scripts/main.js" => file!(r#"document.write('Hello World')"#)
        "scripts/style.css" => file!(r#":root { color: red; }"#)
    }
});
tree.build(&".".into()).unwrap();

Serialization and Deserialization

Both FileSystemTree and MergeableFileSystemTree implement serde::Deserialize and serde::Serialize.

The Program

The name of the command is build-fs-tree. It has 2 subcommands: create and populate.

create

This command reads YAML from stdin and creates a new filesystem tree. It is the CLI equivalent of FileSystemTree.

Create two text files in a new directory:

echo '{ foo.txt: HELLO, bar.txt: WORLD }' | build-fs-tree create foo-and-bar

Create a text file and its parent directories:

echo '{ text-files: { foo.txt: HELLO } }' | build-fs-tree create files

Create a new filesystem tree from a YAML file:

build-fs-tree create root < fs-tree.yaml

populate

This command reads YAML from stdin and either creates a new filesystem tree or add files and directories to an already existing directories. It is the CLI equivalent of MergeableFileSystemTree.

Create two text files in the current directory:

echo '{ foo.txt: HELLO, bar.txt: WORLD }' | build-fs-tree populate .

Create a text file and its parent directories:

echo '{ files/text-files/foo.txt: HELLO }' | build-fs-tree populate .

Populate the current directory with filesystem tree as described in a YAML file:

build-fs-tree populate . < fs-tree.yaml

Packaging Status

Packaging Status

Frequently Asked Questions

Why YAML?

It has the features I desired: Easy to read and write, multiline strings done right.

What about this cool configuration format?

According to the UNIX philosophy, you may pipe your cool configuration format to a program that converts it to JSON (YAML is a superset of JSON) and then pipe the JSON output to build-fs-tree.

License

MIT © Hoàng Văn Khải.

Dependencies

~1.2–2MB
~46K SLoC