~shulhan/pakakeh.go 

Release pakakeh.go v0.59.0 (2025-01-06)

This is the first release of pakakeh.go on the year 2025. There are many
new features and cleaning up, including packages that merged into single
package with help of type parameters.

The first major changes is indicated by using "go 1.23.4" as minimum Go
version in this module, to allow us using new packages like "slices" and
"maps".

In this release notes, we try new format. Instead of grouping each
changes by Breaking changes, New features, Bug fixes, Enhancements,
and/or Chores; we group them by package. Each paragraph in the package
sections will be prefixed with tag "[BREAKING CHANGE]", "[NEW FEATURE]",
"[BUG FIX]", "[ENHANCEMENT]", "[CHORE]" to indicates the type of
changes.

=== lib/binary

The "lib/binary] is new package that complement the standard binary
package.

[NEW FEATURE]
Implement append-only binary that encode the data using [binary.Writer].
We call them "Apo" for short.

[NEW FEATURE]
Implement buffer for reading/writing in BigEndian. The BigEndianBuffer
provides backing storage for writing (most of) Go native types into
binary in big-endian order. The zero value of BigEndianBuffer is an
empty buffer ready to use.

The following basic types are supported for Write and Read: bool, byte,
int, float, complex, and string. The slice and array are also supported
as long as the slice’s element type is one of basic types.

=== lib/bytes

[BREAKING CHANGE]
In the "lib/bytes" we split the hexdump related functions to separate
package, "lib/hexdump".

=== lib/floats64

[BREAKING CHANGE]
This package has been removed, merged into "slices" package.

=== lib/hexdump

[NEW FEATURE]
Package hexdump implements reading and writing bytes from and into
hexadecimal number. It support parsing output from hexdump(1) tool.

=== lib/http

[NEW FEATURE]
In the [lib/http.Client] we add new method Transport that return default
HTTP Transport. The returned [http.Transport] is created after the
Client instantiated. Their value can be customized by user when needed,
which should affect the Transport inside the Client.

=== lib/ints

[BREAKING CHANGE]
This package has been removed, merged into "slices" package.

=== lib/ints64

[BREAKING CHANGE]
This package has been removed, merged into "slices" package.

=== lib/memfs

[ENHANCEMENT]
In the "lib/memfs" we refactoring the Watch method to use the new
"watchfs/v2" package.

[BREAKING CHANGE]
The old Watcher and DirWatcher types now moved to watchfs package. This
changes require exporting method [memfs.MemFS.UpdateContent].

=== lib/numbers

[CHORE]
In the package level, we remove unused README and LICENSE files. This
package README has been merged into the package documentation and the
LICENSE is same with the module one.

We also remove some package documentation that should be in
"lib/slices".

=== lib/play

[NEW FEATURE]
The [lib/play] now has function and HTTP handler to run Go test code.
Since the test must run inside the directory that contains the Go file
to be tested, the [HTTPHandleTest] API accept the following request
format,

{
	"goversion": <string>,
	"file": <string>,
	"body": <string>,
	"without_race": <boolean>
}

The "file" field define the path to the "_test.go" file, default to
"test_test.go" if its empty. The "body" field contains the Go code that
will be saved to "file". The test will run, by default, with "go test
-count=1 -race $dirname" where "$dirname" is the path directory to the
"file" relative to where the program is running. If "without_race" is
true, the test command will not run with "-race" option.

[ENHANCEMENT]
On package level, the home and cache directory now initialized on
package init since there are never changes when program running. If Go
failed to get the home and cache it will be set to system temporary
directory.

[ENHANCEMENT]
We also simplify running Go code by removing the field pid in the struct
command that wait for process ID. Instead we execute cmd with Run
directly. In the Run function, we use the UnsafeRun to store temporary
directory and move the statements that writes go.mod and main.go into
the method writes of Request. This remove unnecessary unsafeRun
function.

=== lib/reflect

[BREAKING CHANGE]
This release changes the Equal signature from "Equal(v any) bool" to
"Equal(v any) error". The reason for this changes is to force the method
to return an error message that is understand-able by caller.

=== lib/slices

[NEW FEATURE]
Package "lib/ints", "lib/ints64", and "lib/floats64" are merged into
"slices". Now that Go has type parameter, we can use it to use the same
function that accept different types for working with slice of int,
int64, and float64.

=== lib/ssh

[ENHANCEMENT]
In the lib/ssh, we implement Run with context internally. Instead of
depends on fork of crypto with CL that needs proposal, we implement them
in here so we can update crypto module to the latest release.

