pakakeh.go CHANGELOG

[NEW FEATURE]
New method Peek in Parser. The Peek method take a look on n bytes inside the buffer without using delimiters. The returned bytes may empty or have length less than n.

[BREAKING CHANGES]
We remove Copy and Concat functions in favor of standard library. Since Go 1.20, the standard bytes package have the Copy function. Since Go 1.22, the standard slices package have the Concat function.

[BREAKING CHANGES]
We also remove "lib/bytes.AppendXxx", "lib/bytes.ReadXxx", and "lib/bytes.WriteXxx" in favor of standard library. Since Go 1.19, package "encoding/binary" support appending byte order. The ReadXxx and WriteXxx can be replaced with standard library BigEndian/LittleEndian UintXxx and PutUintXxx.

[BREAKING CHANGES]
The global Value variable has been removed. Using global variable inside one package is a mistake. If, for example, package X set debug.Value to 1, another packages that does need to be debugged will print unnecessary log messages.

[BUG FIX]
We fix unpacking HTTPS where the response answers contains RR other than SVCB parameters, for example CNAME.

[ENHANCEMENT]
This release now detect invalid response header earlier, like invalid op code and response code, before we continue unpacking the rest data. Previously, we unpack the header and then question without detecting whether the header itself is valid or not. This cause the unpacking question return an error like

One of the case is when someone sent random or HTTP request to DoT port.

[ENHANCEMENT]
In the logging part, we improve the logging prefix on serveTCPClient. The serveTCPClient is used to serve TCP and DoT clients. Previously, the error returned from this method is prefixed based on the kind, for example

This changes pass the log prefix to the method so now it become

[ENHANCEMENT]
On server with TryDirect is true, a GET request to a directory now always rescan the content and the generate the new "index.html".

In the generated "index.html" we display the file time in UTC instead of local time.

The ParseContentRange function now return an error instead of nil "*RangePosition".

[NEW FEATURE]
Package goanalysis implement go static analysis using [Analyzer] that are not included in the default "go vet", but included in the [passes] directory, including: fieldalignment, nilness, reflectvaluecompare, shadow, sortslice, unusedwrite, and waitgroup. This package is not mean to be imported directly by other package except main, like we have in [cmd/gocheck].

This package has been renamed to "_hunspell". The hunspell is still in progress and we did not have time to continue it, so we rename it to "_hunspell" for now to prevent it being checked by linters or being imported.

[BUG FIX]
Fix possible panic on AddChild if path is not included.

[ENHANCEMENT]
One of the major issue that we previously have is the Run and Test functions can write file in any unsafe path. Another issue is default GoVersion and Timeout is set on the package level.

This release introduce new type "Go" as the top level type that can be instantiate with different Root, GoVersion, and Timeout. The instance of Go then can Format, Run, or Test the Go code in their own scope.

Any request to Run or Test Go code that requires writing new files now joined with the [GoOptions.Root] first. If the final absolute path does not have Root as the prefix it will return an error [os.ErrPermission]. This fix possible security issue where file may be written outside of the Root directory.

[ENHANCEMENT]
Inside the Assert, we call the [T.Helper] method. The Helper method mark the Assert function as test helper, which when printing file and line information, the stack trace from Assert function will be skipped. This remove manual lines skipping that previously we have.

The "lib/binary" is the 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.

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

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

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

[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.

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

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

[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].

[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".

[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,

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.

[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.

[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.

[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.

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

[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.