1package containernode
  2
  3import (
  4	"math/rand"
  5	"sort"
  6
  7	"github.com/onsi/ginkgo/internal/leafnodes"
  8	"github.com/onsi/ginkgo/types"
  9)
 10
 11type subjectOrContainerNode struct {
 12	containerNode *ContainerNode
 13	subjectNode   leafnodes.SubjectNode
 14}
 15
 16func (n subjectOrContainerNode) text() string {
 17	if n.containerNode != nil {
 18		return n.containerNode.Text()
 19	} else {
 20		return n.subjectNode.Text()
 21	}
 22}
 23
 24type CollatedNodes struct {
 25	Containers []*ContainerNode
 26	Subject    leafnodes.SubjectNode
 27}
 28
 29type ContainerNode struct {
 30	text         string
 31	flag         types.FlagType
 32	codeLocation types.CodeLocation
 33
 34	setupNodes               []leafnodes.BasicNode
 35	subjectAndContainerNodes []subjectOrContainerNode
 36}
 37
 38func New(text string, flag types.FlagType, codeLocation types.CodeLocation) *ContainerNode {
 39	return &ContainerNode{
 40		text:         text,
 41		flag:         flag,
 42		codeLocation: codeLocation,
 43	}
 44}
 45
 46func (container *ContainerNode) Shuffle(r *rand.Rand) {
 47	sort.Sort(container)
 48	permutation := r.Perm(len(container.subjectAndContainerNodes))
 49	shuffledNodes := make([]subjectOrContainerNode, len(container.subjectAndContainerNodes))
 50	for i, j := range permutation {
 51		shuffledNodes[i] = container.subjectAndContainerNodes[j]
 52	}
 53	container.subjectAndContainerNodes = shuffledNodes
 54}
 55
 56func (node *ContainerNode) BackPropagateProgrammaticFocus() bool {
 57	if node.flag == types.FlagTypePending {
 58		return false
 59	}
 60
 61	shouldUnfocus := false
 62	for _, subjectOrContainerNode := range node.subjectAndContainerNodes {
 63		if subjectOrContainerNode.containerNode != nil {
 64			shouldUnfocus = subjectOrContainerNode.containerNode.BackPropagateProgrammaticFocus() || shouldUnfocus
 65		} else {
 66			shouldUnfocus = (subjectOrContainerNode.subjectNode.Flag() == types.FlagTypeFocused) || shouldUnfocus
 67		}
 68	}
 69
 70	if shouldUnfocus {
 71		if node.flag == types.FlagTypeFocused {
 72			node.flag = types.FlagTypeNone
 73		}
 74		return true
 75	}
 76
 77	return node.flag == types.FlagTypeFocused
 78}
 79
 80func (node *ContainerNode) Collate() []CollatedNodes {
 81	return node.collate([]*ContainerNode{})
 82}
 83
 84func (node *ContainerNode) collate(enclosingContainers []*ContainerNode) []CollatedNodes {
 85	collated := make([]CollatedNodes, 0)
 86
 87	containers := make([]*ContainerNode, len(enclosingContainers))
 88	copy(containers, enclosingContainers)
 89	containers = append(containers, node)
 90
 91	for _, subjectOrContainer := range node.subjectAndContainerNodes {
 92		if subjectOrContainer.containerNode != nil {
 93			collated = append(collated, subjectOrContainer.containerNode.collate(containers)...)
 94		} else {
 95			collated = append(collated, CollatedNodes{
 96				Containers: containers,
 97				Subject:    subjectOrContainer.subjectNode,
 98			})
 99		}
100	}
101
102	return collated
103}
104
105func (node *ContainerNode) PushContainerNode(container *ContainerNode) {
106	node.subjectAndContainerNodes = append(node.subjectAndContainerNodes, subjectOrContainerNode{containerNode: container})
107}
108
109func (node *ContainerNode) PushSubjectNode(subject leafnodes.SubjectNode) {
110	node.subjectAndContainerNodes = append(node.subjectAndContainerNodes, subjectOrContainerNode{subjectNode: subject})
111}
112
113func (node *ContainerNode) PushSetupNode(setupNode leafnodes.BasicNode) {
114	node.setupNodes = append(node.setupNodes, setupNode)
115}
116
117func (node *ContainerNode) SetupNodesOfType(nodeType types.SpecComponentType) []leafnodes.BasicNode {
118	nodes := []leafnodes.BasicNode{}
119	for _, setupNode := range node.setupNodes {
120		if setupNode.Type() == nodeType {
121			nodes = append(nodes, setupNode)
122		}
123	}
124	return nodes
125}
126
127func (node *ContainerNode) Text() string {
128	return node.text
129}
130
131func (node *ContainerNode) CodeLocation() types.CodeLocation {
132	return node.codeLocation
133}
134
135func (node *ContainerNode) Flag() types.FlagType {
136	return node.flag
137}
138
139//sort.Interface
140
141func (node *ContainerNode) Len() int {
142	return len(node.subjectAndContainerNodes)
143}
144
145func (node *ContainerNode) Less(i, j int) bool {
146	return node.subjectAndContainerNodes[i].text() < node.subjectAndContainerNodes[j].text()
147}
148
149func (node *ContainerNode) Swap(i, j int) {
150	node.subjectAndContainerNodes[i], node.subjectAndContainerNodes[j] = node.subjectAndContainerNodes[j], node.subjectAndContainerNodes[i]
151}