judge/dsl/merge.go

package dsl

import "fmt"

func mergeFiles(dst, src *File) error {
	if src.Build != "" {
		dst.Build = src.Build
	}
	if src.BuildLinux != "" {
		dst.BuildLinux = src.BuildLinux
	}
	if src.BuildWindows != "" {
		dst.BuildWindows = src.BuildWindows
	}
	if src.BuildDarwin != "" {
		dst.BuildDarwin = src.BuildDarwin
	}

	if src.BuildDefaults != nil {
		if dst.BuildDefaults == nil {
			dst.BuildDefaults = &BuildConfig{}
		}
		dst.BuildDefaults.MergeFrom(src.BuildDefaults)
	}

	seenTC := map[string]bool{}
	for _, t := range dst.Toolchains {
		seenTC[t.Name] = true
	}
	for _, t := range src.Toolchains {
		if seenTC[t.Name] {
			return fmt.Errorf("duplicate toolchain %q", t.Name)
		}
		seenTC[t.Name] = true
		dst.Toolchains = append(dst.Toolchains, t)
	}

	seenB := map[string]bool{}
	for _, b := range dst.Builds {
		seenB[b.Name] = true
	}
	for _, b := range src.Builds {
		if seenB[b.Name] {
			return fmt.Errorf("duplicate build %q", b.Name)
		}
		seenB[b.Name] = true
		dst.Builds = append(dst.Builds, b)
	}

	seenG := map[string]bool{}
	for _, g := range dst.Groups {
		seenG[g.Name] = true
	}
	for _, g := range src.Groups {
		if seenG[g.Name] {
			return fmt.Errorf("duplicate group %q", g.Name)
		}
		seenG[g.Name] = true
		dst.Groups = append(dst.Groups, g)
	}

	if src.Timeout != 0 {
		dst.Timeout = src.Timeout
	}
	if src.MemoryLimit != 0 {
		dst.MemoryLimit = src.MemoryLimit
	}
	if src.Binary != "" {
		dst.Binary = src.Binary
	}
	if src.Sources != "" {
		dst.Sources = src.Sources
	}
	if src.NormalizeCRLF {
		dst.NormalizeCRLF = true
	}
	if src.TrimTrailingWS {
		dst.TrimTrailingWS = true
	}
	return nil
}