/goredo
+/goredo.info
+/module-name
/redo
/redo-always
/redo-cleanup
/redo-stamp
/redo-whichdo
/tai64nlocal
+/VERSION
--- /dev/null
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+
+mDMEX/ntHhYJKwYBBAHaRw8BAQdAXZRNXi8Lu6nd171jQnrZyLNQoU07VL7Ly2fi
+u28HdoS0J2dvcmVkbyByZWxlYXNlcyA8Z29yZWRvQGN5cGhlcnB1bmtzLnJ1PoiZ
+BBMWCgBBFiEEdTG7hPrwvzWWDGO5OlKN3pUsfpMFAl/57R4CGwMMCwoJDQgMBwsD
+BAECBxUKCQgLAwIFFgIBAwACHgECF4AACgkQOlKN3pUsfpMETQD/XfwWgd4tReIu
+XdcrpZUsWaiTHR6hUY+HXNOpRpGevyIA/04VXYUha9RAJ/xtNMqUvsdV+TS9rFE/
+j2OEwxgRyqIOiHUEEBEKAB0WIQTPYOiaWSMeduJjZCKuGoEJ5JhX7wUCX/ntoAAK
+CRCuGoEJ5JhX70VpAP9VFGudn2x3GdmaGP7SJV1Yvdq9n6VvirLwTdwIOtoAzgD/
+axpOol/Mek0/ERCrlqrh1iQpHCy0ULty+EwnSNBtFQ8=
+=FWA1
+-----END PGP PUBLIC KEY BLOCK-----
-*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.
-
-It passes tests from dieweltistgarnichtso.net's redo-sh.tests and
-implementation-neutral from apenwarr/redo.
-
+goredo -- redo implementation on pure Go.
+See goredo.info and INSTALL for more information.
goredo is free software: see the file COPYING for copying conditions.
Home page: http://www.goredo.cypherpunks.ru/
-
-INSTALL *goredo-install*
-
-Hopefully it should work on all POSIX systems.
- >
- $ go get go.cypherpunks.ru/goredo
- $ goredo -symlinks
- $ export PATH=`pwd`:$PATH
-
-If you have problems with *.golang.org's inability to verify
-authenticity of go.cypherpunks.ru TLS connection, then you can disable
-their usage by setting GOPRIVATE=go.cypherpunks.ru. If you still have
-problems with the authenticity on your side, then build it manually: >
-
- $ git clone git://git.cypherpunks.ru/goredo.git
- $ cd goredo
- $ git tag -v v0.9.0
- $ git clone git://git.cypherpunks.ru/gorecfile.git
- $ ( cd gorecfile ; git tag -v v0.4.0 )
- $ echo "replace go.cypherpunks.ru/recfile => `pwd`/gorecfile" >> go.mod
- $ git clone git://git.cypherpunks.ru/gotai64n.git
- $ ( cd gotai64n ; git tag -v v0.2.0 )
- $ echo "replace go.cypherpunks.ru/tai64n => `pwd`/gotai64n" >> go.mod
- $ go build
- $ ./goredo -symlinks
- $ export PATH=`pwd`:$PATH
-
-NOTES *goredo-notes*
-
-* "all" target is default
-* stdout is always captured, but no target is created if it was empty
-* empty targets are considered always out of date
-* .do's $3 is relative path to the file in target directory
-* .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
-* target's completion messages are written after they finish
-* executable .do is run as is, non-executable is run with /bin/sh -e[x]
-* tracing (-x) can be obviously done only for non-executable .do
-* parallizable build is done only during redo-ifchange for human
- convenience: you can globally enable REDO_JOBS, but still do for
- example: redo htmls infos index upload
-
-FEATURES *goredo-features*
-
-* explicit useful and convenient checks from apenwarr/redo:
- * check that $1 was not touched during .do execution
- * check that stdout and $3 are not written simultaneously
- * check 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 BLAKE2b hash
-* files creation is umask-friendly (unlike mkstemp() used in redo-c)
-* parallel build with jobs limit, optionally in infinite mode
-* coloured messages (can be disabled)
-* verbose debug messages, including out-of-date determination, PIDs,
- lock and jobserver acquirings/releases
-* displaying of each target's execution time
-* each target's stderr can be prefixed with the PID
-* optional statusline with currently running/waiting/done jobs
-* target's stderr can be stored on the disk with TAI64N timestamp
- prefixes for each line. To convert them to localtime you can use either
- tai64nlocal utility from daemontools (http://cr.yp.to/daemontools.html),
- or similar one: >
- $ go get go.cypherpunks.ru/tai64n/cmd/tai64nlocal
-
-COMMANDS *goredo-commands*
-
-* redo-ifchange, redo-ifcreate, redo-always
-* 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. Nothing more, dummy
-* redo-cleanup -- removes either temporary, 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
- ../default.do
-* redo-dot -- dependency DOT graph generator. For example to visualize
- your dependencies with GraphViz: >
- $ redo target [...] # to assure that **/.redo/*.dep are filled up
- $ redo-dot target [...] > whatever.dot
- $ dot -Tpng whatever.dot > whatever.png # possibly add -Gsplines=ortho
-
-FAQ *goredo-faq*
-
- Hashing and stamping~
-
-All targets are checksummed if their ctime differs from the previous
-one. apenwarr/redo gives many reasons why every time checksumming is
-bad, but in my opinion in practice all of them do not apply.
-
-* Aggregate targets and willing to be out-of-date ones just must not
- produce empty output files. apenwarr/*, redo-c and goredo
- implementations consider non existing file as an out-of-date target
-* If you really wish to produce an empty target file, just touch $3
-
-DJB's proposal with both stdout and $3 gives that ability to control
-your desired behaviour. Those who does not capture stdout -- failed.
-Those who creates an empty file if no stdout was written -- failed.
-
-redo is a tool to help people. Literally all targets can be safely
-"redo-stamp < $3"-ed, reducing false positive out-of-dates. Of course,
-with the correct stdout/$3 working and placing necessary results in $3,
-instead of just silently feeding them in redo-stamp.
-
-redo implementations are already automatically record -ifchange on .do
-files and -ifcreate on non-existing .do files. So why they can not
-record redo-stamp the same way implicitly? No, Zen of Python does not
-applicable there, because -ifchange/-ifcreate contradict it already.
-
-Modern cryptographic hash algorithms and CPUs are so fast, that even all
-read and writes to or from hard drive arrays can be easily checksummed
-and transparently compressed, as ZFS with LZ4 and Skein/BLAKE[23]
-algorithms demonstrate us.
-
-goredo includes redo-stamp, that really records the stamp in the .dep
-file, but it does not play any role later. It is stayed just for
-compatibility.
-
- Can removed .do lead to permanent errors of its non existence?~
-
-Yes, because dependency on it was recorded previously. Is it safe to
-assume that .do-less target now is an ordinary source-file? I have no
-confidence in such behaviour. So it is user's decision how to deal with
-it, probably it was just his inaccuracy mistake. If you really want to
-get rid of that dependency knowledge for foo/bar target, then just
-remove foo/.redo/bar.dep.
-
- Does redo-always always rebuilds target?~
-
-goredo, together with apenwarr/redo, rebuilds target once per run.
-Always rebuilds during every redo invocation, but only once during it
-building. http://news.dieweltistgarnichtso.net/bin/redo-sh.html#why-built-twice
-has other opinion, that is why its redo-sh.tests/always_rebuild_1 will
-fail. Rebuilding of always-ed targets even during the same build process
-ruins any redo's usability in practice.
-
-For example if my .h file contains source code's version number, that is
-git-describe's output and all my other files depends on that header,
-then any redo-ifchange of .o will lead to git-describe execution, that
-is rather heavy. Of course, because of either hashing or possible
-redo-stamp-ing its dependants won't be rebuilt further, but build time
-will be already ruined. If you need to rebuild TeX documents (case
-mentioned in redo-sh's FAQ) until all references and numbers are ready,
-then you must naturally expectedly explicitly use while cycle in your
-.do, as apenwarr/redo already suggests.
-
-STATE *goredo-state*
-
-Dependency and build state is kept inside .redo subdirectory in each
-directory 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
-
-USAGE *goredo-usage*
-
-Run any of the command above with the -help.
-
-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
--- /dev/null
+redo-ifchange usage.go
+perl -ne 'print "$1\n" if /Version.*"(.*)"$/' < usage.go
--- /dev/null
+@node Commands
+@unnumbered Commands
+
+@table @command
+
+@item redo-ifchange, redo-ifcreate, redo-always
+
+@item redo
+ Same as redo-ifchange, but forcefully and sequentially run specified
+ targets.
+
+@item redo-log
+ Display TAI64N timestamped last @command{stderr} of the target.
+
+@item redo-stamp
+ Record stamp dependency. Nothing more, dummy. Read about
+ @ref{Stamping, stamping} in the FAQ.
+
+@item redo-cleanup
+ Removes either temporary, log files, or everything related to
+ @command{goredo}.
+
+@item redo-whichdo
+ Display @file{.do} search paths for specified target (similar to
+ @command{apenwarr/redo}):
+@example
+$ 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
+../default.do
+@end example
+
+@item redo-dot
+ Dependency
+ @url{https://en.wikipedia.org/wiki/DOT_(graph_description_language), DOT}
+ graph generator. For example to visualize your dependencies with GraphViz:
+@example
+$ redo target [...] # to assure that **/.redo/*.dep are filled up
+$ redo-dot target [...] > whatever.dot
+$ dot -Tpng whatever.dot > whatever.png # possibly add -Gsplines=ortho
+@end example
+
+@end table
--- /dev/null
+@multitable {XXXXX} {XXXX-XX-XX} {XXXX KiB} {link sign} {xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}
+@headitem Version @tab Date @tab Size @tab Tarball @tab SHA256 checksum
+
+@end multitable
--- /dev/null
+@node FAQ
+@unnumbered FAQ
+
+@anchor{Stamping}
+@section Hashing and stamping
+
+All targets are checksummed if their @file{ctime} differs from the
+previous one. @command{apenwarr/redo} gives many reasons why every time
+checksumming is bad, but in my opinion in practice all of them do not
+apply.
+
+@itemize
+@item Aggregate targets and willing to be out-of-date ones just must not
+ produce empty output files. @command{apenwarr/*}, @command{redo-c} and
+ @command{goredo} implementations consider non existing file as an
+ out-of-date target
+@item If you really wish to produce an empty target file, just touch @file{$3}
+@end itemize
+
+DJB's proposal with both @file{stdout} and @file{$3} gives that ability
+to control your desired behaviour. Those who does not capture
+@file{stdout} -- failed. Those who creates an empty file if no
+@file{stdout} was written -- failed.
+
+redo is a tool to help people. Literally all targets can be safely
+@code{redo-stamp < $3}-ed, reducing false positive out-of-dates. Of
+course, with the correct @file{stdout}/@file{$3} working and placing
+necessary results in @file{$3}, instead of just silently feeding them in
+redo-stamp.
+
+redo implementations are already automatically record -ifchange on
+@file{.do} files and -ifcreate on non-existing @file{.do} files. So why
+they can not record redo-stamp the same way implicitly? No, Zen of
+Python does not applicable there, because -ifchange/-ifcreate contradict
+it already.
+
+Modern cryptographic hash algorithms and CPUs are so fast, that even all
+read and writes to or from hard drive arrays can be easily checksummed
+and transparently compressed, as ZFS with LZ4 and Skein/BLAKE[23]
+algorithms demonstrate us.
+
+@command{goredo} includes @command{redo-stamp}, that really records the
+stamp in the @file{.dep} file, but it does not play any role later. It
+is stayed just for compatibility.
+
+@section Can removed .do lead to permanent errors of its non existence?
+
+Yes, because dependency on it was recorded previously. Is it safe to
+assume that @file{.do}-less target now is an ordinary source-file? I
+have no confidence in such behaviour. So it is user's decision how to
+deal with it, probably it was just his inaccuracy mistake. If you really
+want to get rid of that dependency knowledge for @file{foo/bar} target,
+then just remove @file{foo/.redo/bar.dep}.
+
+@section Does redo-always always rebuilds target?
+
+@command{goredo}, together with @command{apenwarr/redo}, rebuilds target
+once per @strong{run}.
+Always rebuilds during every redo invocation, but only once during it
+building.
+@url{http://news.dieweltistgarnichtso.net/bin/redo-sh.html#why-built-twice, redo-sh}
+has other opinion, that is why its @file{redo-sh.tests/always_rebuild_1}
+will fail. Rebuilding of always-ed targets even during the same build
+process ruins any redo's usability in practice.
+
+For example if my @file{.h} file contains source code's version number,
+that is @command{git describe}'s output and all my other files depends
+on that header, then any @command{redo-ifchange} of @file{.o} will lead
+to @command{git describe} execution, that is rather heavy. Of course,
+because of either hashing or possible @command{redo-stamp}-ing its
+dependants won't be rebuilt further, but build time will be already
+ruined. If you need to rebuild TeX documents (case mentioned in
+redo-sh's FAQ) until all references and numbers are ready, then you must
+naturally expectedly explicitly use while cycle in your @file{.do}, as
+@command{apenwarr/redo} already suggests.
--- /dev/null
+@node Features
+@unnumbered Features
+
+@itemize
+
+@item explicit useful and convenient checks from @command{apenwarr/redo}:
+ @itemize
+ @item check that @file{$1} was not touched during .do execution
+ @item check that @file{stdout} and @file{$3} are not written simultaneously
+ @item check that generated target was not modified "externally" outside
+ the redo, preventing its overwriting, but continuing the build
+ @end itemize
+@item targets, dependency information and their directories are explicitly
+ synced (can be disabled, should work faster)
+@item file's change is detected by comparing its @code{ctime} and BLAKE3 hash
+@item files creation is @code{umask}-friendly (unlike @code{mkstemp()}
+ used in @command{redo-c})
+@item parallel build with jobs limit, optionally in infinite mode
+@item coloured messages (can be disabled)
+@item verbose debug messages, including out-of-date determination, PIDs,
+ lock and jobserver acquirings/releases
+@item displaying of each target's execution time
+@item each target's @file{stderr} can be prefixed with the PID
+@item optional statusline with currently running/waiting/done jobs
+@item target's @file{stderr} can be stored on the disk with
+ @url{http://cr.yp.to/libtai/tai64.html, TAI64N} timestamp prefixes
+ for each line. To convert them to localtime you can use either
+ tai64nlocal utility from @url{http://cr.yp.to/daemontools.html,
+ daemontools}, or similar one:
+ @code{go get go.cypherpunks.ru/tai64n/cmd/tai64nlocal}
+
+@end itemize
--- /dev/null
+echo YOU ARE LIKELY TO BE EATEN BY A GRUE >&2
--- /dev/null
+redo-ifchange *.texi VERSION
+${MAKEINFO:-makeinfo} \
+ -D "VERSION `cat VERSION`" \
+ --set-customization-variable CLOSE_QUOTE_SYMBOL=\" \
+ --set-customization-variable OPEN_QUOTE_SYMBOL=\" \
+ --output $3 goredo.texi
--- /dev/null
+\input texinfo
+@documentencoding UTF-8
+@settitle goredo
+
+@copying
+Copyright @copyright{} 2020-2021 @email{stargrave@@stargrave.org, Sergey Matveev}
+@end copying
+
+@node Top
+@top
+
+This is pure Go implementation of @url{http://cr.yp.to/redo.html, DJB's
+redo} build system proposal. Originally it was just a rewrite of
+@url{https://github.com/leahneukirchen/redo-c, redo-c}, but later most
+features of @url{https://redo.readthedocs.io/en/latest/, apenwarr/redo}
+were also implemented. Why yet another implementation? It is feature
+full and has better performance comparing to shell and Python
+implementation.
+
+It passes tests from
+@url{http://news.dieweltistgarnichtso.net/bin/redo-sh.html, redo-sh.tests}
+and implementation-neutral ones from @command{apenwarr/redo}.
+
+goredo is free software, licenced under
+@url{https://www.gnu.org/licenses/gpl-3.0.html, GNU GPLv3}:
+see the file COPYING for copying conditions.
+
+Please send questions, bug reports and patches to
+@url{https://lists.cypherpunks.ru/mailman/listinfo/goredo-devel, goredo-devel}
+maillist. Announcements also go to this mailing list.
+
+@insertcopying
+
+@include features.texi
+@include notes.texi
+@include cmds.texi
+@include news.texi
+@include install.texi
+@include faq.texi
+@include state.texi
+
+@bye
--- /dev/null
+@node Install
+@unnumbered Install
+
+Hopefully it should work on all POSIX systems.
+Preferable way is to download tarball with the signature from website:
+
+@example
+$ [fetch|wget] http://www.goredo.cypherpunks.ru/download/goredo-@value{VERSION}.tar.zst
+$ [fetch|wget] http://www.goredo.cypherpunks.ru/download/goredo-@value{VERSION}.tar.zst.sig
+$ gpg --verify goredo-@value{VERSION}.tar.zst.sig goredo-@value{VERSION}.tar.zst
+$ zstd -d < goredo-@value{VERSION}.tar.zst | tar xf -
+$ cd goredo-@value{VERSION}
+$ GOPATH=`pwd` go build go.cypherpunks.ru/goredo
+$ ./goredo -symlinks # create redo-* commands symlinks
+$ export PATH=`pwd`:$PATH # let your system know about goredo
+@end example
+
+@include download.texi
+
+You @strong{have to} verify downloaded tarballs integrity and
+authenticity to be sure that you retrieved trusted and untampered
+software. @url{https://www.gnupg.org/, GNU Privacy Guard} is used
+for that purpose.
+
+For the very first time it is necessary to get signing public key and
+import it. It is provided below, but you should check alternative
+resources.
+
+@verbatim
+pub ed25519/0x3A528DDE952C7E93 2021-01-09 [SC]
+ 7531BB84FAF0BF35960C63B93A528DDE952C7E93
+uid goredo releases <goredo@cypherpunks.ru>
+@end verbatim
+
+@itemize
+
+@item
+@example
+$ gpg --auto-key-locate dane --locate-keys goredo at cypherpunks dot ru
+$ gpg --auto-key-locate wkd --locate-keys goredo at cypherpunks dot ru
+@end example
+
+@item
+@verbatiminclude PUBKEY.asc
+
+@end itemize
+
+It is also @command{go get}-able:
+
+@example
+$ go get go.cypherpunks.ru/goredo
+$ goredo -symlinks
+@end example
+
+If you have problems with @code{*.golang.org}'s inability to verify
+authenticity of @code{go.cypherpunks.ru} TLS connection, then you can
+disable their usage by setting @env{GOPRIVATE=go.cypherpunks.ru}. You
+can override CA certificate file path with @env{SSL_CERT_FILE} and
+@env{GIT_SSL_CAINFO} environment variables.
+
+You can obtain development source code with
+@command{git clone git://git.cypherpunks.ru/goredo.git}
+(also you can use @url{https://git.cypherpunks.ru/goredo.git}).
--- /dev/null
+#!/bin/sh -ex
+
+cur=$(pwd)
+tmp=$(mktemp -d)
+release=$1
+[ -n "$release" ]
+
+git clone . $tmp/goredo-$release
+cd $tmp/goredo-$release
+git checkout v$release
+
+redo-ifchange module-name VERSION
+mod_name=`cat module-name`
+
+########################################################################
+cat > download.texi <<EOF
+You can obtain releases source code prepared tarballs on
+@url{http://www.goredo.cypherpunks.ru/}.
+EOF
+redo goredo.info
+
+mkinfo() {
+ ${MAKEINFO:-makeinfo} --plaintext \
+ --set-customization-variable CLOSE_QUOTE_SYMBOL=\" \
+ --set-customization-variable OPEN_QUOTE_SYMBOL=\" \
+ -D "VERSION `cat VERSION`" $@
+}
+
+texi=$(mktemp)
+
+cat > $texi <<EOF
+\input texinfo
+@documentencoding UTF-8
+@settitle NEWS
+@node News
+@unnumbered News
+`sed -n '3,$p' < news.texi`
+@bye
+EOF
+mkinfo --output NEWS $texi
+
+cat > $texi <<EOF
+\input texinfo
+@documentencoding UTF-8
+@settitle INSTALL
+@include install.texi
+@bye
+EOF
+perl -i -p -e "s/.verbatiminclude PUBKEY.asc/Look in PUBKEY.asc file./" install.texi
+mkinfo --output INSTALL $texi
+
+rm $texi
+
+########################################################################
+
+mkdir -p src/$mod_name
+mv *.go go.* src/$mod_name
+
+mods="
+go.cypherpunks.ru/recfile
+go.cypherpunks.ru/tai64n
+golang.org/x/crypto
+golang.org/x/sys
+golang.org/x/term
+"
+
+for mod in $mods; do
+ mod_path=$(sed -n "s# // indirect## ; s#^ \($mod\) \(.*\)\$#\1@\2#p" src/$mod_name/go.mod)
+ [ -n "$mod_path" ]
+ mkdir -p src/$mod
+ ( cd $GOPATH/pkg/mod/$mod_path ; tar cf - --exclude ".git*" * ) | tar xfC - src/$mod
+ chmod -R +w src/$mod
+done
+
+cat > $tmp/includes <<EOF
+golang.org/x/crypto/AUTHORS
+golang.org/x/crypto/blake2b
+golang.org/x/crypto/CONTRIBUTORS
+golang.org/x/crypto/go.mod
+golang.org/x/crypto/go.sum
+golang.org/x/crypto/LICENSE
+golang.org/x/crypto/PATENTS
+golang.org/x/crypto/README.md
+golang.org/x/sys/AUTHORS
+golang.org/x/sys/CONTRIBUTORS
+golang.org/x/sys/cpu
+golang.org/x/sys/go.mod
+golang.org/x/sys/internal/unsafeheader
+golang.org/x/sys/LICENSE
+golang.org/x/sys/PATENTS
+golang.org/x/sys/README.md
+golang.org/x/sys/unix
+golang.org/x/term
+EOF
+tar cfCI - src $tmp/includes | tar xfC - $tmp
+rm -fr src/golang.org $tmp/includes
+mv $tmp/golang.org src
+
+########################################################################
+
+rm -rf *.texi .redo .git .gitignore makedist.sh goredo.info.do module-name* VERSION.do
+find . -type d -exec chmod 755 {} \;
+find . -type f -exec chmod 644 {} \;
+
+cd ..
+tar cvf goredo-"$release".tar --uid=0 --gid=0 --numeric-owner goredo-"$release"
+zstd -19 -v goredo-"$release".tar
+gpg --detach-sign --sign --local-user 3A528DDE952C7E93 goredo-"$release".tar.zst
+
+tarball=goredo-"$release".tar.zst
+size=$(( $(stat -f %z $tarball) / 1024 ))
+hash=$(gpg --print-md SHA256 < $tarball)
+release_date=$(date "+%Y-%m-%d")
+
+cat <<EOF
+An entry for documentation:
+@item @ref{Release $release, $release} @tab $release_date @tab $size KiB
+@tab @url{goredo-${release}.tar.zst, link} @url{goredo-${release}.tar.zst.sig, sign}
+@tab @code{$hash}
+EOF
+
+mv $tmp/$tarball $tmp/"$tarball".sig $cur/goredo.html/download
+
+cat <<EOF
+Subject: goredo $release release announcement
+
+I am pleased to announce goredo $release release availability!
+
+goredo is redo implementation on pure Go.
+
+------------------------ >8 ------------------------
+
+The main improvements for that release are:
+
+
+------------------------ >8 ------------------------
+
+goredo's home page is: http://www.goredo.cypherpunks.ru/
+
+Source code and its signature for that version can be found here:
+
+ http://www.goredo.cypherpunks.ru/download/goredo-${release}.tar.zst ($size KiB)
+ http://www.goredo.cypherpunks.ru/download/goredo-${release}.tar.zst.sig
+
+SHA256 hash: $hash
+GPG key ID: 0x3A528DDE952C7E93 goredo releases <goredo@cypherpunks.ru>
+Fingerprint: 7531 BB84 FAF0 BF35 960C 63B9 3A52 8DDE 952C 7E93
+
+Please send questions regarding the use of goredo, bug reports and patches
+to mailing list: https://lists.cypherpunks.ru/pipermail/goredo-devel/
+EOF
--- /dev/null
+redo-ifchange go.mod
+sed -n 's/^module //p' < go.mod
--- /dev/null
+@node News
+@unnumbered News
+
+@table @strong
+
+@anchor{Release 0.10.0}
+@item 0.10.0
+ Initial tarballed release.
+
+@end table
--- /dev/null
+@node Notes
+@unnumbered Implementation notes
+
+@itemize
+
+@item @file{all} target is default
+@item @file{stdout} is always captured, but no target is created if it
+ was empty
+@item empty targets are considered always out of date
+@item @file{.do}'s @file{$3} is relative path to the file in target directory
+@item @file{.do} search goes up to @file{/} by default, but can be
+ limited with either @env{$REDO_TOP_DIR} environment variable, or by
+ having @file{.redo/top} file in it
+@item target's completion messages are written after they finish
+@item executable @file{.do} is run as is, non-executable is run with
+ @code{/bin/sh -e[x]}
+@item tracing (-x) can be obviously done only for non-executable @file{.do}
+@item parallizable build is done only during @command{redo-ifchange} for
+ human convenience: you can globally enable @env{REDO_JOBS}, but
+ still do for example: @code{redo htmls infos index upload}
+
+@end itemize
--- /dev/null
+@node State
+@unnumbered State
+
+Dependency and build state is kept inside @file{.redo} subdirectory in
+each directory related the build. Each corresponding target has its own,
+recreated with every rebuild, @file{.dep} file. It is
+@url{https://www.gnu.org/software/recutils/, recfile}, that could have
+various dependency information (@file{dep.rec} with the schema
+included):
+
+@example
+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
+@end example
)
const (
- Version = "0.9.0"
+ Version = "0.10.0"
Warranty = `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.