template

Documentation

Index

• Variables

Variables

var MergersFuncs = template.FuncMap{
	"getKey": func(kind, varname string) (string, error) {

		if isIfc, _, err := meta.IsInterface(kind); err != nil {
			return "", errs.Wrap(err)
		} else if isIfc {
			switch kind {
			case "Value":
				return fmt.Sprintf("m.getValueID(%s)", varname), nil
			case "Type":
				return fmt.Sprintf("fmt.Sprint(printer.Print(%s))", varname), nil
			case "Selection":
				return `"selection"`, nil
			case "Node":
				return fmt.Sprintf("m.getNodeID(%s)", varname), nil
			}
			return "", errs.Newf("interface kind %q is not known", kind)
		}

		switch kind {
		case kinds.Name:
			return fmt.Sprintf("fmt.Sprint(printer.Print(%s))", varname), nil
		case kinds.TypeExtensionDefinition:
			return fmt.Sprintf("fmt.Sprint(printer.Print(%s.Definition.Name))", varname), nil
		case kinds.Document:
			return fmt.Sprintf(`"document"`), nil
		}

		if hasName, _, err := meta.HasFieldKind(kind, kinds.Name, "Name"); err != nil {
			return "", errs.Wrap(err)
		} else if hasName {
			return fmt.Sprintf("fmt.Sprint(printer.Print(%s.Name))", varname), nil
		}

		if isNode, err := meta.DoesImplement(kind, "Node"); err != nil {
			return "", errs.Wrap(err)
		} else if isNode {
			return fmt.Sprintf("m.getNodeID(%s)", varname), nil
		}

		return "", errs.Newf("kind %q is not known", kind)
	},

	"propsSlices": func(kind string) (string, error) {
		if isInterface, _, err := meta.IsInterface(kind); err != nil {
			return "", errs.Wrap(err)
		} else if isInterface {
			return "", nil
		}

		var decls []string

		fields, err := meta.AllFields(kind)
		if err != nil {
			return "", errs.Wrap(err)
		}

		for _, field := range fields {
			ft := typeAsMulti(field)
			decl := fmt.Sprintf("var list%s %s", field.Name, ft)
			decls = append(decls, decl)
		}

		return strings.Join(decls, "\n"), nil
	},

	"propsAppenders": func(kind, varname string) (string, error) {
		if isInterface, _, err := meta.IsInterface(kind); err != nil {
			return "", errs.Wrap(err)
		} else if isInterface {
			return "", nil
		}

		var appenders []string

		fields, err := meta.AllFields(kind)
		if err != nil {
			return "", errs.Wrap(err)
		}

		for _, field := range fields {
			suffix := ""
			if isMulti(field.Type) {
				suffix = "..."
			}

			fname := field.Name
			appender := fmt.Sprintf("list%s = append(list%s, %s.%s%s)", fname, fname, varname, fname, suffix)
			appenders = append(appenders, appender)
		}

		return strings.Join(appenders, "\n"), nil
	},

	"propsMergers": func(kind string) (string, error) {
		out := &strings.Builder{}

		data := tmplMerge{
			Kind: kind,
		}

		isConcrete, _, err := meta.IsConcrete(kind)
		if err != nil {
			return "", errs.Wrap(err)
		}
		if isConcrete {
			fields, err := meta.AllFields(kind)
			if err != nil {
				return "", errs.Wrap(err)
			}
			data.Fields = fields
			if err := tmplConcreteMerge.Execute(out, data); err != nil {
				return "", errs.Wrap(err)
			}
			return out.String(), nil
		}

		isInterface, _, err := meta.IsInterface(kind)
		if err != nil {
			return "", errs.Wrap(err)
		}
		if isInterface {
			implementers, err := meta.AllImplementers(kind)
			if err != nil {
				return "", errs.Wrap(err)
			}
			data.Implementers = implementers
			if err := tmplIfcMerge.Execute(out, data); err != nil {
				return "", errs.Wrap(err)
			}
			return out.String(), nil
		}

		return "", errs.Newf("kind %q not concrete or interface", kind)
	},
}

MergersFuncs is a funcmap for generated merger code