https://github.com/stovoy/buildy

Rust based ultra-fast parallel build system for local iteration
https://github.com/stovoy/buildy

Last synced: 5 days ago
JSON representation

Rust based ultra-fast parallel build system for local iteration

• Host: GitHub
• URL: https://github.com/stovoy/buildy
• Owner: Stovoy
• License: mit
• Created: 2019-10-16T02:46:27.000Z (over 5 years ago)
• Default Branch: master
• Last Pushed: 2023-06-21T22:41:30.000Z (over 1 year ago)
• Last Synced: 2025-01-09T06:59:23.107Z (27 days ago)
• Language: Rust
• Size: 69.3 KB
• Stars: 1
• Watchers: 2
• Forks: 2
• Open Issues: 5
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# buildy - An ultra-fast parallel build system for local iteration

**Warning: `buildy` is not yet ready for use**

`buildy` is very simple and configurable. It's meant to facilitate development by watching the file system and rebuilding as necessary.

The core of `buildy` is in it's configuration file. Simply add a file named `.buildy.yml` into the root of the project.

This configuration file tells `buildy` exactly what to do.

## .buildy.yml spec

```

server_deps:

  watch:

    - server/package.json

    - server/yarn.lock

  build:

    - cd server && yarn install

server:

  depends_on:

    - server_deps

  watch:

    - server/src

  run:

    - cd server && node src/server.js

```

The configuration file is composed of `target`s, which are an entity to build. Each `target` can define its dependencies, files to `watch`, commands to `build`, and commands to `run` after the build completes.

`target`s will be run in parallel as much as possible, waiting to start until their dependencies are built.

The commands in the `build` list under a target are run one after another in a shell working from the directory containing the `.buildy.yml`.

The `target` will only be rebuilt if either no `watch` paths exist, or any of the contents of the `watch` paths have changed since the last build.

`buildy` maintains a list of checksums in a directory named `.buildy` next to the `.buildy.yml`. This directory should be ignored in version control.

Once a `target` is built, it will be run. The commands in `run` will be executed one after another. They can continue running in the background, which is useful for running programs such as a web server.

Even after everything is built, `buildy` will watch all the paths in the `watch` directories for new changes in the background. When any change is detected, those `target`s are rebuilt. Children `target`s (those that have a dependency on the rebuilt `target`) will only be rerun if their `watch` files changed as well.

Whenever a `target` is rebuilt, its `run` commands are rerun as well, terminating any that may still be running.

## Usage

Install with `cargo install buildy`.

Then, simply run `buildy` in a directory with `.buildy.yml`.

## Known Issues

* `run` commands that should be restarted when `watch` paths change need to use `exec` or else they won't terminate properly.

* No unit tests

* If a build fails, the checksum should not be saved - so that it gets rerun.