25871013592

Committed 14 May 2026 04:08PM UTC coverage: 47.432% (-5.4%) from 52.862%

Build # 25871013592

Build Type

Pull #2

github

Committed by

fogfish

Commit Message

(fix) allow partial imply for sortkey

Pull Request Pull Request #2: (fix) allow partial imply for sortkey

Coverage Stats

0 of 34 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

157 of 331 relevant lines covered (47.43%)

0.54 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
}

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

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

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

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

        if len(b) == 0 {
                return string(a), nil
        }

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

func (c sortkey[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
32	func EncodeJSON(s string, err error) ([]byte, error) {	×
33	if err != nil {	×
34	return nil, err	×
35	}	×
36	return json.Marshal(s)	×
37	}
38
39	func DecodeJSON(b []byte) (string, error) {	×
40	var s string	×
41	if err := json.Unmarshal(b, &s); err != nil {	×
42	return "", err	×
43	}	×
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
54	func N3[T, A, B any]() Codec[T] {	×
55	return n3[T, A, B]{	×
56	schema: Schema[T](),	×
57	shape: optics.ForShape2[T, IRI[A], IRI[B]](),	×
58	}	×
59	}	×
60
61	func (c n3[T, A, B]) Encode(obj *T) (string, error) {	×
62	a, b := c.shape.Get(obj)	×
63	if len(a) == 0 \|\| len(b) == 0 {	×
64	return "", nil	×
65	}	×
66
67	return fmt.Sprintf("%s %s %s.", a, c.schema, b), nil	×
68	}
69
70	func (c n3[T, A, B]) Decode(s string, obj *T) error {	×
71	if len(s) == 0 {	×
72	c.shape.Put(obj, ToIRI[A](""), ToIRI[B](""))	×
73	return nil	×
74	}	×
75
76	if !strings.HasSuffix(s, ".") {	×
77	return fmt.Errorf("gold: invalid n3 format for %q", s)	×
78	}	×
79
80	seq := strings.SplitN(s[:len(s)-1], " ", 3)	×
81	if len(seq) != 3 \|\| seq[1] != c.schema {	×
82	return fmt.Errorf("gold: invalid schema for %q", s)	×
83	}	×
84
85	a, err := AsIRI[A](seq[0])	×
86	if err != nil {	×
87	return fmt.Errorf("gold: invalid IRI for %q: %w", seq[0], err)	×
88	}	×
89
90	b, err := AsIRI[B](seq[2])	×
91	if err != nil {	×
92	return fmt.Errorf("gold: invalid IRI for %q: %w", seq[2], err)	×
93	}	×
94
95	c.shape.Put(obj, a, b)	×
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
106	func HashKey[T, A, B any]() Codec[T] {	×
107	return hashkey[T, A, B]{	×
108	schema: Schema[T](),	×
109	shape: optics.ForShape2[T, IRI[A], IRI[B]](),	×
110	}	×
111	}	×
112
113	func (c hashkey[T, A, B]) Encode(obj *T) (string, error) {	×
114	a, b := c.shape.Get(obj)	×
115	if len(a) == 0 \|\| len(b) == 0 {	×
116	return "", nil	×
117	}	×
118
UNCOV 119	return fmt.Sprintf("%s\|%s", a, b), nil	×
120	}
121
122	func (c hashkey[T, A, B]) Decode(s string, obj *T) error {	×
123	if len(s) == 0 {	×
124	c.shape.Put(obj, ToIRI[A](""), ToIRI[B](""))	×
125	return nil	×
126	}	×
127
128	seq := strings.SplitN(s, "\|", 2)	×
129	if len(seq) != 2 {	×
130	return fmt.Errorf("gold: invalid schema for %q", s)	×
131	}	×
132
133	a, err := AsIRI[A](seq[0])	×
134	if err != nil {	×
135	return fmt.Errorf("gold: invalid IRI for %q: %w", seq[0], err)	×
136	}	×
137
138	b, err := AsIRI[B](seq[1])	×
139	if err != nil {	×
140	return fmt.Errorf("gold: invalid IRI for %q: %w", seq[1], err)	×
141	}	×
142
143	c.shape.Put(obj, a, b)	×
144	return nil	×
145	}
146
147	//------------------------------------------------------------------------------
148
149	type sortkey[T, A, B any] struct {
150	schema string
151	shape optics.Lens2[T, IRI[A], IRI[B]]
152	}
153
NEW 154	func SortKey[T, A, B any]() Codec[T] {	×
NEW 155	return sortkey[T, A, B]{	×
NEW 156	schema: Schema[T](),	×
NEW 157	shape: optics.ForShape2[T, IRI[A], IRI[B]](),	×
NEW 158	}	×
NEW 159	}	×
160
NEW 161	func (c sortkey[T, A, B]) Encode(obj *T) (string, error) {	×
NEW 162	a, b := c.shape.Get(obj)	×
NEW 163	if len(a) == 0 && len(b) == 0 {	×
NEW 164	return "", nil	×
NEW 165	}	×
166
NEW 167	if len(b) == 0 {	×
NEW 168	return string(a), nil	×
NEW 169	}	×
170
NEW 171	return fmt.Sprintf("%s\|%s", a, b), nil	×
172	}
173
NEW 174	func (c sortkey[T, A, B]) Decode(s string, obj *T) error {	×
NEW 175	if len(s) == 0 {	×
NEW 176	c.shape.Put(obj, ToIRI[A](""), ToIRI[B](""))	×
NEW 177	return nil	×
NEW 178	}	×
179
NEW 180	seq := strings.SplitN(s, "\|", 2)	×
NEW 181	if len(seq) != 2 {	×
NEW 182	return fmt.Errorf("gold: invalid schema for %q", s)	×
NEW 183	}	×
184
NEW 185	a, err := AsIRI[A](seq[0])	×
NEW 186	if err != nil {	×
NEW 187	return fmt.Errorf("gold: invalid IRI for %q: %w", seq[0], err)	×
NEW 188	}	×
189
NEW 190	b, err := AsIRI[B](seq[1])	×
NEW 191	if err != nil {	×
NEW 192	return fmt.Errorf("gold: invalid IRI for %q: %w", seq[1], err)	×
NEW 193	}	×
194
NEW 195	c.shape.Put(obj, a, b)	×
NEW 196	return nil	×
197	}

fogfish / gold / 25871013592

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