GH-40 - Fix group/struct delving & recovery (#43)

* Adjust group/struct delving and recovery

* Validate final PIC not incl.

* Cleanup lint

Author: pgmitche

pkg/lex/parserfn.go

@@ -28,10 +28,11 @@ func parsePIC(_ *Tree, l line, _ *Record) *Record {
 	}
 
 	return &Record{
-		Name:   l.items[4].val,
-		Length: length,
-		depth:  l.items[2].val,
-		Typ:    parsePICType(picNumDef),
+		depthMap: map[string]*Record{},
+		Name:     l.items[4].val,
+		Length:   length,
+		depth:    l.items[2].val,
+		Typ:      parsePICType(picNumDef),
 	}
 }
 
@@ -48,9 +49,10 @@ func parseRedefines(_ *Tree, l line, root *Record) *Record {
 	}
 
 	r := &Record{
-		Name:   l.items[4].val,
-		Length: length,
-		Typ:    parsePICType(picNumDef),
+		depthMap: map[string]*Record{},
+		Name:     l.items[4].val,
+		Length:   length,
+		Typ:      parsePICType(picNumDef),
 	}
 
 	target := l.items[8].val
@@ -75,7 +77,7 @@ func parseGroupRedefines(t *Tree, l line, root *Record) *Record {
 		log.Fatalln(fmt.Sprintf("redefinition target %s does not exist", target))
 	}
 
-	if dst.depthMap == nil {
+	if dst.depthMap == nil || len(dst.depthMap) == 0 {
 		// then check whether a node has children at this depth
 		parent, seenGroup := root.depthMap[dst.depth]
 		if seenGroup {
@@ -116,11 +118,12 @@ func parseOccurs(_ *Tree, l line, _ *Record) *Record {
 	}
 
 	return &Record{
-		Name:   l.items[4].val,
-		Length: length,
-		Occurs: n,
-		depth:  l.items[2].val,
-		Typ:    parsePICType(picNumDef),
+		Name:     l.items[4].val,
+		Length:   length,
+		Occurs:   n,
+		depth:    l.items[2].val,
+		depthMap: map[string]*Record{},
+		Typ:      parsePICType(picNumDef),
 	}
 }
 
@@ -212,20 +215,24 @@ func parseNonNumDelimitedStruct(t *Tree, l line, root *Record) *Record {
 //  |   |-picA
 //  |-group2
 //  |	|-picA
-func parseStruct(t *Tree, l line, root *Record, nameIdx, groupIdx int) *Record {
+func parseStruct(_ *Tree, l line, _ *Record, nameIdx, groupIdx int) *Record {
 	newNode := &Record{
-		Name:  l.items[nameIdx].val,
-		Typ:   reflect.Struct,
-		depth: l.items[groupIdx].val,
+		Name:     l.items[nameIdx].val,
+		Typ:      reflect.Struct,
+		depth:    l.items[groupIdx].val,
+		depthMap: map[string]*Record{},
 	}
 
-	return delve(t, root, newNode)
+	return newNode
 }
 
 func delve(t *Tree, root *Record, newRecord *Record) *Record {
 	parent, seenGroup := root.depthMap[newRecord.depth]
 	if seenGroup {
 		parent.Children = append(parent.Children, newRecord)
+		if newRecord.depthMap == nil || len(newRecord.depthMap) == 0 {
+			copyDepthMap(parent, newRecord)
+		}
 		t.parseLines(newRecord)
 		l := newRecord.Length
 		if newRecord.Occurs > 0 {
@@ -237,7 +244,7 @@ func delve(t *Tree, root *Record, newRecord *Record) *Record {
 		return parent
 	}
 
-	if root.depthMap == nil {
+	if root.depthMap == nil || len(root.depthMap) == 0 {
 		root.depthMap = make(map[string]*Record)
 	}
 
@@ -258,7 +265,7 @@ func delve(t *Tree, root *Record, newRecord *Record) *Record {
 }
 
 func copyDepthMap(src, dst *Record) {
-	if dst.depthMap == nil {
+	if dst.depthMap == nil || len(dst.depthMap) == 0 {
 		dst.depthMap = make(map[string]*Record)
 	}
 

pkg/lex/tree.go

@@ -73,7 +73,7 @@ func (t *Tree) next() item {
 
 // parseLines generates the text for the line
 // and adds it to the tree data
-func (t *Tree) parseLines(root *Record) {
+func (t *Tree) parseLines(root *Record) { //nolint:gocyclo // TODO: refine
 	for {
 		if errors.Is(t.nextLine(), io.EOF) {
 			break
@@ -84,9 +84,22 @@ func (t *Tree) parseLines(root *Record) {
 			log.Printf("%s on copybook line %d resulted in no-op", t.line.typ, t.lIdx)
 			continue
 
-		case lineStruct, lineRedefines, lineGroupRedefines, lineMultilineRedefines:
+		case lineRedefines, lineMultilineRedefines, lineGroupRedefines:
 			t.line.fn(t, t.line, root)
 
+		case lineStruct:
+			rec := t.line.fn(t, t.line, root)
+			if rec == nil {
+				continue
+			}
+
+			parent, ok := root.depthMap[rec.depth]
+			if ok {
+				root = parent
+			}
+
+			delve(t, root, rec)
+
 		default:
 			rec := t.line.fn(t, t.line, root)
 			if rec == nil {

pkg/lex/tree_test.go

@@ -431,6 +431,54 @@ func Test_Parse(t *testing.T) {
 					},
 				},
 			},
+		}, {
+			name: "ValidateGrouping",
+			in: NewTree(
+				New("test",
+					`000160     05  DUMMY-GROUP-1.                                           00000115
+000170         10  DUMMY-SUB-GROUP-1.                                00000116
+000180             15  DUMMY-GROUP-1-OBJECT-A   PIC 9(9).9(2).       00000117
+000190             15  DUMMY-GROUP-1-OBJECT-B   PIC X.               00000118
+000200             15  DUMMY-GROUP-1-OBJECT-C   PIC 9(4).9(4).       00000119
+000210         10  DUMMY-OBJECT-A               PIC X.               00000120
+`)),
+			want: &Record{
+				Name:   "test",
+				Typ:    reflect.Struct,
+				Length: 23,
+				Children: []*Record{
+					{
+						Name:   "DUMMY-GROUP-1",
+						Typ:    reflect.Struct,
+						Length: 23,
+						Children: []*Record{
+							{
+								Name:   "DUMMY-SUB-GROUP-1",
+								Typ:    reflect.Struct,
+								Length: 22,
+								Children: []*Record{{
+									Name:   "DUMMY-GROUP-1-OBJECT-A",
+									Typ:    reflect.Float64,
+									Length: 12,
+								}, {
+									Name:   "DUMMY-GROUP-1-OBJECT-B",
+									Typ:    reflect.String,
+									Length: 1,
+								}, {
+									Name:   "DUMMY-GROUP-1-OBJECT-C",
+									Typ:    reflect.Float64,
+									Length: 9,
+								},
+								},
+							}, {
+								Name:   "DUMMY-OBJECT-A",
+								Length: 1,
+								Typ:    reflect.String,
+							},
+						},
+					},
+				},
+			},
 		},
 	}