fix(cmd): add flag first-win

cmd/root.go

@@ -42,6 +42,7 @@ dcmerge docker-compose.yml https://git.example.local/user/repo/docker-compose.ym
 		RunE:    run,
 		Version: version,
 	}
+	rootCmd.Flags().BoolP("first-win", "f", false, "Add only missing attributes")
 	rootCmd.Flags().BoolP("last-win", "l", false, "Overwrite existing attributes")
 	rootCmd.Flags().StringP("output-file", "o", "", "Write instead on stdout into a file")
 	rootCmd.AddCommand(completionCmd)
@@ -50,6 +51,11 @@ dcmerge docker-compose.yml https://git.example.local/user/repo/docker-compose.ym
 }
 
 func run(cmd *cobra.Command, args []string) error {
+	mergeFirstWin, err := cmd.Flags().GetBool("first-win")
+	if err != nil {
+		return fmt.Errorf("Failed to parse flag last-win: %s", err)
+	}
+
 	mergeLastWin, err := cmd.Flags().GetBool("last-win")
 	if err != nil {
 		return fmt.Errorf("Failed to parse flag last-win: %s", err)
@@ -69,12 +75,15 @@ func run(cmd *cobra.Command, args []string) error {
 
 	for _, config := range dockerComposeConfigs {
 		switch {
-		case mergeLastWin:
+		case mergeFirstWin && mergeLastWin:
+			return fmt.Errorf("Neither --first-win or --last-win can be specified - not booth.")
+		case mergeFirstWin && !mergeLastWin:
+			dockerComposeConfig.MergeFirstWin(config)
+		case !mergeFirstWin && mergeLastWin:
 			dockerComposeConfig.MergeLastWin(config)
 		default:
 			dockerComposeConfig.Merge(config)
 		}
-
 	}
 
 	switch {

pkg/domain/dockerCompose/config.go

@@ -91,6 +91,31 @@ func (c *Config) Merge(config *Config) {
 	}
 }
 
+// MergeLastWin merges a config and overwrite already existing properties
+func (c *Config) MergeFirstWin(config *Config) {
+	switch {
+	case c == nil && config == nil:
+		fallthrough
+	case c != nil && config == nil:
+		return
+
+	// WARN: It's not possible to change the memory pointer c *Config
+	// to a new initialized config without returning the Config
+	// it self.
+	//
+	// case c == nil && config != nil:
+	// 	c = NewConfig()
+	// 	fallthrough
+
+	default:
+		c.mergeFirstWinNetworks(config.Networks)
+		c.mergeFirstWinSecrets(config.Secrets)
+		c.mergeFirstWinServices(config.Services)
+		c.mergeFirstWinVersion(config.Version)
+		c.mergeFirstWinVolumes(config.Volumes)
+	}
+}
+
 // MergeLastWin merges a config and overwrite already existing properties
 func (c *Config) MergeLastWin(config *Config) {
 	switch {
@@ -116,6 +141,68 @@ func (c *Config) MergeLastWin(config *Config) {
 	}
 }
 
+func (c *Config) mergeFirstWinVersion(version string) {
+	if len(c.Version) <= 0 {
+		c.Version = version
+	}
+}
+
+func (c *Config) mergeFirstWinNetworks(networks map[string]*Network) {
+	for networkName, network := range networks {
+		if network == nil {
+			continue
+		}
+
+		if c.ExistsNetwork(networkName) {
+			c.Networks[networkName].MergeFirstWin(network)
+		} else {
+			c.Networks[networkName] = network
+		}
+	}
+}
+
+func (c *Config) mergeFirstWinSecrets(secrets map[string]*Secret) {
+	for secretName, secret := range secrets {
+		if secret == nil {
+			continue
+		}
+
+		if c.ExistsNetwork(secretName) {
+			c.Secrets[secretName].MergeFirstWin(secret)
+		} else {
+			c.Secrets[secretName] = secret
+		}
+	}
+}
+
+func (c *Config) mergeFirstWinServices(services map[string]*Service) {
+	for serviceName, service := range services {
+		if service == nil {
+			continue
+		}
+
+		if c.ExistsService(serviceName) {
+			c.Services[serviceName].MergeFirstWin(service)
+		} else {
+			c.Services[serviceName] = service
+		}
+	}
+}
+
+func (c *Config) mergeFirstWinVolumes(volumes map[string]*Volume) {
+	for volumeName, volume := range volumes {
+		if volume == nil {
+			continue
+		}
+
+		if c.ExistsNetwork(volumeName) {
+			c.Volumes[volumeName].MergeFirstWin(volume)
+		} else {
+			c.Volumes[volumeName] = volume
+		}
+	}
+}
+
 func (c *Config) mergeLastWinVersion(version string) {
 	if c.Version != version {
 		c.Version = version
@@ -214,6 +301,26 @@ func (n *Network) Equal(equalable Equalable) bool {
 	}
 }
 
+func (n *Network) MergeFirstWin(network *Network) {
+	switch {
+	case n == nil && network == nil:
+		fallthrough
+	case n != nil && network == nil:
+		return
+
+	// WARN: It's not possible to change the memory pointer n *Network
+	// to a new initialized network without returning the Network
+	// it self.
+	//
+	// case n == nil && network != nil:
+	// 	c = NewCNetwork()
+	// 	fallthrough
+
+	default:
+		n.mergeFirstWinIPAM(network.IPAM)
+	}
+}
+
 func (n *Network) MergeLastWin(network *Network) {
 	switch {
 	case n == nil && network == nil:
@@ -234,6 +341,12 @@ func (n *Network) MergeLastWin(network *Network) {
 	}
 }
 
+func (n *Network) mergeFirstWinIPAM(networkIPAM *NetworkIPAM) {
+	if !n.IPAM.Equal(networkIPAM) {
+		n.IPAM.MergeFirstWin(networkIPAM)
+	}
+}
+
 func (n *Network) mergeLastWinIPAM(networkIPAM *NetworkIPAM) {
 	if !n.IPAM.Equal(networkIPAM) {
 		n.IPAM.MergeLastWin(networkIPAM)
@@ -270,6 +383,26 @@ func (nIPAM *NetworkIPAM) Equal(equalable Equalable) bool {
 	}
 }
 
+func (nIPAM *NetworkIPAM) MergeFirstWin(networkIPAM *NetworkIPAM) {
+	switch {
+	case nIPAM == nil && networkIPAM == nil:
+		fallthrough
+	case nIPAM != nil && networkIPAM == nil:
+		return
+
+	// WARN: It's not possible to change the memory pointer n *NetworkIPAM
+	// to a new initialized networkIPAM without returning the NetworkIPAM
+	// it self.
+	//
+	// case nIPAM == nil && networkIPAM != nil:
+	// 	c = NewNetworkIPAM()
+	// 	fallthrough
+
+	default:
+		nIPAM.mergeFirstWinConfig(networkIPAM.Configs)
+	}
+}
+
 func (nIPAM *NetworkIPAM) MergeLastWin(networkIPAM *NetworkIPAM) {
 	switch {
 	case nIPAM == nil && networkIPAM == nil:
@@ -290,6 +423,14 @@ func (nIPAM *NetworkIPAM) MergeLastWin(networkIPAM *NetworkIPAM) {
 	}
 }
 
+func (nIPAM *NetworkIPAM) mergeFirstWinConfig(networkIPAMConfigs []*NetworkIPAMConfig) {
+	for _, networkIPAMConfig := range networkIPAMConfigs {
+		if !existsInSlice(nIPAM.Configs, networkIPAMConfig) {
+			nIPAM.Configs = append(nIPAM.Configs, networkIPAMConfig)
+		}
+	}
+}
+
 func (nIPAM *NetworkIPAM) mergeLastWinConfig(networkIPAMConfigs []*NetworkIPAMConfig) {
 	for _, networkIPAMConfig := range networkIPAMConfigs {
 		if !existsInSlice(nIPAM.Configs, networkIPAMConfig) {
@@ -354,6 +495,14 @@ func (s *Secret) Equal(equalable Equalable) bool {
 	}
 }
 
+// MergeFirstWin merges adds or overwrite the attributes of the passed secret
+// with the existing one.
+func (s *Secret) MergeFirstWin(secret *Secret) {
+	if len(s.File) <= 0 {
+		s.File = secret.File
+	}
+}
+
 // MergeLastWin merges adds or overwrite the attributes of the passed secret
 // with the existing one.
 func (s *Secret) MergeLastWin(secret *Secret) {
@@ -381,6 +530,103 @@ type Service struct {
 	Volumes          []string                   `json:"volumes,omitempty" yaml:"volumes,omitempty"`
 }
 
+// ExistsEnvironment returns true if the passed name of environment variable is
+// already present.
+func (s *Service) ExistsEnvironment(name string) bool {
+	for _, environment := range s.Environments {
+		key, _ := splitStringInKeyValue(environment, environmentDelimiter)
+		if key == name {
+			return true
+		}
+	}
+
+	return false
+}
+
+// ExistsLabel returns true if the passed label name is already present.
+func (s *Service) ExistsLabel(name string) bool {
+	for _, label := range s.Labels {
+		key, _ := splitStringInKeyValue(label, labelDelimiter)
+		if key == name {
+			return true
+		}
+	}
+
+	return false
+}
+
+// ExistsPort returns true if the port definition is already present.
+func (s *Service) ExistsPort(src string, dest string, protocol string) bool {
+	for _, port := range s.Ports {
+		s, d, p := splitStringInPort(port)
+		if s == src && d == dest && p == protocol {
+			return true
+		}
+	}
+
+	return false
+}
+
+// ExistsDestinationPort returns true if the destination port is already used.
+func (s *Service) ExistsDestinationPort(dest string) bool {
+	for _, port := range s.Ports {
+		_, d, _ := splitStringInPort(port)
+		if d == dest {
+			return true
+		}
+	}
+
+	return false
+}
+
+// ExistsSourcePort returns true if the source port is already used.
+func (s *Service) ExistsSourcePort(src string) bool {
+	for _, port := range s.Ports {
+		s, _, _ := splitStringInPort(port)
+		if s == src {
+			return true
+		}
+	}
+
+	return false
+}
+
+// ExistsVolume returns true if the volume definition is already present.
+func (s *Service) ExistsVolume(src string, dest string, perm string) bool {
+	for _, volume := range s.Volumes {
+		s, d, p := splitStringInVolume(volume)
+		if s == src && d == dest && p == perm {
+			return true
+		}
+	}
+
+	return false
+}
+
+// ExistsDestinationVolume returns true if the volume definition is already present.
+func (s *Service) ExistsDestinationVolume(dest string) bool {
+	for _, volume := range s.Volumes {
+		_, d, _ := splitStringInVolume(volume)
+		if d == dest {
+			return true
+		}
+	}
+
+	return false
+}
+
+// ExistsSourceVolume returns true if the volume definition is already present.
+func (s *Service) ExistsSourceVolume(src string) bool {
+	for _, volume := range s.Volumes {
+		s, _, _ := splitStringInVolume(volume)
+		if s == src {
+			return true
+		}
+	}
+
+	return false
+}
+
 // Equal returns true if the passed equalable is equal
 func (s *Service) Equal(equalable Equalable) bool {
 	service, ok := equalable.(*Service)
@@ -411,6 +657,37 @@ func (s *Service) Equal(equalable Equalable) bool {
 	}
 }
 
+func (s *Service) MergeFirstWin(service *Service) {
+	switch {
+	case s == nil && service == nil:
+		fallthrough
+	case s != nil && service == nil:
+		return
+
+	// WARN: It's not possible to change the memory pointer s *Service
+	// to a new initialized service without returning the Service
+	// it self.
+	//
+	// case s == nil && service != nil:
+	// 	s = NewService()
+	// 	fallthrough
+
+	default:
+		s.mergeFirstWinCapabilitiesAdd(service.CapabilitiesAdd)
+		s.mergeFirstWinCapabilitiesDrop(service.CapabilitiesDrop)
+		s.mergeFirstWinDeploy(service.Deploy)
+		s.mergeFirstWinEnvironments(service.Environments)
+		s.mergeFirstWinExtraHosts(service.ExtraHosts)
+		s.mergeFirstWinImage(service.Image)
+		s.mergeFirstWinLabels(service.Labels)
+		s.mergeFirstWinNetworks(service.Networks)
+		s.mergeFirstWinPorts(service.Ports)
+		s.mergeFirstWinSecrets(service.Secrets)
+		s.mergeFirstWinULimits(service.ULimits)
+		s.mergeFirstWinVolumes(service.Volumes)
+	}
+}
+
 // MergeLastWin merges adds or overwrite the attributes of the passed secret
 // with the existing one.
 func (s *Service) MergeLastWin(service *Service) {
@@ -444,6 +721,176 @@ func (s *Service) MergeLastWin(service *Service) {
 	}
 }
 
+func (s *Service) mergeFirstWinCapabilitiesAdd(capabilitiesAdd []string) {
+	for _, capabilityAdd := range capabilitiesAdd {
+		if !existsInSlice(s.CapabilitiesAdd, capabilityAdd) && len(capabilityAdd) > 0 {
+			s.CapabilitiesAdd = append(s.CapabilitiesAdd, capabilityAdd)
+		}
+	}
+}
+
+func (s *Service) mergeFirstWinCapabilitiesDrop(capabilitiesDrop []string) {
+	for _, capabilityDrop := range capabilitiesDrop {
+		if !existsInSlice(s.CapabilitiesAdd, capabilityDrop) && len(capabilityDrop) > 0 {
+			s.CapabilitiesDrop = append(s.CapabilitiesDrop, capabilityDrop)
+		}
+	}
+}
+
+func (s *Service) mergeFirstWinDeploy(deploy *ServiceDeploy) {
+	switch {
+	case s.Deploy == nil && deploy != nil:
+		s.Deploy = deploy
+	case s.Deploy != nil && deploy == nil:
+		fallthrough
+	case s.Deploy == nil && deploy == nil:
+		return
+	default:
+		s.Deploy.MergeFirstWin(deploy)
+	}
+}
+
+func (s *Service) mergeFirstWinEnvironments(environments []string) {
+	switch {
+	case s.Environments == nil && environments != nil:
+		s.Environments = environments
+	case s.Environments != nil && environments == nil:
+		fallthrough
+	case s.Environments == nil && environments == nil:
+		return
+	default:
+		for _, environment := range environments {
+			if len(environment) <= 0 {
+				continue
+			}
+
+			key, value := splitStringInKeyValue(environment, environmentDelimiter)
+			if !s.ExistsEnvironment(key) {
+				s.SetEnvironment(key, value)
+			}
+		}
+	}
+}
+
+func (s *Service) mergeFirstWinImage(image string) {
+	switch {
+	case len(s.Image) == 0 && len(image) != 0:
+		s.Image = image
+	case len(s.Image) != 0 && len(image) == 0:
+		fallthrough
+	case len(s.Image) == 0 && len(image) == 0:
+		fallthrough
+	default:
+		return
+	}
+}
+
+func (s *Service) mergeFirstWinExtraHosts(extraHosts []string) {
+	for _, extraHost := range extraHosts {
+		if !existsInSlice(s.ExtraHosts, extraHost) && len(extraHost) > 0 {
+			s.ExtraHosts = append(s.ExtraHosts, extraHost)
+		}
+	}
+}
+
+func (s *Service) mergeFirstWinLabels(labels []string) {
+	switch {
+	case s.Labels == nil && labels != nil:
+		s.Labels = labels
+	case s.Labels != nil && labels == nil:
+		fallthrough
+	case s.Labels == nil && labels == nil:
+		return
+	default:
+		for _, label := range labels {
+			if len(label) <= 0 {
+				continue
+			}
+
+			key, value := splitStringInKeyValue(label, labelDelimiter)
+			if !s.ExistsLabel(key) {
+				s.SetLabel(key, value)
+			}
+		}
+	}
+}
+
+func (s *Service) mergeFirstWinNetworks(networks map[string]*ServiceNetwork) {
+	switch {
+	case s.Networks == nil && networks != nil:
+		s.Networks = networks
+	case s.Networks != nil && networks == nil:
+		fallthrough
+	case s.Networks == nil && networks == nil:
+		return
+	default:
+		for name, network := range networks {
+			if _, exists := s.Networks[name]; exists {
+				s.Networks[name].MergeFirstWin(network)
+			} else {
+				s.Networks[name] = network
+			}
+		}
+	}
+}
+
+func (s *Service) mergeFirstWinPorts(ports []string) {
+	switch {
+	case s.Ports == nil && ports != nil:
+		s.Ports = ports
+	case s.Ports != nil && ports == nil:
+		fallthrough
+	case s.Ports == nil && ports == nil:
+		return
+	default:
+		for _, port := range ports {
+			src, dest, protocol := splitStringInPort(port)
+			if !s.ExistsDestinationPort(dest) {
+				s.SetPort(src, dest, protocol)
+			}
+		}
+	}
+}
+
+func (s *Service) mergeFirstWinSecrets(secrets []string) {
+	for _, secret := range secrets {
+		if !existsInSlice(s.Secrets, secret) && len(secret) > 0 {
+			s.Secrets = append(s.Secrets, secret)
+		}
+	}
+}
+
+func (s *Service) mergeFirstWinULimits(uLimits *ServiceULimits) {
+	switch {
+	case s.ULimits == nil && uLimits != nil:
+		s.ULimits = uLimits
+	case s.ULimits != nil && uLimits == nil:
+		fallthrough
+	case s.ULimits == nil && uLimits == nil:
+		return
+	default:
+		s.ULimits.MergeFirstWin(uLimits)
+	}
+}
+
+func (s *Service) mergeFirstWinVolumes(volumes []string) {
+	switch {
+	case s.Volumes == nil && volumes != nil:
+		s.Volumes = volumes
+	case s.Volumes != nil && volumes == nil:
+		fallthrough
+	case s.Volumes == nil && volumes == nil:
+		return
+	default:
+		for _, volume := range volumes {
+			src, dest, perm := splitStringInVolume(volume)
+			if !s.ExistsDestinationVolume(dest) {
+				s.SetVolume(src, dest, perm)
+			}
+		}
+	}
+}
+
 func (s *Service) mergeLastWinCapabilitiesAdd(capabilitiesAdd []string) {
 	for _, capabilityAdd := range capabilitiesAdd {
 		if !existsInSlice(s.CapabilitiesAdd, capabilityAdd) {
@@ -732,6 +1179,28 @@ func (sd *ServiceDeploy) Equal(equalable Equalable) bool {
 	}
 }
 
+// MergeFirstWin merges adds or overwrite the attributes of the passed
+// serviceDeploy with the existing one.
+func (sd *ServiceDeploy) MergeFirstWin(serviceDeploy *ServiceDeploy) {
+	switch {
+	case sd == nil && serviceDeploy == nil:
+		fallthrough
+	case sd != nil && serviceDeploy == nil:
+		return
+
+	// WARN: It's not possible to change the memory pointer sd *ServiceDeploy
+	// to a new initialized serviceDeploy without returning the ServiceDeploy
+	// it self.
+	//
+	// case sd == nil && serviceDeploy != nil:
+	// 	sd = NewServiceDeploy()
+	// 	fallthrough
+
+	default:
+		sd.mergeFirstWinDeployResources(serviceDeploy.Resources)
+	}
+}
+
 // MergeLastWin merges adds or overwrite the attributes of the passed
 // serviceDeploy with the existing one.
 func (sd *ServiceDeploy) MergeLastWin(serviceDeploy *ServiceDeploy) {
@@ -754,6 +1223,19 @@ func (sd *ServiceDeploy) MergeLastWin(serviceDeploy *ServiceDeploy) {
 	}
 }
 
+func (sd *ServiceDeploy) mergeFirstWinDeployResources(resources *ServiceDeployResources) {
+	switch {
+	case sd.Resources == nil && resources != nil:
+		sd.Resources = resources
+	case sd.Resources != nil && resources == nil:
+		fallthrough
+	case sd.Resources == nil && resources == nil:
+		return
+	default:
+		sd.Resources.MergeFirstWin(resources)
+	}
+}
+
 func (sd *ServiceDeploy) mergeLastWinDeployResources(resources *ServiceDeployResources) {
 	switch {
 	case sd.Resources == nil && resources != nil:
@@ -798,6 +1280,27 @@ func (sdr *ServiceDeployResources) Equal(equalable Equalable) bool {
 	}
 }
 
+// MergeFirstWin adds only attributes of the passed serviceDeployResources if
+// they are not already exists.
+func (sdr *ServiceDeployResources) MergeFirstWin(serviceDeployResources *ServiceDeployResources) {
+	switch {
+	case sdr == nil && serviceDeployResources == nil:
+		fallthrough
+	case sdr != nil && serviceDeployResources == nil:
+		return
+
+	// WARN: It's not possible to change the memory pointer sdr *ServiceDeployResources
+	// to a new initialized serviceDeployResources without returning the
+	// serviceDeployResources it self.
+	case sdr == nil && serviceDeployResources != nil:
+		sdr = NewServiceDeployResources()
+		fallthrough
+	default:
+		sdr.mergeFirstWinLimits(serviceDeployResources.Limits)
+		sdr.mergeFirstWinReservations(serviceDeployResources.Reservations)
+	}
+}
+
 // MergeLastWin merges adds or overwrite the attributes of the passed
 // serviceDeployResources with the existing one.
 func (sdr *ServiceDeployResources) MergeLastWin(serviceDeployResources *ServiceDeployResources) {
@@ -819,6 +1322,32 @@ func (sdr *ServiceDeployResources) MergeLastWin(serviceDeployResources *ServiceD
 	}
 }
 
+func (sdr *ServiceDeployResources) mergeFirstWinLimits(limits *ServiceDeployResourcesLimits) {
+	switch {
+	case sdr.Limits == nil && limits != nil:
+		sdr.Limits = limits
+	case sdr.Limits != nil && limits == nil:
+		fallthrough
+	case sdr.Limits == nil && limits == nil:
+		return
+	default:
+		sdr.Limits.MergeFirstWin(limits)
+	}
+}
+
+func (sdr *ServiceDeployResources) mergeFirstWinReservations(reservations *ServiceDeployResourcesLimits) {
+	switch {
+	case sdr.Reservations == nil && reservations != nil:
+		sdr.Reservations = reservations
+	case sdr.Reservations != nil && reservations == nil:
+		fallthrough
+	case sdr.Reservations == nil && reservations == nil:
+		return
+	default:
+		sdr.Reservations.MergeFirstWin(reservations)
+	}
+}
+
 func (sdr *ServiceDeployResources) mergeLastWinLimits(limits *ServiceDeployResourcesLimits) {
 	switch {
 	case sdr.Limits == nil && limits != nil:
@@ -877,6 +1406,29 @@ func (sdrl *ServiceDeployResourcesLimits) Equal(equalable Equalable) bool {
 	}
 }
 
+// MergeFirstWin adds only attributes of the passed serviceDeployResourcesLimits
+// if they are not already exists.
+func (sdrl *ServiceDeployResourcesLimits) MergeFirstWin(serviceDeployResourcesLimits *ServiceDeployResourcesLimits) {
+	switch {
+	case sdrl == nil && serviceDeployResourcesLimits == nil:
+		fallthrough
+	case sdrl != nil && serviceDeployResourcesLimits == nil:
+		return
+
+	// WARN: It's not possible to change the memory pointer sdrl *ServiceDeployResourcesLimits
+	// to a new initialized serviceDeployResourcesLimits without returning the
+	// serviceDeployResourcesLimits it self.
+	//
+	// case sdrl == nil && serviceDeployResourcesLimits != nil:
+	// 	sdrl = NewServiceDeployResourcesLimits()
+	// 	fallthrough
+
+	default:
+		sdrl.mergeFirstWinCPUs(serviceDeployResourcesLimits.CPUs)
+		sdrl.mergeFirstWinMemory(serviceDeployResourcesLimits.Memory)
+	}
+}
+
 // MergeLastWin merges adds or overwrite the attributes of the passed
 // serviceDeployResourcesLimits with the existing one.
 func (sdrl *ServiceDeployResourcesLimits) MergeLastWin(serviceDeployResourcesLimits *ServiceDeployResourcesLimits) {
@@ -900,6 +1452,18 @@ func (sdrl *ServiceDeployResourcesLimits) MergeLastWin(serviceDeployResourcesLim
 	}
 }
 
+func (sdrl *ServiceDeployResourcesLimits) mergeFirstWinCPUs(cpus string) {
+	if len(sdrl.CPUs) <= 0 {
+		sdrl.CPUs = cpus
+	}
+}
+
+func (sdrl *ServiceDeployResourcesLimits) mergeFirstWinMemory(memory string) {
+	if len(sdrl.Memory) <= 0 {
+		sdrl.Memory = memory
+	}
+}
+
 func (sdrl *ServiceDeployResourcesLimits) mergeLastWinCPUs(cpus string) {
 	if sdrl.CPUs != cpus {
 		sdrl.CPUs = cpus
@@ -939,6 +1503,30 @@ func (sn *ServiceNetwork) Equal(equalable Equalable) bool {
 	}
 }
 
+// MergeFirstWin adds only attributes of the passed
+// serviceNetwork if they are undefined.
+func (sn *ServiceNetwork) MergeFirstWin(serviceNetwork *ServiceNetwork) {
+	switch {
+	case sn == nil && serviceNetwork == nil:
+		fallthrough
+	case sn != nil && serviceNetwork == nil:
+		return
+
+	// WARN: It's not possible to change the memory pointer sn *ServiceNetwork to a new
+	// initialized ServiceNetwork without returning the serviceNetwork it self.
+	//
+	// case l == nil && serviceULimits != nil:
+	// 	l = NewServiceULimits()
+	// 	fallthrough
+
+	case sn == nil && serviceNetwork != nil:
+		sn = NewServiceNetwork()
+		fallthrough
+	default:
+		sn.mergeFirstWinAliases(serviceNetwork.Aliases)
+	}
+}
+
 // MergeLastWin merges adds or overwrite the attributes of the passed
 // serviceNetwork with the existing one.
 func (sn *ServiceNetwork) MergeLastWin(serviceNetwork *ServiceNetwork) {
@@ -963,9 +1551,17 @@ func (sn *ServiceNetwork) MergeLastWin(serviceNetwork *ServiceNetwork) {
 	}
 }
 
+func (sn *ServiceNetwork) mergeFirstWinAliases(aliases []string) {
+	for _, alias := range aliases {
+		if !existsInSlice(sn.Aliases, alias) && len(alias) > 0 {
+			sn.Aliases = append(sn.Aliases, alias)
+		}
+	}
+}
+
 func (sn *ServiceNetwork) mergeLastWinAliases(aliases []string) {
 	for _, alias := range aliases {
-		if !existsInSlice(sn.Aliases, alias) {
+		if !existsInSlice(sn.Aliases, alias) && len(alias) > 0 {
 			sn.Aliases = append(sn.Aliases, alias)
 		}
 	}
@@ -1002,6 +1598,28 @@ func (l *ServiceULimits) Equal(equalable Equalable) bool {
 	}
 }
 
+// MergeFirstWin adds only the attributes of the passed ServiceULimits they are
+// undefined.
+func (l *ServiceULimits) MergeFirstWin(serviceULimits *ServiceULimits) {
+	switch {
+	case l == nil && serviceULimits == nil:
+		fallthrough
+	case l != nil && serviceULimits == nil:
+		return
+
+	// WARN: It's not possible to change the memory pointer l *ServiceULimits to a new
+	// initialized ServiceULimits without returning the serviceULimits it self.
+	//
+	// case l == nil && serviceULimits != nil:
+	// 	l = NewServiceULimits()
+	// 	fallthrough
+
+	default:
+		l.mergeFirstWinNProc(serviceULimits.NProc)
+		l.mergeFirstWinNoFile(serviceULimits.NoFile)
+	}
+}
+
 // MergeLastWin merges adds or overwrite the attributes of the passed
 // ServiceULimits with the existing one.
 func (l *ServiceULimits) MergeLastWin(serviceULimits *ServiceULimits) {
@@ -1024,6 +1642,19 @@ func (l *ServiceULimits) MergeLastWin(serviceULimits *ServiceULimits) {
 	}
 }
 
+func (l *ServiceULimits) mergeFirstWinNProc(nproc uint) {
+	if l.NProc != nproc {
+		return
+	}
+	l.NProc = nproc
+}
+
+func (l *ServiceULimits) mergeFirstWinNoFile(noFile *ServiceULimitsNoFile) {
+	if !l.NoFile.Equal(noFile) {
+		l.NoFile.MergeFirstWin(noFile)
+	}
+}
+
 func (l *ServiceULimits) mergeLastWinNProc(nproc uint) {
 	if l.NProc != nproc {
 		l.NProc = nproc
@@ -1067,8 +1698,31 @@ func (nf *ServiceULimitsNoFile) Equal(equalable Equalable) bool {
 	}
 }
 
+// MergeFirstWin adds only the attributes of the passed ServiceULimits they are
+// undefined.
+func (nf *ServiceULimitsNoFile) MergeFirstWin(serviceULimitsNoFile *ServiceULimitsNoFile) {
+	switch {
+	case nf == nil && serviceULimitsNoFile == nil:
+		fallthrough
+	case nf != nil && serviceULimitsNoFile == nil:
+		return
+
+	// WARN: It's not possible to change the memory pointer nf *ServiceULimitsNoFile
+	// to a new initialized ServiceULimitsNoFile without returning the serviceULimitsNoFile
+	// it self.
+	//
+	// case nf == nil && serviceULimitsNoFile != nil:
+	// 	nf = NewServiceULimitsNoFile()
+	// 	fallthrough
+
+	default:
+		nf.mergeFirstWinHard(serviceULimitsNoFile.Hard)
+		nf.mergeFirstWinSoft(serviceULimitsNoFile.Soft)
+	}
+}
+
 // MergeLastWin merges adds or overwrite the attributes of the passed
-// ServiceULimits with the existing one.
+// ServiceULimitsNoFile with the existing one.
 func (nf *ServiceULimitsNoFile) MergeLastWin(serviceULimitsNoFile *ServiceULimitsNoFile) {
 	switch {
 	case nf == nil && serviceULimitsNoFile == nil:
@@ -1090,6 +1744,20 @@ func (nf *ServiceULimitsNoFile) MergeLastWin(serviceULimitsNoFile *ServiceULimit
 	}
 }
 
+func (nf *ServiceULimitsNoFile) mergeFirstWinHard(hard uint) {
+	if nf.Hard != hard {
+		return
+	}
+	nf.Hard = hard
+}
+
+func (nf *ServiceULimitsNoFile) mergeFirstWinSoft(soft uint) {
+	if nf.Soft != soft {
+		return
+	}
+	nf.Soft = soft
+}
+
 func (nf *ServiceULimitsNoFile) mergeLastWinHard(hard uint) {
 	if nf.Hard != hard {
 		nf.Hard = hard
@@ -1129,6 +1797,27 @@ func (v *Volume) Equal(equalable Equalable) bool {
 	}
 }
 
+// MergeFirstWin adds only the attributes of the passed Volume they are
+// undefined.
+func (v *Volume) MergeFirstWin(volume *Volume) {
+	switch {
+	case v == nil && volume == nil:
+		fallthrough
+	case v != nil && volume == nil:
+		return
+
+	// WARN: It's not possible to change the memory pointer v *Volume to a new
+	// initialized Volume without returning the volume it self.
+	//
+	// case v == nil && volume != nil:
+	// 	v = NewVolume()
+	// 	fallthrough
+
+	default:
+		v.mergeFirstWinExternal(volume.External)
+	}
+}
+
 func (v *Volume) MergeLastWin(volume *Volume) {
 	switch {
 	case v == nil && volume == nil:
@@ -1148,6 +1837,13 @@ func (v *Volume) MergeLastWin(volume *Volume) {
 	}
 }
 
+func (v *Volume) mergeFirstWinExternal(external bool) {
+	if v.External {
+		return
+	}
+	v.External = true
+}
+
 func (v *Volume) mergeLastWinExternal(external bool) {
 	if v.External != external {
 		v.External = external

test/assets/docker-compose-a.yaml

@@ -0,0 +1,10 @@
+version: "3.3"
+services:
+  app:
+    environment:
+    - HTTP_PROXY=1.2.3.4:8080
+    image: repository:version
+    ports:
+    - 8080:80
+    volumes:
+    - /etc/localtime:/etc/localtime

test/assets/docker-compose-b.yaml

@@ -0,0 +1,10 @@
+version: "3.3"
+services:
+  app:
+    environment:
+    - HTTP_PROXY=4.3.2.1:8080
+    image: repository:version
+    ports:
+    - 10080:80
+    volumes:
+    - /usr/share/zoneinfo/UTC:/etc/localtime