refactor(traversal): readability refactor

refactoring functions in traverseInformatively to simply and optimize logic and also minimize inner
loop function calls

traversal/traverse.go

@@ -52,66 +52,87 @@ func (tp TraversalProgress) traverseInformatively(n ipld.Node, s selector.Select
 	}
 	attn := s.Interests()
 	if attn == nil {
-		for itr := selector.NewSegmentIterator(n); !itr.Done(); {
-			ps, v, err := itr.Next()
-			if err != nil {
-				return err
-			}
-			sNext := s.Explore(n, ps)
-			if sNext != nil {
-				err = tp.traverseChild(n, v, ps, sNext, fn)
+		return tp.traverseAll(n, s, fn)
+	}
+	return tp.traverseSelective(n, attn, s, fn)
+
+}
+
+func (tp TraversalProgress) traverseAll(n ipld.Node, s selector.Selector, fn AdvVisitFn) error {
+	for itr := selector.NewSegmentIterator(n); !itr.Done(); {
+		ps, v, err := itr.Next()
+		if err != nil {
+			return err
+		}
+		sNext := s.Explore(n, ps)
+		if sNext != nil {
+			tpNext := tp
+			tpNext.Path = tp.Path.AppendSegment(ps.String())
+			if v.ReprKind() == ipld.ReprKind_Link {
+				v, err = tpNext.loadLink(v, n)
 				if err != nil {
 					return err
 				}
 			}
-		}
-	} else {
-		for _, ps := range attn {
-			// TODO: Probably not the most efficient way to be doing this...
-			v, err := n.TraverseField(ps.String())
+
+			err = tpNext.traverseInformatively(v, sNext, fn)
 			if err != nil {
-				continue
+				return err
 			}
-			sNext := s.Explore(n, ps)
-			if sNext != nil {
-				err = tp.traverseChild(n, v, ps, sNext, fn)
+		}
+	}
+	return nil
+}
+
+func (tp TraversalProgress) traverseSelective(n ipld.Node, attn []selector.PathSegment, s selector.Selector, fn AdvVisitFn) error {
+	for _, ps := range attn {
+		// TODO: Probably not the most efficient way to be doing this...
+		v, err := n.TraverseField(ps.String())
+		if err != nil {
+			continue
+		}
+		sNext := s.Explore(n, ps)
+		if sNext != nil {
+			tpNext := tp
+			tpNext.Path = tp.Path.AppendSegment(ps.String())
+			if v.ReprKind() == ipld.ReprKind_Link {
+				v, err = tpNext.loadLink(v, n)
 				if err != nil {
 					return err
 				}
 			}
+
+			err = tpNext.traverseInformatively(v, sNext, fn)
+			if err != nil {
+				return err
+			}
 		}
 	}
 	return nil
 }
 
-func (tp TraversalProgress) traverseChild(n ipld.Node, v ipld.Node, ps selector.PathSegment, sNext selector.Selector, fn AdvVisitFn) error {
-	var err error
-	tpNext := tp
-	tpNext.Path = tp.Path.AppendSegment(ps.String())
-	if v.ReprKind() == ipld.ReprKind_Link {
-		lnk, _ := v.AsLink()
-		// Assemble the LinkContext in case the Loader or NBChooser want it.
-		lnkCtx := ipld.LinkContext{
-			LinkPath:   tpNext.Path,
-			LinkNode:   v,
-			ParentNode: n,
-		}
-		// Load link!
-		v, err = lnk.Load(
-			tpNext.Cfg.Ctx,
-			lnkCtx,
-			tpNext.Cfg.LinkNodeBuilderChooser(lnk, lnkCtx),
-			tpNext.Cfg.LinkLoader,
-		)
-		if err != nil {
-			return fmt.Errorf("error traversing node at %q: could not load link %q: %s", tpNext.Path, lnk, err)
-		}
+func (tp TraversalProgress) loadLink(v ipld.Node, parent ipld.Node) (ipld.Node, error) {
+	lnk, err := v.AsLink()
+	if err != nil {
+		return nil, err
 	}
-
-	if err := tpNext.traverseInformatively(v, sNext, fn); err != nil {
-		return err
+	// Assemble the LinkContext in case the Loader or NBChooser want it.
+	lnkCtx := ipld.LinkContext{
+		LinkPath:   tp.Path,
+		LinkNode:   v,
+		ParentNode: parent,
 	}
-	return nil
+	// Load link!
+	v, err = lnk.Load(
+		tp.Cfg.Ctx,
+		lnkCtx,
+		tp.Cfg.LinkNodeBuilderChooser(lnk, lnkCtx),
+		tp.Cfg.LinkLoader,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("error traversing node at %q: could not load link %q: %s", tp.Path, lnk, err)
+	}
+	return v, nil
 }
 
 func (tp TraversalProgress) TraverseTransform(n ipld.Node, s selector.Selector, fn TransformFn) (ipld.Node, error) {