17361003870

Committed 31 Aug 2025 06:44PM UTC coverage: 52.862%. First build

Build # 17361003870

Build Type

Pull #1

github

Committed by

fogfish

Commit Message

update example

Pull Request Pull Request #1: Initial release

Run Details

157 of 297 new or added lines in 7 files covered. (52.86%)

157 of 297 relevant lines covered (52.86%)

0.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/codec.go

//
// Copyright (C) 2025 Dmitry Kolesnikov
//
// This file may be modified and distributed under the terms
// of the MIT license.  See the LICENSE file for details.
// https://github.com/fogfish/gold
//

package gold

import (
        "encoding/json"
        "fmt"
        "strings"

        "github.com/fogfish/golem/optics"
)

type Encoder[T any] interface {
        Encode(*T) (string, error)
}

type Decoder[T any] interface {
        Decode(string, *T) error
}

type Codec[T any] interface {
        Encoder[T]
        Decoder[T]
}

func EncodeJSON(s string, err error) ([]byte, error) {
        if err != nil {
                return nil, err
        }
        return json.Marshal(s)
}

func DecodeJSON(b []byte) (string, error) {
        var s string
        if err := json.Unmarshal(b, &s); err != nil {
                return "", err
        }
        return s, nil
}

//------------------------------------------------------------------------------

type n3[T, A, B any] struct {
        schema string
        shape  optics.Lens2[T, IRI[A], IRI[B]]
}

func N3[T, A, B any]() Codec[T] {
        return n3[T, A, B]{
                schema: Schema[T](),
                shape:  optics.ForShape2[T, IRI[A], IRI[B]](),
        }
}

func (c n3[T, A, B]) Encode(obj *T) (string, error) {
        a, b := c.shape.Get(obj)
        if len(a) == 0 || len(b) == 0 {
                return "", nil
        }

        return fmt.Sprintf("%s %s %s.", a, c.schema, b), nil
}

func (c n3[T, A, B]) Decode(s string, obj *T) error {
        if len(s) == 0 {
                c.shape.Put(obj, ToIRI[A](""), ToIRI[B](""))
                return nil
        }

        if !strings.HasSuffix(s, ".") {
                return fmt.Errorf("gold: invalid n3 format for %q", s)
        }

        seq := strings.SplitN(s[:len(s)-1], " ", 3)
        if len(seq) != 3 || seq[1] != c.schema {
                return fmt.Errorf("gold: invalid schema for %q", s)
        }

        a, err := AsIRI[A](seq[0])
        if err != nil {
                return fmt.Errorf("gold: invalid IRI for %q: %w", seq[0], err)
        }

        b, err := AsIRI[B](seq[2])
        if err != nil {
                return fmt.Errorf("gold: invalid IRI for %q: %w", seq[2], err)
        }

        c.shape.Put(obj, a, b)
        return nil
}

//------------------------------------------------------------------------------

type hashkey[T, A, B any] struct {
        schema string
        shape  optics.Lens2[T, IRI[A], IRI[B]]
}

func HashKey[T, A, B any]() Codec[T] {
        return hashkey[T, A, B]{
                schema: Schema[T](),
                shape:  optics.ForShape2[T, IRI[A], IRI[B]](),
        }
}

func (c hashkey[T, A, B]) Encode(obj *T) (string, error) {
        a, b := c.shape.Get(obj)
        if len(a) == 0 || len(b) == 0 {
                return "", nil
        }
        return fmt.Sprintf("%s|%s", a, b), nil
}

func (c hashkey[T, A, B]) Decode(s string, obj *T) error {
        if len(s) == 0 {
                c.shape.Put(obj, ToIRI[A](""), ToIRI[B](""))
                return nil
        }

        seq := strings.SplitN(s, "|", 2)
        if len(seq) != 2 {
                return fmt.Errorf("gold: invalid schema for %q", s)
        }

        a, err := AsIRI[A](seq[0])
        if err != nil {
                return fmt.Errorf("gold: invalid IRI for %q: %w", seq[0], err)
        }

        b, err := AsIRI[B](seq[1])
        if err != nil {
                return fmt.Errorf("gold: invalid IRI for %q: %w", seq[1], err)
        }

        c.shape.Put(obj, a, b)
        return nil
}

