feat: create navigators (#33)

Taskfile.yml

@@ -28,9 +28,9 @@ tasks:
     cmds:
       - go test ./...
 
-  tt:
+  tk:
     cmds:
-      - go test
+      - go test ./internal/kernel
 
   ti:
     cmds:
@@ -40,6 +40,10 @@ tasks:
     cmds:
       - go test ./pref
 
+  tt:
+    cmds:
+      - go test
+
   # === ginkgo ================================================
 
   # initialise a test suite for a package. (only 1 per package)

builders.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 
 	"github.com/snivilised/traverse/core"
+	"github.com/snivilised/traverse/internal/kernel"
 	"github.com/snivilised/traverse/internal/types"
 	"github.com/snivilised/traverse/pref"
 )
@@ -23,17 +24,32 @@ type Builders struct {
 func (bs *Builders) buildAll() (*buildArtefacts, error) {
 	o, optionsErr := bs.ob.build()
 	if optionsErr != nil {
-		return nil, optionsErr
+		had, _ := kernel.HadesNav(optionsErr)
+
+		return &buildArtefacts{
+			o:   o,
+			nav: had,
+		}, optionsErr
 	}
 
 	nav, navErr := bs.nb.build(o)
 	if navErr != nil {
-		return nil, navErr
+		had, _ := kernel.HadesNav(navErr)
+
+		return &buildArtefacts{
+			o:   o,
+			nav: had,
+		}, navErr
 	}
 
 	plugins, pluginsErr := bs.pb.build(o)
 	if pluginsErr != nil {
-		return nil, pluginsErr
+		had, _ := kernel.HadesNav(pluginsErr)
+
+		return &buildArtefacts{
+			o:   o,
+			nav: had,
+		}, pluginsErr
 	}
 
 	if host, ok := nav.(types.UsePlugin); ok {
@@ -44,7 +60,12 @@ func (bs *Builders) buildAll() (*buildArtefacts, error) {
 		}
 
 		if pluginErr := errors.Join(es...); pluginErr != nil {
-			return nil, pluginErr
+			had, _ := kernel.HadesNav(pluginErr)
+
+			return &buildArtefacts{
+				o:   o,
+				nav: had,
+			}, pluginErr
 		}
 	}
 

director.go

@@ -2,7 +2,6 @@ package tv
 
 import (
 	"github.com/snivilised/traverse/core"
-	"github.com/snivilised/traverse/enums"
 	"github.com/snivilised/traverse/hiber"
 	"github.com/snivilised/traverse/internal/kernel"
 	"github.com/snivilised/traverse/internal/services"
@@ -12,30 +11,6 @@ import (
 	"github.com/snivilised/traverse/sampling"
 )
 
-type duffPrimeController struct {
-	err     error
-	root    string
-	client  core.Client
-	from    string
-	options []pref.Option
-}
-
-type duffResult struct{}
-
-func (r *duffResult) Error() error {
-	return nil
-}
-
-func (c *duffPrimeController) Navigate() (core.TraverseResult, error) {
-	return &duffResult{}, nil
-}
-
-type duffResumeController struct {
-	err      error
-	from     string
-	strategy enums.ResumeStrategy
-}
-
 type ifActive func(o *pref.Options) types.Plugin
 
 // activated interrogates options and invokes requests on behalf of the user
@@ -59,10 +34,6 @@ func activated(o *pref.Options) ([]types.Plugin, error) {
 	return plugins, err
 }
 
-func (c *duffResumeController) Navigate() (core.TraverseResult, error) {
-	return &duffResult{}, nil
-}
-
 // Prime extent
 func Prime(using core.Using, settings ...pref.Option) *Builders {
 	return &Builders{
@@ -77,13 +48,7 @@ func Prime(using core.Using, settings ...pref.Option) *Builders {
 			return pref.Get(settings...)
 		}),
 		nb: factory(func(o *pref.Options) (core.Navigator, error) {
-			controller, err := kernel.Prime(using, o)
-
-			if err != nil {
-				controller = &duffPrimeController{
-					err: err,
-				}
-			}
+			controller, err := kernel.PrimeNav(using, o)
 
 			return controller, err
 		}),
@@ -115,20 +80,14 @@ func Resume(as As, settings ...pref.Option) *Builders {
 			return o, err
 		}),
 		nb: factory(func(o *pref.Options) (core.Navigator, error) {
-			controller, err := kernel.Resume(as, o,
+			controller, err := kernel.ResumeNav(as, o,
 				kernel.DecorateController(func(n core.Navigator) core.Navigator {
 					// TODO: create the resume controller
 					//
 					return n
 				}),
 			)
 
-			if err != nil {
-				controller = &duffResumeController{
-					err: err,
-				}
-			}
-
 			// at this point, the resume controller does not know
 			// the wake point as would be loaded by the options
 			// builder.
@@ -171,11 +130,13 @@ func (f *walker) Configure() Director {
 		// the extent is, so we know if we need to make this query?
 		//
 		//
-		artefacts, _ := bs.buildAll() // TODO: check error
+		artefacts, err := bs.buildAll()
 
-		// Announce the availability of the navigator via UsePlugin interface
-		ctx, _ := artefacts.o.Acceleration.Cancellation()
-		_ = services.Broker.Emit(ctx, services.TopicInterceptNavigator, artefacts.nav)
+		if err == nil {
+			// Announce the availability of the navigator via UsePlugin interface
+			ctx, _ := artefacts.o.Acceleration.Cancellation()
+			_ = services.Broker.Emit(ctx, services.TopicInterceptNavigator, artefacts.nav)
+		}
 
 		return &driver{
 			session{

director_test.go

@@ -59,6 +59,45 @@ var _ = Describe("Traverse", Ordered, func() {
 				})
 			})
 
+			When("Prime with subscription error", func() {
+				It("🧪 should: fail", func() {
+					defer leaktest.Check(GinkgoT())()
+
+					_, err := tv.Walk().Configure().Extent(tv.Prime(
+						tv.Using{
+							Root: RootPath,
+							Handler: func(_ *tv.Node) error {
+								return nil
+							},
+						},
+					)).Navigate()
+
+					Expect(err).NotTo(Succeed())
+				})
+			})
+
+			When("Prime with options build error", func() {
+				It("🧪 should: fail", func() {
+					defer leaktest.Check(GinkgoT())()
+
+					_, err := tv.Walk().Configure().Extent(tv.Prime(
+						tv.Using{
+							Root:         RootPath,
+							Subscription: tv.SubscribeFiles,
+							Handler: func(_ *tv.Node) error {
+								return nil
+							},
+						},
+						tv.WithSubscription(tv.SubscribeFiles),
+						func(_ *pref.Options) error {
+							return errBuildOptions
+						},
+					)).Navigate()
+
+					Expect(err).To(MatchError(errBuildOptions))
+				})
+			})
+
 			When("Resume", func() {
 				It("🧪 should: walk resume navigation successfully", func() {
 					defer leaktest.Check(GinkgoT())()

internal/kernel/kernel-defs.go

@@ -1,19 +1,12 @@
 package kernel
 
-// type Navigator interface {
-// 	Navigate() (core.TraverseResult, error)
-// }
-
-// type NavigatorFunc func() (core.TraverseResult, error)
-
-// func (fn NavigatorFunc) Navigate() (core.TraverseResult, error) {
-// 	return fn()
-// }
-
 type navigationResult struct {
 	err error
 }
 
 func (r *navigationResult) Error() error {
 	return r.err
 }
+
+type navigatorImpl interface {
+}

internal/kernel/kernel-suite_test.go

@@ -0,0 +1,13 @@
+package kernel_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2" //nolint:revive // ok
+	. "github.com/onsi/gomega"    //nolint:revive // ok
+)
+
+func TestKernel(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Kernel Suite")
+}

internal/kernel/kernel-support_test.go

@@ -0,0 +1,6 @@
+package kernel_test
+
+const (
+	RootPath    = "/traversal-root-path"
+	RestorePath = "/from-restore-path"
+)

internal/kernel/navigator-base.go

@@ -0,0 +1,9 @@
+package kernel
+
+import (
+	"github.com/snivilised/traverse/pref"
+)
+
+type navigatorBase struct {
+	o *pref.Options
+}

internal/kernel/navigator-factory.go

@@ -1,19 +1,23 @@
 package kernel
 
 import (
-	"errors"
-
 	"github.com/snivilised/traverse/core"
 	"github.com/snivilised/traverse/enums"
 	"github.com/snivilised/traverse/pref"
 )
 
-func Prime(using core.Using, o *pref.Options) (core.Navigator, error) {
+func PrimeNav(using core.Using, o *pref.Options) (core.Navigator, error) {
 	return newController(&using, o)
 }
 
-func Resume(with core.As, o *pref.Options, resumption Resumption) (core.Navigator, error) {
-	controller, err := newController(&with.Using, o)
+func ResumeNav(with core.As, o *pref.Options,
+	resumption Resumption,
+) (controller core.Navigator, err error) {
+	controller, err = newController(&with.Using, o)
+
+	if err != nil {
+		return HadesNav(err)
+	}
 
 	return resumption.Decorate(controller), err
 }
@@ -28,47 +32,46 @@ func (f DecorateController) Decorate(source core.Navigator) core.Navigator {
 	return f(source)
 }
 
-func newController(using *core.Using, o *pref.Options) (core.Navigator, error) {
-	if err := using.Validate(); err != nil {
-		return nil, err
+func newController(using *core.Using,
+	o *pref.Options,
+) (navigator core.Navigator, err error) {
+	if err = using.Validate(); err != nil {
+		return
 	}
 
-	var (
-		impl core.Navigator
-		err  error
-	)
-
-	impl, err = newImpl(using, o)
+	impl := newImpl(using, o)
 
-	navigator := &navigationController{
+	navigator = &navigationController{
 		impl: impl,
 		o:    o,
 	}
 
-	return navigator, err
+	return
 }
 
-func newImpl(using *core.Using, o *pref.Options) (core.Navigator, error) {
-	var (
-		navigator    core.Navigator
-		err          error
-		subscription = using.Subscription
-	)
+func newImpl(using *core.Using,
+	o *pref.Options,
+) (navigator navigatorImpl) {
+	base := navigatorBase{
+		o: o,
+	}
 
-	switch subscription {
+	switch using.Subscription { //nolint:exhaustive // already validated by using
 	case enums.SubscribeFiles:
-		navigator = &navigationController{
-			o: o,
-		} // just temporary (create the impl's)
-	case enums.SubscribeFolders:
-		navigator = &navigationController{}
-	case enums.SubscribeFoldersWithFiles:
-		navigator = &navigationController{}
+		navigator = &navigatorFiles{
+			navigatorBase: base,
+		}
+
+	case enums.SubscribeFolders, enums.SubscribeFoldersWithFiles:
+		navigator = &navigatorFolders{
+			navigatorBase: base,
+		}
+
 	case enums.SubscribeUniversal:
-		navigator = &navigationController{}
-	case enums.SubscribeUndefined:
-		err = errors.New("invalid subscription")
+		navigator = &navigatorUniversal{
+			navigatorBase: base,
+		}
 	}
 
-	return navigator, err
+	return
 }