core/go-io
8
0
Fork 0
Code Issues 4 Pull requests Projects Releases Packages Wiki Activity Actions

refactor(ax): tighten local naming

Browse source 
Co-Authored-By: Virgil <virgil@lethean.io>
This commit is contained in:
Virgil 2026-03-31 13:25:00 +00:00
parent eab112c7cf
commit bd8d7c6975
8 changed files with 56 additions and 56 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
node/node.go
View file

@ -53,8 +53,8 @@ func (node *Node) AddData(name string, content []byte) {
// Example: snapshot, _ := nodeTree.ToTar()
func (node *Node) ToTar() ([]byte, error) {
buf := new(bytes.Buffer)
tw := tar.NewWriter(buf)
buffer := new(bytes.Buffer)
tarWriter := tar.NewWriter(buffer)
for _, file := range node.files {
hdr := &tar.Header{
@ -63,19 +63,19 @@ func (node *Node) ToTar() ([]byte, error) {
Size: int64(len(file.content)),
ModTime: file.modTime,
}
if err := tw.WriteHeader(hdr); err != nil {
if err := tarWriter.WriteHeader(hdr); err != nil {
return nil, err
}
if _, err := tw.Write(file.content); err != nil {
if _, err := tarWriter.Write(file.content); err != nil {
return nil, err
}
}
if err := tw.Close(); err != nil {
if err := tarWriter.Close(); err != nil {
return nil, err
}
return buf.Bytes(), nil
return buffer.Bytes(), nil
}
// Example: restored, _ := node.FromTar(snapshot)
@ -90,10 +90,10 @@ func FromTar(data []byte) (*Node, error) {
// Example: _ = nodeTree.LoadTar(snapshot)
func (node *Node) LoadTar(data []byte) error {
newFiles := make(map[string]*dataFile)
tr := tar.NewReader(bytes.NewReader(data))
tarReader := tar.NewReader(bytes.NewReader(data))
for {
header, err := tr.Next()
header, err := tarReader.Next()
if err == goio.EOF {
break
}
@ -102,7 +102,7 @@ func (node *Node) LoadTar(data []byte) error {
}
if header.Typeflag == tar.TypeReg {
content, err := goio.ReadAll(tr)
content, err := goio.ReadAll(tarReader)
if err != nil {
return core.E("node.LoadTar", "read tar entry", err)
}
@ -147,18 +147,18 @@ func (node *Node) Walk(root string, fn fs.WalkDirFunc, options WalkOptions) erro
}
}
result := fn(entryPath, entry, err)
walkResult := fn(entryPath, entry, err)
if result == nil && options.MaxDepth > 0 && entry != nil && entry.IsDir() && entryPath != root {
rel := core.TrimPrefix(entryPath, root)
rel = core.TrimPrefix(rel, "/")
depth := len(core.Split(rel, "/"))
if walkResult == nil && options.MaxDepth > 0 && entry != nil && entry.IsDir() && entryPath != root {
relativePath := core.TrimPrefix(entryPath, root)
relativePath = core.TrimPrefix(relativePath, "/")
depth := len(core.Split(relativePath, "/"))
if depth >= options.MaxDepth {
return fs.SkipDir
}
}
return result
return walkResult
})
}

24
node/node_test.go
View file

@ -463,15 +463,15 @@ func TestNode_ToTar_Good(t *testing.T) {
require.NoError(t, err)
require.NotEmpty(t, tarball)
tr := tar.NewReader(bytes.NewReader(tarball))
tarReader := tar.NewReader(bytes.NewReader(tarball))
files := make(map[string]string)
for {
header, err := tr.Next()
header, err := tarReader.Next()
if err == io.EOF {
break
}
require.NoError(t, err)
content, err := io.ReadAll(tr)
content, err := io.ReadAll(tarReader)
require.NoError(t, err)
files[header.Name] = string(content)
}
@ -481,26 +481,26 @@ func TestNode_ToTar_Good(t *testing.T) {
}
func TestNode_FromTar_Good(t *testing.T) {
buf := new(bytes.Buffer)
tw := tar.NewWriter(buf)
buffer := new(bytes.Buffer)
tarWriter := tar.NewWriter(buffer)
for _, f := range []struct{ Name, Body string }{
for _, file := range []struct{ Name, Body string }{
{"foo.txt", "foo"},
{"bar/baz.txt", "baz"},
} {
hdr := &tar.Header{
Name: f.Name,
Name: file.Name,
Mode: 0600,
Size: int64(len(f.Body)),
Size: int64(len(file.Body)),
Typeflag: tar.TypeReg,
}
require.NoError(t, tw.WriteHeader(hdr))
_, err := tw.Write([]byte(f.Body))
require.NoError(t, tarWriter.WriteHeader(hdr))
_, err := tarWriter.Write([]byte(file.Body))
require.NoError(t, err)
}
require.NoError(t, tw.Close())
require.NoError(t, tarWriter.Close())
nodeTree, err := FromTar(buf.Bytes())
nodeTree, err := FromTar(buffer.Bytes())
require.NoError(t, err)
assert.True(t, nodeTree.Exists("foo.txt"), "foo.txt should exist")

8
sqlite/sqlite.go
View file

@ -203,11 +203,11 @@ func (medium *Medium) Delete(filePath string) error {
}
}
res, err := medium.database.Exec(`DELETE FROM `+medium.table+` WHERE path = ?`, key)
execResult, err := medium.database.Exec(`DELETE FROM `+medium.table+` WHERE path = ?`, key)
if err != nil {
return core.E("sqlite.Delete", core.Concat("delete failed: ", key), err)
}
rowsAffected, _ := res.RowsAffected()
rowsAffected, _ := execResult.RowsAffected()
if rowsAffected == 0 {
return core.E("sqlite.Delete", core.Concat("path not found: ", key), fs.ErrNotExist)
}
@ -223,14 +223,14 @@ func (medium *Medium) DeleteAll(filePath string) error {
prefix := key + "/"
res, err := medium.database.Exec(
execResult, err := medium.database.Exec(
`DELETE FROM `+medium.table+` WHERE path = ? OR path LIKE ?`,
key, prefix+"%",
)
if err != nil {
return core.E("sqlite.DeleteAll", core.Concat("delete failed: ", key), err)
}
rowsAffected, _ := res.RowsAffected()
rowsAffected, _ := execResult.RowsAffected()
if rowsAffected == 0 {
return core.E("sqlite.DeleteAll", core.Concat("path not found: ", key), fs.ErrNotExist)
}

8
store/medium.go
View file

@ -128,11 +128,11 @@ func (medium *Medium) Rename(oldPath, newPath string) error {
if oldKey == "" || newKey == "" {
return core.E("store.Rename", "both paths must include group/key", fs.ErrInvalid)
}
val, err := medium.store.Get(oldGroup, oldKey)
value, err := medium.store.Get(oldGroup, oldKey)
if err != nil {
return err
}
if err := medium.store.Set(newGroup, newKey, val); err != nil {
if err := medium.store.Set(newGroup, newKey, value); err != nil {
return err
}
return medium.store.Delete(oldGroup, oldKey)
@ -235,11 +235,11 @@ func (medium *Medium) ReadStream(entryPath string) (goio.ReadCloser, error) {
if key == "" {
return nil, core.E("store.ReadStream", "path must include group/key", fs.ErrInvalid)
}
val, err := medium.store.Get(group, key)
value, err := medium.store.Get(group, key)
if err != nil {
return nil, err
}
return goio.NopCloser(core.NewReader(val)), nil
return goio.NopCloser(core.NewReader(value)), nil
}
func (medium *Medium) WriteStream(entryPath string) (goio.WriteCloser, error) {

24
store/medium_test.go
View file

@ -23,9 +23,9 @@ func TestKeyValueMedium_ReadWrite_Good(t *testing.T) {
err := m.Write("config/theme", "dark")
require.NoError(t, err)
val, err := m.Read("config/theme")
value, err := m.Read("config/theme")
require.NoError(t, err)
assert.Equal(t, "dark", val)
assert.Equal(t, "dark", value)
}
func TestKeyValueMedium_Read_NoKey_Bad(t *testing.T) {
@ -83,9 +83,9 @@ func TestKeyValueMedium_Rename_Good(t *testing.T) {
err := m.Rename("old/key", "new/key")
require.NoError(t, err)
val, err := m.Read("new/key")
value, err := m.Read("new/key")
require.NoError(t, err)
assert.Equal(t, "val", val)
assert.Equal(t, "val", value)
assert.False(t, m.IsFile("old/key"))
}
@ -163,9 +163,9 @@ func TestKeyValueMedium_CreateClose_Good(t *testing.T) {
_, _ = w.Write([]byte("streamed"))
require.NoError(t, w.Close())
val, err := m.Read("group/key")
value, err := m.Read("group/key")
require.NoError(t, err)
assert.Equal(t, "streamed", val)
assert.Equal(t, "streamed", value)
}
func TestKeyValueMedium_Append_Good(t *testing.T) {
@ -177,9 +177,9 @@ func TestKeyValueMedium_Append_Good(t *testing.T) {
_, _ = w.Write([]byte(" world"))
require.NoError(t, w.Close())
val, err := m.Read("group/key")
value, err := m.Read("group/key")
require.NoError(t, err)
assert.Equal(t, "hello world", val)
assert.Equal(t, "hello world", value)
}
func TestKeyValueMedium_AsMedium_Good(t *testing.T) {
@ -188,13 +188,13 @@ func TestKeyValueMedium_AsMedium_Good(t *testing.T) {
m := s.AsMedium()
require.NoError(t, m.Write("group/key", "val"))
val, err := s.Get("group", "key")
value, err := s.Get("group", "key")
require.NoError(t, err)
assert.Equal(t, "val", val)
assert.Equal(t, "val", value)
val, err = m.Read("group/key")
value, err = m.Read("group/key")
require.NoError(t, err)
assert.Equal(t, "val", val)
assert.Equal(t, "val", value)
}
func TestKeyValueMedium_Store_Good(t *testing.T) {

4
store/store_test.go
View file

@ -34,9 +34,9 @@ func TestStore_SetGet_Good(t *testing.T) {
err := keyValueStore.Set("config", "theme", "dark")
require.NoError(t, err)
val, err := keyValueStore.Get("config", "theme")
value, err := keyValueStore.Get("config", "theme")
require.NoError(t, err)
assert.Equal(t, "dark", val)
assert.Equal(t, "dark", value)
}
func TestStore_Get_NotFound_Bad(t *testing.T) {

4
workspace/service.go
View file

@ -134,12 +134,12 @@ func (service *Service) CreateWorkspace(identifier, password string) (string, er
}
}
privKey, err := service.keyPairProvider.CreateKeyPair(identifier, password)
privateKey, err := service.keyPairProvider.CreateKeyPair(identifier, password)
if err != nil {
return "", core.E("workspace.CreateWorkspace", "failed to generate keys", err)
}
if err := service.medium.WriteMode(core.Path(workspaceDirectory, "keys", "private.key"), privKey, 0600); err != nil {
if err := service.medium.WriteMode(core.Path(workspaceDirectory, "keys", "private.key"), privateKey, 0600); err != nil {
return "", core.E("workspace.CreateWorkspace", "failed to save private key", err)
}

10
workspace/service_test.go
View file

@ -10,15 +10,15 @@ import (
)
type stubKeyPairProvider struct {
key string
err error
privateKey string
err error
}
func (provider stubKeyPairProvider) CreateKeyPair(_, _ string) (string, error) {
if provider.err != nil {
return "", provider.err
}
return provider.key, nil
return provider.privateKey, nil
}
func newTestService(t *testing.T) (*Service, string) {
@ -27,7 +27,7 @@ func newTestService(t *testing.T) (*Service, string) {
tempHome := t.TempDir()
t.Setenv("HOME", tempHome)
service, err := New(Options{KeyPairProvider: stubKeyPairProvider{key: "private-key"}})
service, err := New(Options{KeyPairProvider: stubKeyPairProvider{privateKey: "private-key"}})
require.NoError(t, err)
return service, tempHome
}
@ -42,7 +42,7 @@ func TestService_New_CustomRootPathAndMedium_Good(t *testing.T) {
rootPath := core.Path(t.TempDir(), "custom", "workspaces")
service, err := New(Options{
KeyPairProvider: stubKeyPairProvider{key: "private-key"},
KeyPairProvider: stubKeyPairProvider{privateKey: "private-key"},
RootPath: rootPath,
Medium: medium,
})