[1/3] subgroups

Makefile

@@ -181,6 +181,7 @@ endif
 
 SWAGGER_SPEC := templates/swagger/v1_json.tmpl
 SWAGGER_SPEC_INPUT := templates/swagger/v1_input.json
+SWAGGER_SPEC_GROUP_INPUT := templates/swagger/v1_groups.json
 SWAGGER_EXCLUDE := code.gitea.io/sdk
 
 TEST_MYSQL_HOST ?= mysql:3306
@@ -293,6 +294,8 @@ generate-swagger: $(SWAGGER_SPEC) ## generate the swagger spec from code comment
 
 $(SWAGGER_SPEC): $(GO_SOURCES) $(SWAGGER_SPEC_INPUT)
 	$(GO) run $(SWAGGER_PACKAGE) generate spec --exclude "$(SWAGGER_EXCLUDE)" --input "$(SWAGGER_SPEC_INPUT)" --output './$(SWAGGER_SPEC)'
+	$(GO) generate -v ./build_tools/...
+	$(GO) run $(SWAGGER_PACKAGE) mixin -o './$(SWAGGER_SPEC)' $(SWAGGER_SPEC) $(SWAGGER_SPEC_GROUP_INPUT)
 
 .PHONY: swagger-check
 swagger-check: generate-swagger

build_tools/swagger/main.go

