Use refs in jsonschema userconfig generator

Author: karimkhaleel

docs/Config.md

@@ -411,6 +411,11 @@ os:
   # window is closed.
   editAtLineAndWait: ""
 
+  # Whether lazygit suspends until an edit process returns
+  # Pointer to bool so that we can distinguish unset (nil) from false.
+  # We're naming this `editInTerminal` for backwards compatibility
+  editInTerminal: false
+
   # For opening a directory in an editor
   openDirInEditor: ""
 

pkg/jsonschema/generate.go

@@ -7,41 +7,73 @@ import (
 	"fmt"
 	"os"
 	"reflect"
+	"strings"
 
 	"github.com/jesseduffield/lazycore/pkg/utils"
 	"github.com/jesseduffield/lazygit/pkg/config"
 	"github.com/karimkhaleel/jsonschema"
+	"github.com/samber/lo"
 )
 
 func GetSchemaDir() string {
 	return utils.GetLazyRootDirectory() + "/schema"
 }
 
-func GenerateSchema() {
+func GenerateSchema() *jsonschema.Schema {
 	schema := customReflect(&config.UserConfig{})
 	obj, _ := json.MarshalIndent(schema, "", "  ")
 	obj = append(obj, '\n')
 
 	if err := os.WriteFile(GetSchemaDir()+"/config.json", obj, 0o644); err != nil {
 		fmt.Println("Error writing to file:", err)
-		return
+		return nil
 	}
+	return schema
+}
+
+func getSubSchema(rootSchema, parentSchema *jsonschema.Schema, key string) *jsonschema.Schema {
+	subSchema, found := parentSchema.Properties.Get(key)
+	if !found {
+		panic(fmt.Sprintf("Failed to find subSchema at %s on parent", key))
+	}
+
+	// This means the schema is defined on the rootSchema's Definitions
+	if subSchema.Ref != "" {
+		key, _ = strings.CutPrefix(subSchema.Ref, "#/$defs/")
+		refSchema := rootSchema.Definitions[key]
+		refSchema.Description = subSchema.Description
+		return refSchema
+	}
+
+	return subSchema
 }
 
 func customReflect(v *config.UserConfig) *jsonschema.Schema {
-	defaultConfig := config.GetDefaultConfig()
-	r := &jsonschema.Reflector{FieldNameTag: "yaml", RequiredFromJSONSchemaTags: true, DoNotReference: true}
+	r := &jsonschema.Reflector{FieldNameTag: "yaml", RequiredFromJSONSchemaTags: true}
 	if err := r.AddGoComments("github.com/jesseduffield/lazygit/pkg/config", "../config"); err != nil {
 		panic(err)
 	}
 	schema := r.Reflect(v)
+	defaultConfig := config.GetDefaultConfig()
+	userConfigSchema := schema.Definitions["UserConfig"]
+
+	defaultValue := reflect.ValueOf(defaultConfig).Elem()
+
+	yamlToFieldNames := lo.Invert(userConfigSchema.OriginalPropertiesMapping)
+
+	for pair := userConfigSchema.Properties.Oldest(); pair != nil; pair = pair.Next() {
+		yamlName := pair.Key
+		fieldName := yamlToFieldNames[yamlName]
 
-	setDefaultVals(defaultConfig, schema)
+		subSchema := getSubSchema(schema, userConfigSchema, yamlName)
+
+		setDefaultVals(schema, subSchema, defaultValue.FieldByName(fieldName).Interface())
+	}
 
 	return schema
 }
 
-func setDefaultVals(defaults any, schema *jsonschema.Schema) {
+func setDefaultVals(rootSchema, schema *jsonschema.Schema, defaults any) {
 	t := reflect.TypeOf(defaults)
 	v := reflect.ValueOf(defaults)
 
@@ -50,6 +82,24 @@ func setDefaultVals(defaults any, schema *jsonschema.Schema) {
 		v = v.Elem()
 	}
 
+	k := t.Kind()
+	_ = k
+
+	switch t.Kind() {
+	case reflect.Bool:
+		schema.Default = v.Bool()
+	case reflect.Int:
+		schema.Default = v.Int()
+	case reflect.String:
+		schema.Default = v.String()
+	default:
+		// Do nothing
+	}
+
+	if t.Kind() != reflect.Struct {
+		return
+	}
+
 	for i := 0; i < t.NumField(); i++ {
 		value := v.Field(i).Interface()
 		parentKey := t.Field(i).Name
@@ -59,13 +109,10 @@ func setDefaultVals(defaults any, schema *jsonschema.Schema) {
 			continue
 		}
 
-		subSchema, ok := schema.Properties.Get(key)
-		if !ok {
-			continue
-		}
+		subSchema := getSubSchema(rootSchema, schema, key)
 
 		if isStruct(value) {
-			setDefaultVals(value, subSchema)
+			setDefaultVals(rootSchema, subSchema, value)
 		} else if !isZeroValue(value) {
 			subSchema.Default = value
 		}

pkg/jsonschema/generate_config_docs.go

@@ -2,14 +2,13 @@ package jsonschema
 
 import (
 	"bytes"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"os"
 	"strings"
 
-	"github.com/iancoleman/orderedmap"
 	"github.com/jesseduffield/lazycore/pkg/utils"
+	"github.com/karimkhaleel/jsonschema"
 	"github.com/samber/lo"
 
 	"gopkg.in/yaml.v3"
@@ -106,16 +105,7 @@ func (n *Node) MarshalYAML() (interface{}, error) {
 		setComment(&keyNode, n.Description)
 	}
 
-	if n.Default != nil {
-		valueNode := yaml.Node{
-			Kind: yaml.ScalarNode,
-		}
-		err := valueNode.Encode(n.Default)
-		if err != nil {
-			return nil, err
-		}
-		node.Content = append(node.Content, &keyNode, &valueNode)
-	} else if len(n.Children) > 0 {
+	if len(n.Children) > 0 {
 		childrenNode := yaml.Node{
 			Kind: yaml.MappingNode,
 		}
@@ -136,60 +126,18 @@ func (n *Node) MarshalYAML() (interface{}, error) {
 			childrenNode.Content = append(childrenNode.Content, childYaml.(*yaml.Node).Content...)
 		}
 		node.Content = append(node.Content, &keyNode, &childrenNode)
-	}
-
-	return &node, nil
-}
-
-func getDescription(v *orderedmap.OrderedMap) string {
-	description, ok := v.Get("description")
-	if !ok {
-		description = ""
-	}
-	return description.(string)
-}
-
-func getDefault(v *orderedmap.OrderedMap) (error, any) {
-	defaultValue, ok := v.Get("default")
-	if ok {
-		return nil, defaultValue
-	}
-
-	dataType, ok := v.Get("type")
-	if ok {
-		dataTypeString := dataType.(string)
-		if dataTypeString == "string" {
-			return nil, ""
+	} else {
+		valueNode := yaml.Node{
+			Kind: yaml.ScalarNode,
 		}
+		err := valueNode.Encode(n.Default)
+		if err != nil {
+			return nil, err
+		}
+		node.Content = append(node.Content, &keyNode, &valueNode)
 	}
 
-	return errors.New("Failed to get default value"), nil
-}
-
-func parseNode(parent *Node, name string, value *orderedmap.OrderedMap) {
-	description := getDescription(value)
-	err, defaultValue := getDefault(value)
-	if err == nil {
-		leaf := &Node{Name: name, Description: description, Default: defaultValue}
-		parent.Children = append(parent.Children, leaf)
-	}
-
-	properties, ok := value.Get("properties")
-	if !ok {
-		return
-	}
-
-	orderedProperties := properties.(orderedmap.OrderedMap)
-
-	node := &Node{Name: name, Description: description}
-	parent.Children = append(parent.Children, node)
-
-	keys := orderedProperties.Keys()
-	for _, name := range keys {
-		value, _ := orderedProperties.Get(name)
-		typedValue := value.(orderedmap.OrderedMap)
-		parseNode(node, name, &typedValue)
-	}
+	return &node, nil
 }
 
 func writeToConfigDocs(config []byte) error {
@@ -222,30 +170,37 @@ func writeToConfigDocs(config []byte) error {
 	return nil
 }
 
-func GenerateConfigDocs() {
-	content, err := os.ReadFile(GetSchemaDir() + "/config.json")
-	if err != nil {
-		panic("Error reading config.json")
+func GenerateConfigDocs(schema *jsonschema.Schema) {
+	rootNode := &Node{
+		Children: make([]*Node, 0),
 	}
 
-	schema := orderedmap.New()
+	userConfigSchema := schema.Definitions["UserConfig"]
+	for pair := userConfigSchema.Properties.Oldest(); pair != nil; pair = pair.Next() {
+		yamlName := pair.Key
+		subSchema := getSubSchema(schema, userConfigSchema, yamlName)
 
-	err = json.Unmarshal(content, &schema)
-	if err != nil {
-		panic("Failed to unmarshal config.json")
-	}
+		if subSchema.Type == "array" {
+			_ = subSchema
+		}
 
-	root, ok := schema.Get("properties")
-	if !ok {
-		panic("properties key not found in schema")
-	}
-	orderedRoot := root.(orderedmap.OrderedMap)
+		// Skip empty objects
+		if subSchema.Type == "object" && subSchema.Properties == nil {
+			continue
+		}
+
+		// Skip empty arrays
+		if isZeroValue(subSchema.Default) && subSchema.Type == "array" {
+			continue
+		}
 
-	rootNode := Node{}
-	for _, name := range orderedRoot.Keys() {
-		value, _ := orderedRoot.Get(name)
-		typedValue := value.(orderedmap.OrderedMap)
-		parseNode(&rootNode, name, &typedValue)
+		node := Node{
+			Name:        pair.Key,
+			Description: subSchema.Description,
+			Default:     getZeroValue(subSchema.Default, subSchema.Type),
+		}
+		recurseOverSchema(schema, subSchema, &node)
+		rootNode.Children = append(rootNode.Children, &node)
 	}
 
 	var buffer bytes.Buffer
@@ -262,8 +217,54 @@ func GenerateConfigDocs() {
 
 	config := prepareMarshalledConfig(buffer)
 
-	err = writeToConfigDocs(config)
+	err := writeToConfigDocs(config)
 	if err != nil {
 		panic(err)
 	}
 }
+
+func recurseOverSchema(rootSchema, schema *jsonschema.Schema, parent *Node) {
+	if schema == nil || schema.Properties == nil || schema.Properties.Len() == 0 {
+		return
+	}
+
+	for pair := schema.Properties.Oldest(); pair != nil; pair = pair.Next() {
+		if pair.Key == "confirmOnQuit" {
+			_ = pair
+		}
+		subSchema := getSubSchema(rootSchema, schema, pair.Key)
+
+		// Skip empty objects
+		if subSchema.Type == "object" && subSchema.Properties == nil {
+			continue
+		}
+
+		// Skip empty arrays
+		if isZeroValue(subSchema.Default) && subSchema.Type == "array" {
+			continue
+		}
+
+		node := Node{
+			Name:        pair.Key,
+			Description: subSchema.Description,
+			Default:     getZeroValue(subSchema.Default, subSchema.Type),
+		}
+		parent.Children = append(parent.Children, &node)
+		recurseOverSchema(rootSchema, subSchema, &node)
+	}
+}
+
+func getZeroValue(val any, t string) any {
+	if !isZeroValue(val) {
+		return val
+	}
+
+	switch t {
+	case "string":
+		return ""
+	case "boolean":
+		return false
+	default:
+		return nil
+	}
+}

pkg/jsonschema/generator.go

@@ -10,6 +10,6 @@ import (
 
 func main() {
 	fmt.Printf("Generating jsonschema in %s...\n", jsonschema.GetSchemaDir())
-	jsonschema.GenerateSchema()
-	jsonschema.GenerateConfigDocs()
+	schema := jsonschema.GenerateSchema()
+	jsonschema.GenerateConfigDocs(schema)
 }