mirror of
https://github.com/hanzoai/forge.git
synced 2026-10-30 15:00:39 +00:00
zeekayandHanzo Dev
27cde39e36
Storage buckets, indexer names, the bleve analyzer, the lock prefix, SSH host keys, the markdown front-matter key, the container data paths, the RPM repo id and the API security scheme all read as this product now, and app.example.ini matches the code again. The upstream maintainer list and the changelog generator config went with the release history they belonged to, and the citation comments state the fact rather than link the issue. Three inert rules turn out to have been inert because they named a module path this tree does not use: gci grouped no first-party imports under prefix(), and depguard let models/migrations import models and modules/structs. They now name github.com/hanzoai/git. The config example also documented .gitea/workflows while the code has read .hanzo/workflows for some time. The authorized_keys marker follows the delegate-hook precedent: the new name is written and the old one is still recognised, because a marker we do not know is copied through as a hand-added key and leaves a revoked key authorized. The stored user_setting key keeps its value; only a migration may change that. Co-authored-by: Hanzo Dev <[email protected]>
112 lines
2.8 KiB
Go
112 lines
2.8 KiB
Go
// Copyright 2026 Hanzo AI, Inc. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package json
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"encoding/json" //nolint:depguard // this package wraps it
|
|
"io"
|
|
)
|
|
|
|
// Encoder represents an encoder for json
|
|
type Encoder interface {
|
|
Encode(v any) error
|
|
}
|
|
|
|
// Decoder represents a decoder for json
|
|
type Decoder interface {
|
|
Decode(v any) error
|
|
}
|
|
|
|
// Interface represents an interface to handle json data
|
|
type Interface interface {
|
|
Marshal(v any) ([]byte, error)
|
|
Unmarshal(data []byte, v any) error
|
|
NewEncoder(writer io.Writer) Encoder
|
|
NewDecoder(reader io.Reader) Decoder
|
|
Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error
|
|
}
|
|
|
|
var DefaultJSONHandler = getDefaultJSONHandler()
|
|
|
|
// Marshal converts object as bytes
|
|
func Marshal(v any) ([]byte, error) {
|
|
return DefaultJSONHandler.Marshal(v)
|
|
}
|
|
|
|
// Unmarshal decodes object from bytes
|
|
func Unmarshal(data []byte, v any) error {
|
|
return DefaultJSONHandler.Unmarshal(data, v)
|
|
}
|
|
|
|
// NewEncoder creates an encoder to write objects to writer
|
|
func NewEncoder(writer io.Writer) Encoder {
|
|
return DefaultJSONHandler.NewEncoder(writer)
|
|
}
|
|
|
|
// NewDecoder creates a decoder to read objects from reader
|
|
func NewDecoder(reader io.Reader) Decoder {
|
|
return DefaultJSONHandler.NewDecoder(reader)
|
|
}
|
|
|
|
// Indent appends to dst an indented form of the JSON-encoded src.
|
|
func Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error {
|
|
return DefaultJSONHandler.Indent(dst, src, prefix, indent)
|
|
}
|
|
|
|
// MarshalIndent copied from encoding/json
|
|
func MarshalIndent(v any, prefix, indent string) ([]byte, error) {
|
|
b, err := Marshal(v)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var buf bytes.Buffer
|
|
err = Indent(&buf, b, prefix, indent)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
|
|
// Valid proxy to json.Valid
|
|
func Valid(data []byte) bool {
|
|
return json.Valid(data)
|
|
}
|
|
|
|
// UnmarshalHandleDoubleEncode - xorm can hand us a value that was JSON-encoded twice, so it's
|
|
// possible that a Blob may be double encoded or gain an unwanted prefix of 0xff 0xfe.
|
|
func UnmarshalHandleDoubleEncode(bs []byte, v any) error {
|
|
if len(bs) == 0 {
|
|
// json.Unmarshal will report errors if input is empty (nil or zero-length)
|
|
// It seems that XORM ignores the nil but still passes zero-length string into this function
|
|
// To be consistent, we should treat all empty inputs as success
|
|
return nil
|
|
}
|
|
err := json.Unmarshal(bs, v)
|
|
if err != nil {
|
|
ok := true
|
|
rs := []byte{}
|
|
temp := make([]byte, 2)
|
|
for _, rn := range string(bs) {
|
|
if rn > 0xffff {
|
|
ok = false
|
|
break
|
|
}
|
|
binary.LittleEndian.PutUint16(temp, uint16(rn))
|
|
rs = append(rs, temp...)
|
|
}
|
|
if ok {
|
|
if len(rs) > 1 && rs[0] == 0xff && rs[1] == 0xfe {
|
|
rs = rs[2:]
|
|
}
|
|
err = json.Unmarshal(rs, v)
|
|
}
|
|
}
|
|
if err != nil && len(bs) > 2 && bs[0] == 0xff && bs[1] == 0xfe {
|
|
err = json.Unmarshal(bs[2:], v)
|
|
}
|
|
return err
|
|
}
|