*goredo* redo implementation on pure Go

OVERVIEW                                               *goredo-overview*

This is pure Go implementation of DJB's redo (http://cr.yp.to/redo.html)
build system proposal. Originally it was just a rewrite of redo-c
(https://github.com/leahneukirchen/redo-c), but later most features of
apenwarr/redo (https://redo.readthedocs.io/en/latest/) were also
implemented. Why yet another implementation? It is feature full and has
better performance comparing to shell and Python implementation.
goredo is free software: see the file COPYING for copying conditions.

INSTALL                                                 *goredo-install*

Either: >
    $ go get go.cypherpunks.ru/goredo
    $ goredo -symlinks
    $ export PATH=`pwd`:$PATH
or: >
    $ git clone git://git.cypherpunks.ru/goredo.git
    $ cd goredo
    $ go build
    $ ./goredo -symlinks
    $ export PATH=`pwd`:$PATH
<
NOTES                                                     *goredo-notes*

* "all" target is used by default
* stdout is always captured, but no target is created if it was empty
* empty targets are considered always out of date
* .do's arguments are relative paths
* .do search goes up to / by default, but can be limited with either
  REDO_TOP_DIR environment variable, or by having .redo/top file in it
* executable .do is run as is
* shebangless .do is run with /bin/sh -e[x]
* target's completion messages are written after they finish

FEATURES                                               *goredo-features*

* explicit check that stdout and $3 are not written simultaneously
* explicit check (similar to apenwarr/redo's one) that generated target
  was not modified "externally" outside the redo, preventing its
  overwriting, but continuing the build
* targets, dependency information and their directories are explicitly
  synced (can be disabled, should work faster)
* file's change is detected by comparing its ctime and, if it differs,
  its BLAKE2b hash. Hash checking is done to prevent false positives
  (can be disabled, will work faster)
* files creation is umask-friendly (unlike mkstemp() used in redo-c)
* coloured messages (can be disabled)
* verbose debug messages, including out-of-date determination, PIDs,
  lock acquirings/releases
* parallel build with jobs limit, optionally in infinite mode
* optional display of each target's execution time
* each target's stderr can be displayed with the PID
* target's stderr can be stored on the disk with TAI64N timestamp
  prefixes for each line (you can use tai64nlocal utility from
  daemontools (http://cr.yp.to/daemontools/tai64nlocal.html) to convert
  them to local time). Captures can be viewed any time later

COMMANDS                                               *goredo-commands*

* redo-ifchange, redo-ifcreate, redo-always (useful with redo-stamp)
* redo -- same as redo-ifchange, but forcefully and *sequentially* run
  specified targets
* redo-log -- display TAI64N timestamped last stderr of the target
* redo-stamp -- record stamp dependency and consider it non out-of-date
  if stamp equals to the previous one
* redo-cleanup -- removes either temporary, or log files, or
  everything related to goredo
* redo-whichdo -- .do search paths for specified target (similar to
  apenwarr/redo): >
    $ redo-whichdo x/y/a.b.o
    x/y/a.b.o.do
    x/y/default.b.o.do
    x/y/default.o.do
    x/y/default.do
    x/default.b.o.do
    x/default.o.do
    x/default.do
    default.b.o.do
    default.o.do
    default.do
    ../default.b.o.do
    ../default.o.do
* redo-dot -- dependency DOT graph generator. For example to visualize
  your dependencies with GraphViz: >
    $ redo target [...] # to assure that .redo is filled up
    $ redo-dot target [...] > whatever.dot
    $ dot -Tpng whatever.dot > whatever.png # possibly add -Gsplines=ortho
<
STATE                                                     *goredo-state*

Dependency and build state is kept inside .redo subdirectory in each
directory touched related the build. Each corresponding target has its
own, recreated with every rebuild, .dep file. It is recfile
(https://www.gnu.org/software/recutils/), that could have various
dependency information (dep.rec with the schema included): >

    Build: 80143f04-bfff-4673-950c-081d712f573d

    Type: ifcreate
    Target: foo.o.do

    Type: ifchange
    Target: default.o.do
    Ctime: 1605721341.253305000
    Hash: f4929732f96f11e6d4ebe94536b5edef426d00ed0146853e37a87f4295e18eda

    Type: always

    Type: stamp
    Hash: 5bbdf635932cb16b9127e69b6f3872577efed338f0a4ab6f2c7ca3df6ce50cc9
<
LICENCE~

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

 vim: filetype=help