docs: add component chart reference

Author: LukasGentele

docs/hack/config/partials/main.go

@@ -1,281 +1,20 @@
 package main
 
 import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"sort"
-	"strconv"
-	"strings"
-
-	"github.com/gertd/go-pluralize"
-	"github.com/invopop/jsonschema"
 	"github.com/loft-sh/devspace/docs/hack/util"
-	"github.com/loft-sh/devspace/pkg/devspace/config/versions"
 	"github.com/loft-sh/devspace/pkg/devspace/config/versions/latest"
 )
 
 const configPartialBasePath = "docs/pages/configuration/_partials/"
-const nameFieldName = "name"
-const versionFieldName = "version"
-const groupKey = "group"
-const groupNameKey = "group_name"
-const prefixSeparator = "/"
-const anchorSeparator = "-"
-
-var pluralizeClient = pluralize.NewClient()
 
 func main() {
-	r := new(jsonschema.Reflector)
-	r.AllowAdditionalProperties = true
-	r.PreferYAMLSchema = true
-	r.RequiredFromJSONSchemaTags = true
-	r.YAMLEmbeddedStructs = false
-	r.ExpandedStruct = true
-
-	err := r.AddGoComments("github.com/loft-sh/devspace", "./pkg/devspace/config/versions/latest")
-	if err != nil {
-		panic(err)
-	}
-
-	schema := r.Reflect(&latest.Config{})
-
-	versionField, ok := schema.Properties.Get(versionFieldName)
-	if ok {
-		if fieldSchema, ok := versionField.(*jsonschema.Schema); ok {
-			versionEnum := []string{}
-			for version := range versions.VersionLoader {
-				versionEnum = append(versionEnum, version)
-			}
-
-			sort.SliceStable(versionEnum, func(a, b int) bool {
-				majorA, _ := strconv.Atoi(string(versionEnum[a][1]))
-				majorB, _ := strconv.Atoi(string(versionEnum[b][1]))
-				minorA, _ := strconv.Atoi(string(versionEnum[a][6:]))
-				minorB, _ := strconv.Atoi(string(versionEnum[b][6:]))
-
-				if majorA == majorB {
-					return minorA > minorB
-				} else {
-					return majorA > majorB
-				}
-			})
-
-			fieldSchema.Enum = []interface{}{}
-			for _, version := range versionEnum {
-				fieldSchema.Enum = append(fieldSchema.Enum, version)
-			}
-		}
-	}
-
-	createSections("", schema, schema.Definitions, 1, false)
-}
-
-func createSections(prefix string, schema *jsonschema.Schema, definitions jsonschema.Definitions, depth int, parentIsNameObjectMap bool) string {
-	partialImports := &[]string{}
-	content := ""
-	headlinePrefix := strings.Repeat("#", depth+1) + " "
-	anchorPrefix := strings.TrimPrefix(strings.ReplaceAll(prefix, prefixSeparator, anchorSeparator), anchorSeparator)
-
-	groups := map[string]*util.Group{}
-
-	for _, fieldName := range schema.Properties.Keys() {
-		if parentIsNameObjectMap && fieldName == nameFieldName {
-			continue
-		}
-
-		field, ok := schema.Properties.Get(fieldName)
-		if ok {
-			if fieldSchema, ok := field.(*jsonschema.Schema); ok {
-				fieldContent := ""
-				fieldFile := fmt.Sprintf(configPartialBasePath+"%s/%s%s.mdx", latest.Version, prefix, fieldName)
-				fieldType := "object"
-				isNameObjectMap := false
-				groupID, _ := fieldSchema.Extras[groupKey].(string)
-
-				var patternPropertySchema *jsonschema.Schema
-				var nestedSchema *jsonschema.Schema
-
-				ref := ""
-				if fieldSchema.Type == "array" {
-					ref = fieldSchema.Items.Ref
-					fieldType = "object[]"
-				} else if patternPropertySchema, ok = fieldSchema.PatternProperties[".*"]; ok {
-					ref = patternPropertySchema.Ref
-					isNameObjectMap = true
-				} else if fieldSchema.Ref != "" {
-					ref = fieldSchema.Ref
-				}
-
-				if ref != "" {
-					refSplit := strings.Split(ref, "/")
-					nestedSchema, ok = definitions[refSplit[len(refSplit)-1]]
-
-					if ok {
-						newPrefix := prefix + fieldName + prefixSeparator
-						createSections(newPrefix, nestedSchema, definitions, depth+1, isNameObjectMap)
-					}
-				} else {
-					required := contains(schema.Required, fieldName)
-					fieldDefault := ""
-
-					fieldType = fieldSchema.Type
-					if fieldType == "" && fieldSchema.OneOf != nil {
-						for _, oneOfType := range fieldSchema.OneOf {
-							if fieldType != "" {
-								fieldType = fieldType + "|"
-							}
-							fieldType = fieldType + oneOfType.Type
-						}
-					}
-
-					if isNameObjectMap {
-						fieldNameSingular := pluralizeClient.Singular(fieldName)
-						fieldType = "<" + fieldNameSingular + "_name>:"
-
-						if patternPropertySchema != nil && patternPropertySchema.Type != "" {
-							fieldType = fieldType + patternPropertySchema.Type
-						} else {
-							fieldType = fieldType + "object"
-						}
-					}
-
-					if fieldType == "array" {
-						fieldType = fieldSchema.Items.Type + "[]"
-					}
-
-					if fieldType == "boolean" {
-						fieldDefault = "false"
-						if required {
-							fieldDefault = "true"
-							required = false
-						}
-					} else {
-						fieldDefault, ok = fieldSchema.Default.(string)
-						if !ok {
-							fieldDefault = ""
-						}
-					}
+	repository := "github.com/loft-sh/devspace"
+	configGoPackage := "./pkg/devspace/config/versions/latest"
+	versionedConfigBasePath := configPartialBasePath + latest.Version + "/"
 
-					enumValues := GetEumValues(fieldSchema, required, &fieldDefault)
-
-					anchorName := anchorPrefix + fieldName
-					fieldContent = fmt.Sprintf(util.TemplateConfigField, false, " open", headlinePrefix, fieldName, required, fieldType, fieldDefault, enumValues, anchorName, fieldSchema.Description, "")
-
-					err := os.MkdirAll(filepath.Dir(fieldFile), os.ModePerm)
-					if err != nil {
-						panic(err)
-					}
-
-					err = ioutil.WriteFile(fieldFile, []byte(fieldContent), os.ModePerm)
-					if err != nil {
-						panic(err)
-					}
-				}
-
-				fieldPartial := fmt.Sprintf(util.TemplatePartialUse, util.GetPartialImportName(fieldFile))
-				if ref != "" {
-					if isNameObjectMap && nestedSchema != nil {
-						nameField, ok := nestedSchema.Properties.Get(nameFieldName)
-						if ok {
-							if nameFieldSchema, ok := nameField.(*jsonschema.Schema); ok {
-								fieldNameSingular := pluralizeClient.Singular(fieldName)
-								nameFieldRequired := true
-								nameFieldDefault := ""
-								nameFieldEnumValues := GetEumValues(nameFieldSchema, nameFieldRequired, &nameFieldDefault)
-
-								anchorName := anchorPrefix + nameFieldName
-								fieldPartial = fmt.Sprintf(util.TemplateConfigField, true, "open", headlinePrefix, "<"+fieldNameSingular+"_"+nameFieldName+">", nameFieldRequired, "string", nameFieldDefault, nameFieldEnumValues, anchorName, nameFieldSchema.Description, fieldPartial)
-								fieldType = "&lt;" + fieldNameSingular + "_name&gt;:object"
-							}
-						}
-					}
-
-					anchorName := anchorPrefix + fieldName
-					fieldPartial = fmt.Sprintf(util.TemplateConfigField, true, "", headlinePrefix, fieldName, false, fieldType, "", "", anchorName, fieldSchema.Description, fieldPartial)
-				}
-
-				if groupID != "" {
-					group, ok := groups[groupID]
-					if !ok {
-						group = &util.Group{
-							File:    fmt.Sprintf(configPartialBasePath+"%s/%sgroup_%s.mdx", latest.Version, prefix, groupID),
-							Imports: &[]string{},
-						}
-						groups[groupID] = group
-
-						groupPartial := fmt.Sprintf(util.TemplatePartialUse, util.GetPartialImportName(group.File))
-
-						content = content + "\n\n" + groupPartial
-						*partialImports = append(*partialImports, group.File)
-					}
-
-					if groupName, ok := fieldSchema.Extras[groupNameKey]; ok {
-						group.Name = groupName.(string)
-					}
-
-					group.Content = group.Content + fieldPartial
-					*group.Imports = append(*group.Imports, fieldFile)
-				} else {
-					content = content + "\n\n" + fieldPartial
-					*partialImports = append(*partialImports, fieldFile)
-				}
-			}
-		}
-	}
-
-	util.ProcessGroups(groups)
-
-	if prefix == "" {
-		prefix = "reference"
-	}
-
-	pageFile := fmt.Sprintf(configPartialBasePath+"%s/%s.mdx", latest.Version, strings.TrimSuffix(prefix, "/"))
-
-	importContent := ""
-	for _, partialFile := range *partialImports {
-		importContent = importContent + util.GetPartialImport(partialFile, pageFile)
-	}
-
-	content = fmt.Sprintf("%s%s", importContent, content)
-
-	err := ioutil.WriteFile(pageFile, []byte(content), os.ModePerm)
-	if err != nil {
-		panic(err)
-	}
-
-	//fmt.Println(content)
-
-	return content
-}
-
-func GetEumValues(fieldSchema *jsonschema.Schema, required bool, fieldDefault *string) string {
-	enumValues := ""
-	if fieldSchema.Enum != nil {
-		for i, enumVal := range fieldSchema.Enum {
-			enumValString, ok := enumVal.(string)
-			if ok {
-				if i == 0 && !required && *fieldDefault == "" {
-					*fieldDefault = enumValString
-				}
-
-				if enumValues != "" {
-					enumValues = enumValues + "<br/>"
-				}
-				enumValues = enumValues + enumValString
-			}
-		}
-		enumValues = fmt.Sprintf("<span>%s</span>", enumValues)
-	}
-	return enumValues
-}
+	schema := util.GenerateSchema(latest.Config{}, repository, configGoPackage)
+	util.GenerateReference(schema, versionedConfigBasePath)
 
-func contains(s []string, e string) bool {
-	for _, a := range s {
-		if a == e {
-			return true
-		}
-	}
-	return false
+	schema = util.GenerateSchema(latest.ComponentConfig{}, repository, configGoPackage)
+	util.GenerateReference(schema, versionedConfigBasePath+"deployments/helm/componentChart/")
 }

docs/hack/functions/main.go

@@ -249,6 +249,14 @@ var Functions = []Function{
 		Flags:       commands.RunDependencyPipelinesOptions{},
 		Group:       groupPipelines,
 	},
+	{
+		Name:        "is_dependency",
+		Description: `Returns true if the pipeline currently being executed is run because the project is a dependency of another project`,
+		Handler:     commands.IsDependency,
+		Return:      reflect.Bool.String(),
+		Group:       groupChecks,
+		IsGlobal:    true,
+	},
 	{
 		Name:        "is_empty",
 		Description: `Returns true if the value of the argument is empty string`,