1	//
2	// Copyright (C) 2025 Dmitry Kolesnikov
3	//
4	// This file may be modified and distributed under the terms
5	// of the MIT license. See the LICENSE file for details.
6	// https://github.com/fogfish/gold
7	//
8
9	package gold
10
11	import (
12	"encoding/json"
13	"fmt"
14	"strings"
15
16	"github.com/fogfish/golem/optics"
17	)
18
19	type Encoder[T any] interface {
20	Encode(*T) (string, error)
21	}
22
23	type Decoder[T any] interface {
24	Decode(string, *T) error
25	}
26
27	type Codec[T any] interface {
28	Encoder[T]
29	Decoder[T]
30	}
31
NEW 32	func EncodeJSON(s string, err error) ([]byte, error) {	×
NEW 33	if err != nil {	×
NEW 34	return nil, err	×
NEW 35	}	×
NEW 36	return json.Marshal(s)	×
37	}
38
NEW 39	func DecodeJSON(b []byte) (string, error) {	×
NEW 40	var s string	×
NEW 41	if err := json.Unmarshal(b, &s); err != nil {	×
NEW 42	return "", err	×
NEW 43	}	×
NEW 44	return s, nil	×
45	}
46
47	//------------------------------------------------------------------------------
48
49	type n3[T, A, B any] struct {
50	schema string
51	shape optics.Lens2[T, IRI[A], IRI[B]]
52	}
53
NEW 54	func N3[T, A, B any]() Codec[T] {	×
NEW 55	return n3[T, A, B]{	×
NEW 56	schema: Schema[T](),	×
NEW 57	shape: optics.ForShape2[T, IRI[A], IRI[B]](),	×
NEW 58	}	×
NEW 59	}	×
60
NEW 61	func (c n3[T, A, B]) Encode(obj *T) (string, error) {	×
NEW 62	a, b := c.shape.Get(obj)	×
NEW 63	if len(a) == 0 \|\| len(b) == 0 {	×
NEW 64	return "", nil	×
NEW 65	}	×
66
NEW 67	return fmt.Sprintf("%s %s %s.", a, c.schema, b), nil	×
68	}
69
NEW 70	func (c n3[T, A, B]) Decode(s string, obj *T) error {	×
NEW 71	if len(s) == 0 {	×
NEW 72	c.shape.Put(obj, ToIRI[A](""), ToIRI[B](""))	×
NEW 73	return nil	×
NEW 74	}	×
75
NEW 76	if !strings.HasSuffix(s, ".") {	×
NEW 77	return fmt.Errorf("gold: invalid n3 format for %q", s)	×
NEW 78	}	×
79
NEW 80	seq := strings.SplitN(s[:len(s)-1], " ", 3)	×
NEW 81	if len(seq) != 3 \|\| seq[1] != c.schema {	×
NEW 82	return fmt.Errorf("gold: invalid schema for %q", s)	×
NEW 83	}	×
84
NEW 85	a, err := AsIRI[A](seq[0])	×
NEW 86	if err != nil {	×
NEW 87	return fmt.Errorf("gold: invalid IRI for %q: %w", seq[0], err)	×
NEW 88	}	×
89
NEW 90	b, err := AsIRI[B](seq[2])	×
NEW 91	if err != nil {	×
NEW 92	return fmt.Errorf("gold: invalid IRI for %q: %w", seq[2], err)	×
NEW 93	}	×
94
NEW 95	c.shape.Put(obj, a, b)	×
NEW 96	return nil	×
97	}
98
99	//------------------------------------------------------------------------------
100
101	type hashkey[T, A, B any] struct {
102	schema string
103	shape optics.Lens2[T, IRI[A], IRI[B]]
104	}
105
NEW 106	func HashKey[T, A, B any]() Codec[T] {	×
NEW 107	return hashkey[T, A, B]{	×
NEW 108	schema: Schema[T](),	×
NEW 109	shape: optics.ForShape2[T, IRI[A], IRI[B]](),	×
NEW 110	}	×
NEW 111	}	×
112
NEW 113	func (c hashkey[T, A, B]) Encode(obj *T) (string, error) {	×
NEW 114	a, b := c.shape.Get(obj)	×
NEW 115	if len(a) == 0 \|\| len(b) == 0 {	×
NEW 116	return "", nil	×
NEW 117	}	×
NEW 118	return fmt.Sprintf("%s\|%s", a, b), nil	×
119	}
120
NEW 121	func (c hashkey[T, A, B]) Decode(s string, obj *T) error {	×
NEW 122	if len(s) == 0 {	×
NEW 123	c.shape.Put(obj, ToIRI[A](""), ToIRI[B](""))	×
NEW 124	return nil	×
NEW 125	}	×
126
NEW 127	seq := strings.SplitN(s, "\|", 2)	×
NEW 128	if len(seq) != 2 {	×
NEW 129	return fmt.Errorf("gold: invalid schema for %q", s)	×
NEW 130	}	×
131
NEW 132	a, err := AsIRI[A](seq[0])	×
NEW 133	if err != nil {	×
NEW 134	return fmt.Errorf("gold: invalid IRI for %q: %w", seq[0], err)	×
NEW 135	}	×
136
NEW 137	b, err := AsIRI[B](seq[1])	×
NEW 138	if err != nil {	×
NEW 139	return fmt.Errorf("gold: invalid IRI for %q: %w", seq[1], err)	×
NEW 140	}	×
141
NEW 142	c.shape.Put(obj, a, b)	×
NEW 143	return nil	×
144	}

fogfish / gold / 17361003870

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous