LumeWeb
/
libs5-go
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor: unify all encoding packages

This commit is contained in:
Derrick Hammer 2024-01-03 08:36:23 -05:00
parent 355de2b65f
commit 1b30048a75
Signed by: pcfreak30
GPG Key ID: C997C339BE476FF2
7 changed files with 80 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
cid/cid.go → encoding/cid.go
View File

@ -1,13 +1,11 @@
package cid
package encoding
import (
"bytes"
"encoding/hex"
"errors"
"fmt"
"git.lumeweb.com/LumeWeb/libs5-go/cid/multibase"
"git.lumeweb.com/LumeWeb/libs5-go/internal/bases"
"git.lumeweb.com/LumeWeb/libs5-go/multihash"
"git.lumeweb.com/LumeWeb/libs5-go/types"
"git.lumeweb.com/LumeWeb/libs5-go/utils"
)
@ -18,19 +16,19 @@ var (
)
type CID struct {
multibase.Multibase
Multibase
Type types.CIDType
Hash multihash.Multihash
Hash Multihash
Size uint32
}
func New(Type types.CIDType, Hash multihash.Multihash, Size uint32) *CID {
func NewCID(Type types.CIDType, Hash Multihash, Size uint32) *CID {
c := &CID{
Type: Type,
Hash: Hash,
Size: Size,
}
m := multibase.New(c)
m := NewMultibase(c)
c.Multibase = m
return c
@ -60,7 +58,7 @@ func (cid *CID) ToBytes() []byte {
}
func Decode(cid string) (*CID, error) {
decodedBytes, err := multibase.DecodeString(cid)
decodedBytes, err := MultibaseDecodeString(cid)
if err != nil {
return nil, err
}
@ -74,7 +72,7 @@ func Decode(cid string) (*CID, error) {
return cidInstance, nil
}
func FromRegistry(bytes []byte) (*CID, error) {
func CIDFromRegistry(bytes []byte) (*CID, error) {
if len(bytes) == 0 {
return nil, errEmptyBytes
}
@ -95,11 +93,11 @@ func FromRegistry(bytes []byte) (*CID, error) {
return cidInstance, nil
}
func FromBytes(bytes []byte) (*CID, error) {
func CIDFromBytes(bytes []byte) (*CID, error) {
return initCID(bytes)
}
func FromHash(bytes interface{}, size uint32, cidType types.CIDType) (*CID, error) {
func CIDFromHash(bytes interface{}, size uint32, cidType types.CIDType) (*CID, error) {
var (
byteSlice []byte
err error
@ -121,10 +119,10 @@ func FromHash(bytes interface{}, size uint32, cidType types.CIDType) (*CID, erro
return nil, fmt.Errorf("invalid hash type %d", cidType)
}
return New(cidType, *multihash.New(byteSlice), size), nil
return NewCID(cidType, *NewMultihash(byteSlice), size), nil
}
func Verify(bytes interface{}) bool {
func CIDVerify(bytes interface{}) bool {
var (
byteSlice []byte
err error
@ -132,7 +130,7 @@ func Verify(bytes interface{}) bool {
switch v := bytes.(type) {
case string:
byteSlice, err = multibase.DecodeString(v) // Assuming MultibaseDecodeString function is defined
byteSlice, err = MultibaseDecodeString(v) // Assuming MultibaseDecodeString function is defined
if err != nil {
return false
}
@ -155,7 +153,7 @@ func (cid *CID) CopyWith(newType int, newSize uint32) (*CID, error) {
return nil, fmt.Errorf("invalid cid type %d", newType)
}
return New(types.CIDType(newType), cid.Hash, newSize), nil
return NewCID(types.CIDType(newType), cid.Hash, newSize), nil
}
func (cid *CID) ToRegistryEntry() []byte {
@ -197,8 +195,8 @@ func (cid *CID) HashCode() int {
int(fullBytes[3])<<24
}
func FromRegistryPublicKey(pubkey interface{}) (*CID, error) {
return FromHash(pubkey, 0, types.CIDTypeResolver)
func CIDFromRegistryPublicKey(pubkey interface{}) (*CID, error) {
return CIDFromHash(pubkey, 0, types.CIDTypeResolver)
}
func initCID(bytes []byte) (*CID, error) {
@ -208,12 +206,12 @@ func initCID(bytes []byte) (*CID, error) {
cidType := types.CIDType(bytes[0])
if cidType == types.CIDTypeBridge {
hash := multihash.New(bytes[1:35])
return New(cidType, *hash, 0), nil
hash := NewMultihash(bytes[1:35])
return NewCID(cidType, *hash, 0), nil
}
hashBytes := bytes[1:34]
hash := multihash.New(hashBytes)
hash := NewMultihash(hashBytes)
var size uint32
if len(bytes) > 34 {
@ -226,5 +224,5 @@ func initCID(bytes []byte) (*CID, error) {
return nil, fmt.Errorf("invalid cid type %d", cidType)
}
return New(cidType, *hash, size), nil
return NewCID(cidType, *hash, size), nil
}

80
cid/cid_test.go → encoding/cid_test.go
View File

@ -1,9 +1,7 @@
package cid
package encoding
import (
"git.lumeweb.com/LumeWeb/libs5-go/cid/multibase"
"git.lumeweb.com/LumeWeb/libs5-go/internal/testdata"
"git.lumeweb.com/LumeWeb/libs5-go/multihash"
"git.lumeweb.com/LumeWeb/libs5-go/types"
"reflect"
"testing"
@ -11,9 +9,9 @@ import (
func TestCID_CopyWith(t *testing.T) {
type fields struct {
Multibase multibase.Multibase
Multibase Multibase
Type types.CIDType
Hash multihash.Multihash
Hash Multihash
Size uint32
}
type args struct {
@ -51,9 +49,9 @@ func TestCID_CopyWith(t *testing.T) {
func TestCID_Equals(t *testing.T) {
type fields struct {
Multibase multibase.Multibase
Multibase Multibase
Type types.CIDType
Hash multihash.Multihash
Hash Multihash
Size uint32
}
type args struct {
@ -84,9 +82,9 @@ func TestCID_Equals(t *testing.T) {
func TestCID_HashCode(t *testing.T) {
type fields struct {
Multibase multibase.Multibase
Multibase Multibase
Type types.CIDType
Hash multihash.Multihash
Hash Multihash
Size uint32
}
tests := []struct {
@ -112,14 +110,14 @@ func TestCID_HashCode(t *testing.T) {
}
/*func TestCID_ToBytes(t *testing.T) {
FromHash(testdata.RawBase58CID)
CIDFromHash(testdata.RawBase58CID)
println(len(testdata.RawCIDBytes))
println(utils.DecodeEndian(testdata.RawCIDBytes[35:]))
return
type fields struct {
Type types.CIDType
Hash multihash.Multihash
Hash Multihash
Size uint32
}
tests := []struct {
@ -131,7 +129,7 @@ func TestCID_HashCode(t *testing.T) {
name: "Bridge CID",
fields: fields{
Type: types.CIDTypeBridge,
Hash: multihash.New(), // Replace with a valid hash value
Hash: NewMultibase(), // Replace with a valid hash value
},
want: , // Replace with the expected byte output for Bridge CID
},
@ -139,7 +137,7 @@ func TestCID_HashCode(t *testing.T) {
name: "Raw CID with Non-Zero Size",
fields: fields{
Type: types.CIDTypeRaw,
Hash: *multihash.New(testdata.RawCIDBytes[1:34]),
Hash: *NewMultibase(testdata.RawCIDBytes[1:34]),
Size: utils.DecodeEndian(testdata.RawCIDBytes[34:]),
},
want: testdata.RawCIDBytes,
@ -169,7 +167,7 @@ func TestCID_HashCode(t *testing.T) {
Hash: tt.fields.Hash,
Size: tt.fields.Size,
}
m := multibase.New(cid)
m := NewMultibase(cid)
cid.Multibase = m
if got := cid.ToBytes(); !reflect.DeepEqual(got, tt.want) {
t.Errorf("ToBytes() = %v, want %v", got, tt.want)
@ -180,9 +178,9 @@ func TestCID_HashCode(t *testing.T) {
func TestCID_ToRegistryCID(t *testing.T) {
type fields struct {
Multibase multibase.Multibase
Multibase Multibase
Type types.CIDType
Hash multihash.Multihash
Hash Multihash
Size uint32
}
tests := []struct {
@ -215,9 +213,9 @@ func TestCID_ToRegistryCID(t *testing.T) {
func TestCID_ToRegistryEntry(t *testing.T) {
type fields struct {
Multibase multibase.Multibase
Multibase Multibase
Type types.CIDType
Hash multihash.Multihash
Hash Multihash
Size uint32
}
tests := []struct {
@ -244,9 +242,9 @@ func TestCID_ToRegistryEntry(t *testing.T) {
func TestCID_ToString(t *testing.T) {
type fields struct {
Multibase multibase.Multibase
Multibase Multibase
Type types.CIDType
Hash multihash.Multihash
Hash Multihash
Size uint32
}
tests := []struct {
@ -279,9 +277,9 @@ func TestCID_ToString(t *testing.T) {
func TestCID_getPrefixBytes(t *testing.T) {
type fields struct {
Multibase multibase.Multibase
Multibase Multibase
Type types.CIDType
Hash multihash.Multihash
Hash Multihash
Size uint32
}
tests := []struct {
@ -326,19 +324,19 @@ func TestDecode(t *testing.T) {
{
name: "Valid Raw Base 58 CID",
args: args{cid: testdata.RawBase58CID},
want: New(types.CIDTypeRaw, *multihash.New(testdata.RawCIDBytes[1:34]), testdata.RawCIDSize),
want: NewCID(types.CIDTypeRaw, *NewMultihash(testdata.RawCIDBytes[1:34]), testdata.RawCIDSize),
wantErr: false,
},
{
name: "Valid Media 58 CID",
args: args{cid: testdata.MediaBase58CID},
want: New(types.CIDTypeMetadataMedia, *multihash.New(testdata.MediaCIDBytes[1:34]), testdata.MediaCIDSize),
want: NewCID(types.CIDTypeMetadataMedia, *NewMultihash(testdata.MediaCIDBytes[1:34]), testdata.MediaCIDSize),
wantErr: false,
},
{
name: "Valid Resolver CID",
args: args{cid: testdata.ResolverBase58CID},
want: New(types.CIDTypeResolver, *multihash.New(testdata.ResolverCIDBytes[1:34]), testdata.ResolverCIDSize),
want: NewCID(types.CIDTypeResolver, *NewMultihash(testdata.ResolverCIDBytes[1:34]), testdata.ResolverCIDSize),
wantErr: false,
},
}
@ -369,31 +367,31 @@ func TestFromBytes(t *testing.T) {
{
name: "Valid Raw Base 58 CID",
args: args{bytes: testdata.RawCIDBytes},
want: New(types.CIDTypeRaw, *multihash.New(testdata.RawCIDBytes[1:34]), testdata.RawCIDSize),
want: NewCID(types.CIDTypeRaw, *NewMultihash(testdata.RawCIDBytes[1:34]), testdata.RawCIDSize),
wantErr: false,
},
{
name: "Valid Media 58 CID",
args: args{bytes: testdata.MediaCIDBytes},
want: New(types.CIDTypeMetadataMedia, *multihash.New(testdata.MediaCIDBytes[1:34]), testdata.MediaCIDSize),
want: NewCID(types.CIDTypeMetadataMedia, *NewMultihash(testdata.MediaCIDBytes[1:34]), testdata.MediaCIDSize),
wantErr: false,
},
{
name: "Valid Resolver CID",
args: args{bytes: testdata.ResolverCIDBytes},
want: New(types.CIDTypeResolver, *multihash.New(testdata.ResolverCIDBytes[1:34]), testdata.ResolverCIDSize),
want: NewCID(types.CIDTypeResolver, *NewMultihash(testdata.ResolverCIDBytes[1:34]), testdata.ResolverCIDSize),
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := FromBytes(tt.args.bytes)
got, err := CIDFromBytes(tt.args.bytes)
if (err != nil) != tt.wantErr {
t.Errorf("FromBytes() error = %v, wantErr %v", err, tt.wantErr)
t.Errorf("CIDFromBytes() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("FromBytes() got = %v, want %v", got, tt.want)
t.Errorf("CIDFromBytes() got = %v, want %v", got, tt.want)
}
})
}
@ -414,31 +412,31 @@ func TestFromHash(t *testing.T) {
{
name: "Valid Raw Base 58 CID",
args: args{bytes: testdata.RawCIDBytes[1:34], size: testdata.RawCIDSize, cidType: types.CIDTypeRaw},
want: New(types.CIDTypeRaw, *multihash.New(testdata.RawCIDBytes[1:34]), testdata.RawCIDSize),
want: NewCID(types.CIDTypeRaw, *NewMultihash(testdata.RawCIDBytes[1:34]), testdata.RawCIDSize),
wantErr: false,
},
{
name: "Valid Media 58 CID",
args: args{bytes: testdata.MediaCIDBytes[1:34], size: testdata.MediaCIDSize, cidType: types.CIDTypeMetadataMedia},
want: New(types.CIDTypeMetadataMedia, *multihash.New(testdata.MediaCIDBytes[1:34]), testdata.MediaCIDSize),
want: NewCID(types.CIDTypeMetadataMedia, *NewMultihash(testdata.MediaCIDBytes[1:34]), testdata.MediaCIDSize),
wantErr: false,
},
{
name: "Valid Resolver CID",
args: args{bytes: testdata.ResolverCIDBytes[1:34], size: testdata.ResolverCIDSize, cidType: types.CIDTypeResolver},
want: New(types.CIDTypeResolver, *multihash.New(testdata.ResolverCIDBytes[1:34]), testdata.ResolverCIDSize),
want: NewCID(types.CIDTypeResolver, *NewMultihash(testdata.ResolverCIDBytes[1:34]), testdata.ResolverCIDSize),
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := FromHash(tt.args.bytes, tt.args.size, tt.args.cidType)
got, err := CIDFromHash(tt.args.bytes, tt.args.size, tt.args.cidType)
if (err != nil) != tt.wantErr {
t.Errorf("FromHash() error = %v, wantErr %v", err, tt.wantErr)
t.Errorf("CIDFromHash() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("FromHash() got = %v, want %v", got, tt.want)
t.Errorf("CIDFromHash() got = %v, want %v", got, tt.want)
}
})
}
@ -457,19 +455,19 @@ func TestFromRegistry(t *testing.T) {
{
name: "Valid Resolver Data",
args: args{bytes: testdata.ResolverDataBytes},
want: New(types.CIDTypeMetadataWebapp, *multihash.New(testdata.ResolverDataBytes[2:35]), testdata.ResolverDataSize),
want: NewCID(types.CIDTypeMetadataWebapp, *NewMultihash(testdata.ResolverDataBytes[2:35]), testdata.ResolverDataSize),
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := FromRegistry(tt.args.bytes)
got, err := CIDFromRegistry(tt.args.bytes)
if (err != nil) != tt.wantErr {
t.Errorf("FromRegistry() error = %v, wantErr %v", err, tt.wantErr)
t.Errorf("CIDFromRegistry() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("FromRegistry() got = %v, want %v", got, tt.want)
t.Errorf("CIDFromRegistry() got = %v, want %v", got, tt.want)
}
})
}

6
cid/multibase/multibase.go → encoding/multibase.go
View File

@ -1,4 +1,4 @@
package multibase
package encoding
import (
"errors"
@ -30,11 +30,11 @@ type Multibase interface {
var _ Multibase = (*multibaseImpl)(nil)
func New(encoder Encoder) Multibase {
func NewMultibase(encoder Encoder) Multibase {
return &multibaseImpl{encoder: encoder}
}
func DecodeString(data string) (bytes []byte, err error) {
func MultibaseDecodeString(data string) (bytes []byte, err error) {
if len(data) == 0 {
return nil, errMultibaseDecodeZeroLength
}

10
cid/multibase/multibase_test.go → encoding/multibase_test.go
View File

@ -1,4 +1,4 @@
package multibase
package encoding
import (
"git.lumeweb.com/LumeWeb/libs5-go/internal/testdata"
@ -17,7 +17,7 @@ func (e *encoder) ToBytes() []byte {
func newEncoder(data []byte) encoder {
e := &encoder{data: data}
m := New(e)
m := NewMultibase(e)
e.Multibase = m
return *e
@ -84,13 +84,13 @@ func TestDecodeString(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
gotBytes, err := DecodeString(tt.args.data)
gotBytes, err := MultibaseDecodeString(tt.args.data)
if (err != nil) != tt.wantErr {
t.Errorf("DecodeString() error = %v, wantErr %v", err, tt.wantErr)
t.Errorf("MultibaseDecodeString() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(gotBytes, tt.wantBytes) {
t.Errorf("DecodeString() gotBytes = %v, want %v", gotBytes, tt.wantBytes)
t.Errorf("MultibaseDecodeString() gotBytes = %v, want %v", gotBytes, tt.wantBytes)
}
})
}

12
multihash/multihash.go → encoding/multihash.go
View File

@ -1,4 +1,4 @@
package multihash
package encoding
import (
"bytes"
@ -21,7 +21,7 @@ type Multihash struct {
FullBytes []byte
}
func New(fullBytes []byte) *Multihash {
func NewMultihash(fullBytes []byte) *Multihash {
return &Multihash{FullBytes: fullBytes}
}
@ -33,7 +33,7 @@ func (m *Multihash) HashBytes() []byte {
return m.FullBytes[1:]
}
func FromBase64Url(hash string) (*Multihash, error) {
func MultihashFromBase64Url(hash string) (*Multihash, error) {
encoder, _ := multibase.EncoderByName("base64url")
encoding, err := getEncoding(hash)
@ -45,7 +45,7 @@ func FromBase64Url(hash string) (*Multihash, error) {
if err != nil {
return nil, err
}
return New(ret), nil
return NewMultihash(ret), nil
}
func (m *Multihash) ToBase64Url() (string, error) {
@ -69,10 +69,6 @@ func (m *Multihash) Equals(other *Multihash) bool {
func (m *Multihash) HashCode() MultihashCode {
return utils.HashCode(m.FullBytes[:4])
return int(m.FullBytes[0]) +
int(m.FullBytes[1])<<8 +
int(m.FullBytes[2])<<16 +
int(m.FullBytes[3])<<24
}
func getEncoding(hash string) (multibase.Encoding, error) {

12
multihash/multihash_test.go → encoding/multihash_test.go
View File

@ -1,4 +1,4 @@
package multihash
package encoding
import (
"git.lumeweb.com/LumeWeb/libs5-go/internal/testdata"
@ -57,13 +57,13 @@ func TestFromBase64Url(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := FromBase64Url(tt.args.hash)
got, err := MultihashFromBase64Url(tt.args.hash)
if (err != nil) != tt.wantErr {
t.Errorf("FromBase64Url() error = %v, wantErr %v", err, tt.wantErr)
t.Errorf("MultihashFromBase64Url() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("FromBase64Url() got = %v, want %v", got, tt.want)
t.Errorf("MultihashFromBase64Url() got = %v, want %v", got, tt.want)
}
})
}
@ -203,8 +203,8 @@ func TestNewMultihash(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := New(tt.args.fullBytes); !reflect.DeepEqual(got, tt.want) {
t.Errorf("New() = %v, want %v", got, tt.want)
if got := NewMultihash(tt.args.fullBytes); !reflect.DeepEqual(got, tt.want) {
t.Errorf("NewMultihash() = %v, want %v", got, tt.want)
}
})
}

8
nodeid/nodeid.go → encoding/nodeid.go
View File

@ -1,4 +1,4 @@
package nodeid
package encoding
import (
"bytes"
@ -16,11 +16,11 @@ type NodeId struct {
Bytes []byte
}
func New(bytes []byte) *NodeId {
func NewNodeId(bytes []byte) *NodeId {
return &NodeId{Bytes: bytes}
}
func Decode(nodeId string) (*NodeId, error) {
func NodeIdDecode(nodeId string) (*NodeId, error) {
encoding, ret, err := multibase.Decode(nodeId)
if err != nil {
return nil, err
@ -30,7 +30,7 @@ func Decode(nodeId string) (*NodeId, error) {
return nil, errorNotBase58BTC
}
return New(ret), nil
return NewNodeId(ret), nil
}
func (nodeId *NodeId) Equals(other interface{}) bool {