Protect attribute "Inherit" method from recursive type definitions. (goadesign#1345)

Author: raphael

design/definitions.go

@@ -1204,21 +1204,33 @@ func (a *AttributeDefinition) Merge(other *AttributeDefinition) *AttributeDefini
 
 // Inherit merges the properties of existing target type attributes with the argument's.
 // The algorithm is recursive so that child attributes are also merged.
-func (a *AttributeDefinition) Inherit(parent *AttributeDefinition) {
+func (a *AttributeDefinition) Inherit(parent *AttributeDefinition, seen ...map[*AttributeDefinition]struct{}) {
 	if !a.shouldInherit(parent) {
 		return
 	}
 
 	a.inheritValidations(parent)
-	a.inheritRecursive(parent)
+	a.inheritRecursive(parent, seen...)
 }
 
 // DSL returns the initialization DSL.
 func (a *AttributeDefinition) DSL() func() {
 	return a.DSLFunc
 }
 
-func (a *AttributeDefinition) inheritRecursive(parent *AttributeDefinition) {
+func (a *AttributeDefinition) inheritRecursive(parent *AttributeDefinition, seen ...map[*AttributeDefinition]struct{}) {
+	// prevent infinite recursions
+	var s map[*AttributeDefinition]struct{}
+	if len(seen) > 0 {
+		s = seen[0]
+		if _, ok := s[parent]; ok {
+			return
+		}
+	} else {
+		s = make(map[*AttributeDefinition]struct{})
+	}
+	s[parent] = struct{}{}
+
 	if !a.shouldInherit(parent) {
 		return
 	}
@@ -1239,7 +1251,7 @@ func (a *AttributeDefinition) inheritRecursive(parent *AttributeDefinition) {
 				att.Type = patt.Type
 			} else if att.shouldInherit(patt) {
 				for _, att := range att.Type.ToObject() {
-					att.Inherit(patt.Type.ToObject()[n])
+					att.Inherit(patt.Type.ToObject()[n], s)
 				}
 			}
 			if att.Example == nil {

design/definitions_test.go

@@ -9,6 +9,82 @@ import (
 	. "github.com/onsi/gomega"
 )
 
+var _ = Describe("Inherit", func() {
+	var child, parent *design.AttributeDefinition
+
+	BeforeEach(func() {
+		parent = &design.AttributeDefinition{Type: design.Object{}}
+		child = &design.AttributeDefinition{Type: design.Object{}}
+	})
+
+	JustBeforeEach(func() {
+		child.Inherit(parent)
+	})
+
+	Context("with a empty parent", func() {
+		const attName = "c"
+		BeforeEach(func() {
+			child.Type.(design.Object)[attName] = &design.AttributeDefinition{Type: design.String}
+		})
+
+		It("does not change", func() {
+			obj := child.Type.(design.Object)
+			Ω(obj).Should(HaveLen(1))
+			Ω(obj).Should(HaveKey(attName))
+		})
+	})
+
+	Context("with a parent that defines no inherited attribute", func() {
+		const (
+			attName = "c"
+			def     = "default"
+		)
+
+		BeforeEach(func() {
+			child.Type.(design.Object)[attName] = &design.AttributeDefinition{Type: design.String}
+			parent.Type.(design.Object)["other"] = &design.AttributeDefinition{Type: design.String, DefaultValue: def}
+		})
+
+		It("does not change", func() {
+			obj := child.Type.(design.Object)
+			Ω(obj).Should(HaveLen(1))
+			Ω(obj).Should(HaveKey(attName))
+			Ω(obj[attName].DefaultValue).Should(BeNil())
+		})
+	})
+
+	Context("with a parent that defines an inherited attribute", func() {
+		const (
+			attName = "c"
+			def     = "default"
+		)
+
+		BeforeEach(func() {
+			child.Type.(design.Object)[attName] = &design.AttributeDefinition{Type: design.String}
+			parent.Type.(design.Object)[attName] = &design.AttributeDefinition{Type: design.String, DefaultValue: def}
+		})
+
+		It("inherits the default value", func() {
+			obj := child.Type.(design.Object)
+			Ω(obj).Should(HaveLen(1))
+			Ω(obj).Should(HaveKey(attName))
+			Ω(obj[attName].DefaultValue).Should(Equal(def))
+		})
+	})
+
+	Context("with recursive type definitions", func() {
+		BeforeEach(func() {
+			po := design.Object{}
+			parent = &design.AttributeDefinition{Type: po}
+			child = &design.AttributeDefinition{Type: &design.UserTypeDefinition{AttributeDefinition: parent}}
+			po["recurse"] = child
+		})
+
+		It("does not recurse infinitely", func() {})
+	})
+
+})
+
 var _ = Describe("IsRequired", func() {
 	var required string
 	var attName string