@@ -0,0 +1,306 @@
+// Copyright 2025 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//go:generate go run main.go ../../
+
+package main
+
+import (
+	"bytes"
+	encjson "encoding/json" //nolint:depguard // this package wraps it
+	"errors"
+	"fmt"
+	"iter"
+	"log"
+	"os"
+	"path/filepath"
+	"regexp"
+
+	"code.gitea.io/gitea/modules/json"
+)
+
+type Pair struct {
+	Key   string
+	Value any
+}
+
+type OrderedMap struct {
+	Pairs   []Pair
+	indices map[string]int
+}
+
+func (o OrderedMap) Get(key string) (any, bool) {
+	if _, ok := o.indices[key]; ok {
+		return o.Pairs[o.indices[key]].Value, true
+	}
+	return nil, false
+}
+
+func (o *OrderedMap) Set(key string, value any) {
+	if _, ok := o.indices[key]; ok {
+		o.Pairs[o.indices[key]] = Pair{key, value}
+	} else {
+		o.Pairs = append(o.Pairs, Pair{key, value})
+		o.indices[key] = len(o.Pairs) - 1
+	}
+}
+
+func (o OrderedMap) Iter() iter.Seq2[string, any] {
+	return func(yield func(string, any) bool) {
+		for _, it := range o.Pairs {
+			yield(it.Key, it.Value)
+		}
+	}
+}
+
+func (o *OrderedMap) UnmarshalJSON(data []byte) error {
+	trimmed := bytes.TrimSpace(data)
+	if bytes.Equal(trimmed, []byte("null")) {
+		o.Pairs = nil
+		o.indices = nil
+		return nil
+	}
+
+	dec := encjson.NewDecoder(bytes.NewReader(data))
+	dec.UseNumber()
+
+	tok, err := dec.Token()
+	if err != nil {
+		return err
+	}
+	delim, ok := tok.(encjson.Delim)
+	if !ok || delim != '{' {
+		return errors.New("OrderedMap: expected '{' at start of object")
+	}
+
+	// Reset storage
+	if o.indices == nil {
+		o.indices = make(map[string]int)
+	} else {
+		for k := range o.indices {
+			delete(o.indices, k)
+		}
+	}
+	o.Pairs = o.Pairs[:0]
+
+	for dec.More() {
+		tk, err := dec.Token()
+		if err != nil {
+			return err
+		}
+		key, ok := tk.(string)
+		if !ok {
+			return fmt.Errorf(
+				"OrderedMap: expected string key, got %T (%v)",
+				tk,
+				tk,
+			)
+		}
+
+		var raw encjson.RawMessage
+		if err := dec.Decode(&raw); err != nil {
+			return fmt.Errorf("OrderedMap: decode value for %q: %w", key, err)
+		}
+
+		val, err := decodeJSONValue(raw)
+		if err != nil {
+			return fmt.Errorf("OrderedMap: unmarshal value for %q: %w", key, err)
+		}
+
+		if idx, exists := o.indices[key]; exists {
+			o.Pairs[idx].Value = val
+		} else {
+			o.indices[key] = len(o.Pairs)
+			o.Pairs = append(o.Pairs, Pair{Key: key, Value: val})
+		}
+	}
+
+	end, err := dec.Token()
+	if err != nil {
+		return err
+	}
+	if d, ok := end.(encjson.Delim); !ok || d != '}' {
+		return errors.New("OrderedMap: expected '}' at end of object")
+	}
+
+	return nil
+}
+
+func decodeJSONValue(raw encjson.RawMessage) (any, error) {
+	t := bytes.TrimSpace(raw)
+	if bytes.Equal(t, []byte("null")) {
+		return nil, nil
+	}
+
+	d := encjson.NewDecoder(bytes.NewReader(raw))
+	d.UseNumber()
+
+	tok, err := d.Token()
+	if err != nil {
+		return nil, err
+	}
+
+	switch tt := tok.(type) {
+	case encjson.Delim:
+		switch tt {
+		case '{':
+			var inner OrderedMap
+			if err := inner.UnmarshalJSON(raw); err != nil {
+				return nil, err
+			}
+			return inner, nil
+		case '[':
+			var arr []any
+			for d.More() {
+				var elemRaw encjson.RawMessage
+				if err := d.Decode(&elemRaw); err != nil {
+					return nil, err
+				}
+				v, err := decodeJSONValue(elemRaw)
+				if err != nil {
+					return nil, err
+				}
+				arr = append(arr, v)
+			}
+			if end, err := d.Token(); err != nil {
+				return nil, err
+			} else if end != encjson.Delim(']') {
+				return nil, errors.New("expected ']'")
+			}
+			return arr, nil
+		default:
+			return nil, fmt.Errorf("unexpected delimiter %q", tt)
+		}
+	default:
+		var v any
+		d = encjson.NewDecoder(bytes.NewReader(raw))
+		d.UseNumber()
+		if err := d.Decode(&v); err != nil {
+			return nil, err
+		}
+		return v, nil
+	}
+}
+
+func (o OrderedMap) MarshalJSON() ([]byte, error) {
+	var buf bytes.Buffer
+
+	buf.WriteString("{")
+	for i, kv := range o.Pairs {
+		if i != 0 {
+			buf.WriteString(",")
+		}
+		key, err := json.Marshal(kv.Key)
+		if err != nil {
+			return nil, err
+		}
+		buf.Write(key)
+		buf.WriteString(":")
+		val, err := json.Marshal(kv.Value)
+		if err != nil {
+			return nil, err
+		}
+		buf.Write(val)
+	}
+
+	buf.WriteString("}")
+	return buf.Bytes(), nil
+}
+
+var rxPath = regexp.MustCompile(`(?m)^(/repos/\{owner})/(\{repo})`)
+
+func generatePaths(root string) *OrderedMap {
+	pathData := &OrderedMap{
+		indices: make(map[string]int),
+	}
+	endpoints := &OrderedMap{
+		indices: make(map[string]int),
+	}
+	fileToRead, err := filepath.Rel(root, "./templates/swagger/v1_json.tmpl")
+	if err != nil {
+		log.Fatal(err)
+	}
+	swaggerBytes, err := os.ReadFile(fileToRead)
+	if err != nil {
+		log.Fatal(err)
+	}
+	raw := OrderedMap{
+		indices: make(map[string]int),
+	}
+	err = json.Unmarshal(swaggerBytes, &raw)
+	if err != nil {
+		log.Fatal(err)
+	}
+	rpaths, has := raw.Get("paths")
+	if !has {
+		log.Fatal("paths not found")
+	}
+	paths := rpaths.(OrderedMap)
+	for k, v := range paths.Iter() {
+		if !rxPath.MatchString(k) {
+			// skip if this endpoint does not start with `/repos/{owner}/{repo}`
+			continue
+		}
+		// generate new endpoint path with `/group/{group_id}` in between the `owner` and `repo` params
+		nk := rxPath.ReplaceAllString(k, "$1/group/{group_id}/$2")
+		methodMap := v.(OrderedMap)
+
+		for method, methodSpec := range methodMap.Iter() {
+			specMap := methodSpec.(OrderedMap)
+			var params []OrderedMap
+			aparams, has := specMap.Get("parameters")
+			if !has {
+				continue
+			}
+			rparams := aparams.([]any)
+			for _, rparam := range rparams {
+				params = append(params, rparam.(OrderedMap))
+			}
+			param := OrderedMap{
+				indices: make(map[string]int),
+			}
+			param.Set("description", "group ID of the repo")
+			param.Set("name", "group_id")
+			param.Set("type", "integer")
+			param.Set("format", "int64")
+			param.Set("required", true)
+			param.Set("in", "path")
+			params = append(params, param)
+			// i believe for...range loops create copies of each item that's iterated over,
+			// so we need to take extra care to ensure we're mutating the original map entry
+			specMap.Set("parameters", params)
+			methodMap.Set(method, specMap)
+			//(methodMap[method].(map[string]any))["parameters"] = params
+		}
+		endpoints.Set(nk, methodMap)
+	}
+	pathData.Set("paths", endpoints)
+	return pathData
+}
+
+func writeMapToFile(filename string, data *OrderedMap) {
+	bytes, err := json.MarshalIndent(data, "", "  ")
+	if err != nil {
+		log.Fatal(err)
+	}
+	bytes = append(bytes, '\n')
+	err = os.WriteFile(filename, bytes, 0o666)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func main() {
+	var err error
+	root := "../../"
+	if len(os.Args) > 1 {
+		root = os.Args[1]
+	}
+	err = os.Chdir(root)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	pathData := generatePaths(".")
+	out := "./templates/swagger/v1_groups.json"
+	writeMapToFile(out, pathData)
+}