=== lib/watchfs

The watchfs package now contains the original, v1, of the Watcher and
DirWatcher types from "lib/memfs".

=== lib/watchfs/v2

[NEW FEATURE]
The "lib/watchfs/v2" is the new package that implement new file and
directory watcher, that replace the Watcher and DirWatcher in the
"lib/memfs".

The new implementation, FileWatcher, much more simple than what we have
in [memfs.Watcher].

The new directory watcher, DirWatcher, scan the content of directory in
[fs.DirWatcherOptions.Root] recursively for the files to be watched,
using the [fs.DirWatcherOptions.Includes] field. A single file,
[fs.DirWatcherOptions.FileWatcherOptions.FilePath], will be watched for
changes that trigger re-scanning the content of Root recursively.

The result of re-scanning is list of the Includes files (only files not
new directory) that are changes, which send to channel C. On each
[os.FileInfo] received from C, a deleted file have [os.FileInfo.Size]
equal to [NodeFlagDeleted]. The channel send an empty slice if no
changes.

The implementation of file changes in this code is naive, using loop and
comparison of mode, modification time, and size; at least it should
works on most operating system.

lib/memfs: remove GoEmbed test that generate dynamic times

The GoEmbed test that write Go embedded code into "internal/test/embed/"
may create unnecessary changes when the test run on new clone of this
repository, or when we run "go test" again on that package after rebasing.

lib/binary: implement buffer for reading/writing in BigEndian

BigEndianBuffer provides backing storage for writing (most of) Go native
types into binary in big-endian order.
The zero value of BigEndianBuffer is an empty buffer ready to use.

The following basic types are supported for Write and Read: bool, byte,
int, float, complex, and string.

The slice and array are also supported as long as the slice's element type
is one of basic types.

all: update README

Add and remove missing packages under api/, program under cmd/, and
library under lib/ directory.

cmd/ansua: add and update documentation

lib/numbers: fix package documentation that should be lib/slices

all: merge package "lib/floats64" into "slices"

Now that Go has type parameter, we can use it to use the same function
that accept different types for working with slice of float64.

all: merge package "lib/ints" and "lib/ints64" into "slices"

Now that Go has type parameter, we can use it to use the same function
that accept different types for working with slice of int, int64.

lib/numbers: remove unused README and LICENSE

This package README has been merged into the package and the LICENSE
is same with the module.

lib/bytes: split the hexdump related functions to separate package

Package hexdump implements reading and writing bytes from and into
hexadecimal number.
It support parsing output from hexdump(1) tool.

lib/binary: implement append-only binary file

The binary is new package that complement the standard binary package

Currently it implement append-only binary that encode the data using
[binary.Writer].
We call them "Apo" for short.

lib/watchfs: cleaning up, merge shared identifiers to package file

lib/watchfs: detach the options from memfs

lib/memfs: move the old Watcher and DirWatcher to watchfs

The watchfs package now contains the original, v1, of the
Watcher and DirWatcher types.

This changes require exporting method
[memfs.MemFS.UpdateContent].

lib/memfs: refactoring Watch to use "watchfs/v2"

watchfs/v2: implement new directory watcher

DirWatcher scan the content of directory in [fs.DirWatcherOptions.Root]
recursively for the files to be watched, using the
[fs.DirWatcherOptions.Includes] field.
A single file, [fs.DirWatcherOptions.FileWatcherOptions.FilePath], will
be watched for changes that will trigger re-scanning the content of Root
recursively.

The result of re-scanning is list of the Includes files (only files not
new directory) that are changes, which will be send to channel C.
On each [os.FileInfo] received from C, a deleted file have
[os.FileInfo.Size] equal to [NodeFlagDeleted].
The channel will send an empty slice if no changes.

The implementation of file changes in this code is naive, using loop and
comparison of mode, modification time, and size; at least it should
works on most operating system.

watchfs/v2: implement new file watcher

The watchfs package contains new FileWatcher, more simple than what
we have in [memfs.Watcher].

go.mod: update Go toolchains to version 1.23.4

We will needs slices and maps packages that are available since Go 1.23.

lib/test: update comment to show link on reflect.Equaler

lib/reflect: refactor the Equaler method Equal

This changes the Equal signature from "Equal(v any) bool" to
"Equal(v any) error".
The reason for this changes is to force the method to return an error
message that is understand-able by caller.

While at it, simplify checking for Equaler interface in internal
doEqualStruct function.
Next