A modular task management framework
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
xerus2000 1bee6518e6 refactor: rename lyk to equilibrium-test-binary 6 days ago
hooks add pre-commit hook formatter file 5 months ago
nix use make in setup.sh for generating files; use pinned cabal2nix 3 months ago
pkgs refactor: rename lyk to equilibrium-test-binary 6 days ago
scripts chore: add script to generate a package diagram 1 week ago
.envrc Initial commit 5 months ago
.gitignore chore: remove and ignore generated hie.yaml files 3 months ago
Jenkinsfile clean before generating in Jenkins build 3 months ago
LICENSE Initial commit 5 months ago
Makefile add cachix make targets and documentation 3 months ago
README.md docs: move collaboration instructions to taskell_board branch 1 week ago
brittany.yaml Format with brittany 5 months ago
config.nix refactor: rename lyk to equilibrium-test-binary 6 days ago
default.nix respect gitignore in more nix expressions, making builds more reproducible 3 months ago
setup.sh remove leftover exit call 3 months ago
shell.nix fix nix-shell 3 months ago
todos.txt refactor: rename our implementation to lyk 1 week ago

README.md

equilibrium

Equilibrium is a modular task management framework based on the Entity-Component-System pattern.

Build Requirements

Integrated nix-shell (Optional)

If you do not set up lorri and direnv, you will have to enter a nix-shell via nix-shell

  • Install direnv and lorri via nix: nix-env -iA nixpkgs.lorri nixpkgs.direnv
  • Hook direnv into your shell
  • Make sure the lorri daemon is running
  • cd into the project directory
    • If you see a message from direnv asking to allow the .envrc, run direnv allow
    • Run ./setup.sh (if you haven't already)

Then you should be able to use tools such as ghci that are provided by the nix-shell directly in your shell. If this doesn't work, or if you get the lorri hasn't finished an evaluation of this project yet message, run lorri shell to force an evaluation.

Development setup

# Clone the repository
git clone https://codeberg.org/code-done/done.git

# Go into the new project directory
cd done

# Run the setup script, which
# - generates all necessary files
# - optionally sets up git hooks for development
# - asks to enter a nix-shell to start developing
./setup.sh

cachix cache

For faster build times (both locally and in CI), set up our cachix cache.

First, install cachix on your machine (it is not provided in the nix-shell):

nix-env -iA cachix -f https://cachix.org/api/v1/install

Then, enable the project's cache, so you can substitute to-be-built binaries with the ones from the cache:

cachix use code-done

Pushing to cachix

As a team member you can get write access to the shared cache to reduce build times for others and the CI. Follow the two steps above and execute the command found in our cloud in secrets/cachix.md.

Then use make all-push or make build-push instead of their non--push counterparts to update the caches after building.

Make targets

While the make targets don't assume you are in a nix-shell, make itself is provided through it, so you should be inside a nix-shell for these.

Using the Haskell Language Server

Run make hls-setup once and whenever new files are created.

To start the Haskell Language Server you can use make hls which calls haskell-language-server-wrapper.

all ($ make all)

Regenerates all generated files and tests and builds the project. The resulting binary can be found in ./result/bin/.

build ($ make build)

Tests and builds the project.

test ($ make test)

Builds the project and test packages, compiles the tests and runs them. Also regenerates generated files if necessary.

shell ($ make shell)

Enters a nix-shell, which forces a shell rebuild.

clean ($ make clean)

Deletes all generated files, including dist-newstyle folders in the packages, which are generated by haskell-language-server.

pkg ($ make pkg)

An interactive code-generator to create new packages (or test packages).

generate ($ make generate)

Generates all generated files. Will skip some if the project isn't clean ($ make clean).

test.nix ($ make test.nix)

Generates the test.nix file, if it doesn't already exist.

default.nix ($ make default.nix)

Generates a default.nix file for each package in ./pkgs/.

How to add new packages to the nix-shell

Edit the config.nix file and add

pkgs.PACKAGE_NAME to the shellProvidedPackages section.

For example: If the package is

nixpkgs.gitAndTools.git-bug

the added line should be

pkgs.gitAndTools.git-bug

pkgs refers to the pinned version of nixpkgs used in the project. You can add any other nix-package from other sources here as well. However, make sure the version is properly pinned to avoid breaking the project in the future or on other machines. We use niv to manage dependencies, including the pinned nixpkgs version.

How to update dependencies

Dependencies are pinned by including everything through a pinned version of nixpkgs, managed with niv. To update the pinned version, use niv: $ niv update.

Contributing

Collaboration

Please check out the taskell_board branch and refer to its README for information on how to track issues and tasks.

Git guidelines

We roughly follow the Kull Convention. Since we do everything on the command line there are no formal pull requests, instead reviews are requested in Taskell. You can look at this post for inspiration for a suitable setup.

In general, once a feature is in the review column of Taskell and somebody is assigned, the maintainer of that branch has to first rebase the branch on main so that everything is up to date. Then the reviewer can review the code and if everything looks good do a fast forward merge onto main.

Architecture Overview

The taskmanager is split into four categories of modules:

  1. core
  2. executable (main)
  3. storage modules
  4. logic modules

core

The core library defines the pipelines data can flow through and allows for easy combination of storage and logic modules.

executable

The executable is the user-built main entrypoint for the program. It currently also handles user interfaces. In here, you should combine all the storage and logic modules you want to use and pass them to the core library.

Right now, a special exe-types (executable types) package is needed, its responsibilities will be divided into the core library and the executable package in the future.

storage modules

Storage modules serialize and deserialize the task data into their respective storage format.

logic modules

Logic modules implement features for tasks, from simple todo-states (todo/done) to scheduling.

Creating a new package

Use the $ make pkg tool, an interactive code-generator to create new packages in this project.