Perfomance verify duplicate targets

bobtask/map.go

@@ -198,41 +198,40 @@ func (tm Map) IgnoreChildTargets() (err error) {
 
 // VerifyDuplicateTargets checks if multiple build tasks point to the same target.
 func (tm Map) VerifyDuplicateTargets() error {
-
 	// mapping [target][]taskname
 	targetToTasks := make(map[string][]string)
 
 	for taskName, v := range tm {
-		target, _ := v.Target()
-		if target == nil {
+		if !v.TargetExists() {
 			continue
 		}
-		for _, t := range target.DockerImages() {
+		for _, t := range v.target.DockerImages() {
 			targetToTasks[t] = append(targetToTasks[t], taskName)
+
+			if len(targetToTasks[t]) > 1 {
+				return usererror.Wrap(CreateErrAmbiguousTargets(targetToTasks[t], t))
+			}
 		}
-		for _, t := range target.FilesystemEntriesRaw() {
+		for _, t := range v.target.FilesystemEntriesRaw() {
 			targetToTasks[t] = append(targetToTasks[t], taskName)
+
+			if len(targetToTasks[t]) > 1 {
+				return usererror.Wrap(CreateErrAmbiguousTargets(targetToTasks[t], t))
+			}
 		}
 	}
 
 	// FIXME: A filesystem target can still point to a file inside
 	// a directory target.
 	//
-	// Could be solved by beeing more strict with target definitions.
+	// Could be solved by being more strict with target definitions.
 	// E.g. a directory must be defined as "dir/" instead of "dir".
 	// This allows to catch that case without traversing the
 	// actual filesystem.
-
-	for k, v := range targetToTasks {
-		if len(targetToTasks[k]) > 1 {
-			return usererror.Wrap(CreateErrAmbigousTargets(v, k))
-		}
-	}
-
 	return nil
 }
 
-func CreateErrAmbigousTargets(tasks []string, target string) error {
+func CreateErrAmbiguousTargets(tasks []string, target string) error {
 	sort.Strings(tasks)
 	return fmt.Errorf("%w,\nmultiple tasks [%s] pointing to the same target `%s`", ErrAmbigousTargets, strings.Join(tasks, " "), target)
 }

bobtask/target.go

@@ -34,8 +34,8 @@ func (t *Task) Target() (empty target.Target, _ error) {
 		return empty, err
 	}
 
-	// This indicates the previous build did not contain any targets and therfore it
-	// can't  be  comparted againast.
+	// This indicates the previous build did not contain any targets and therefore it
+	// can't  be  compared against.
 	// FIXME: Is this necessary? Seems like it rather happens during development.
 	if len(buildInfo.Target.Filesystem.Files) == 0 && len(buildInfo.Target.Docker) == 0 {
 		return t.target, t.target.Resolve()

test/e2e/target-name/name_test.go

@@ -18,7 +18,7 @@ var _ = Describe("Testing name of targets", func() {
 			_, err = b.Aggregate()
 			Expect(err).To(HaveOccurred())
 
-			expected := bobtask.CreateErrAmbigousTargets([]string{"another", "build"}, "hello").Error()
+			expected := bobtask.CreateErrAmbiguousTargets([]string{"another", "build"}, "hello").Error()
 			Expect(err.Error()).To(Equal(expected))
 		})
 	})
@@ -34,7 +34,7 @@ var _ = Describe("Testing name of targets", func() {
 			_, err = b.Aggregate()
 			Expect(err).To(HaveOccurred())
 
-			expected := bobtask.CreateErrAmbigousTargets([]string{"another", "build"}, "hello").Error()
+			expected := bobtask.CreateErrAmbiguousTargets([]string{"another", "build"}, "hello").Error()
 			Expect(err.Error()).To(Equal(expected))
 		})
 	})
@@ -66,7 +66,7 @@ var _ = Describe("Testing name of targets", func() {
 			_, err = b.Aggregate()
 			Expect(err).To(HaveOccurred())
 
-			expected := bobtask.CreateErrAmbigousTargets([]string{"another", "build"}, "my-image:latest").Error()
+			expected := bobtask.CreateErrAmbiguousTargets([]string{"another", "build"}, "my-image:latest").Error()
 			Expect(err.Error()).To(Equal(expected))
 		})
 	})
@@ -85,7 +85,7 @@ var _ = Describe("Testing name of targets", func() {
 			_, err = b.Aggregate()
 			Expect(err).To(HaveOccurred())
 
-			expected := bobtask.CreateErrAmbigousTargets([]string{"build", "second/build"}, "my-image:latest").Error()
+			expected := bobtask.CreateErrAmbiguousTargets([]string{"build", "second/build"}, "my-image:latest").Error()
 			Expect(err.Error()).To(Equal(expected))
 		})
 	})
@@ -104,9 +104,8 @@ var _ = Describe("Testing name of targets", func() {
 			_, err = b.Aggregate()
 			Expect(err).To(HaveOccurred())
 
-			expected := bobtask.CreateErrAmbigousTargets([]string{"build", "second/build"}, "second/hello").Error()
+			expected := bobtask.CreateErrAmbiguousTargets([]string{"build", "second/build"}, "second/hello").Error()
 			Expect(err.Error()).To(Equal(expected))
-
 		})
 	})
 })