feat(proxy): implement dry run mode (#146)

src/app/command/bootstrap.go

@@ -275,7 +275,7 @@ func (b *Bootstrap) logger() *slog.Logger {
 	logPath = utils.ResolvePath(logPath)
 	logPath, _ = utils.EnsurePathAt(logPath, defaultLogFilename, perm, b.Vfs)
 
-	ws := zapcore.AddSync(&lumberjack.Logger{
+	sync := zapcore.AddSync(&lumberjack.Logger{
 		Filename:   logPath,
 		MaxSize:    int(b.LoggingCFG.MaxSizeInMb()),
 		MaxBackups: int(b.LoggingCFG.MaxNoOfBackups()),
@@ -285,7 +285,7 @@ func (b *Bootstrap) logger() *slog.Logger {
 	config.EncodeTime = zapcore.TimeEncoderOfLayout(b.LoggingCFG.TimeFormat())
 	core := zapcore.NewCore(
 		zapcore.NewJSONEncoder(config),
-		ws,
+		sync,
 		b.level(b.LoggingCFG.Level()),
 	)
 

src/app/proxy/common/static-info.go

@@ -11,6 +11,7 @@ type StaticInfo struct {
 	Meta   JournalMetaInfo
 	Legacy string
 	Trash  string
+	Fake   string
 }
 
 func (i *StaticInfo) JournalLocation(name, parent string) string {

src/app/proxy/enter-shrink.go

@@ -171,11 +171,26 @@ func EnterShrink(
 	if agent, err = ipc.New(
 		params.Configs.Advanced,
 		params.Inputs.ParamSet.Native.KnownBy,
+		params.Vfs,
+		params.Inputs.Root.PreviewFam.Native.DryRun,
 	); err != nil {
-		if errors.Is(err, ipc.ErrUsingDummyExecutor) {
+		if errors.Is(err, ipc.ErrUseDummyExecutor) {
 			// todo: notify ui via bubbletea
 			//
 			fmt.Printf("===> 💥💥💥 REVERTING TO DUMMY EXECUTOR !!!!\n")
+
+			agent = ipc.Pacify(
+				params.Configs.Advanced,
+				params.Inputs.ParamSet.Native.KnownBy,
+				params.Vfs,
+				ipc.PacifyWithDummy,
+			)
+		} else if errors.Is(err, ipc.ErrUnsupportedExecutor) {
+			fmt.Printf("===> 💥💥💥 Undefined EXECUTOR: '%v' !!!!\n",
+				params.Configs.Advanced.Executable().Symbol(),
+			)
+
+			return err
 		}
 	}
 

src/app/proxy/filing/dry-run-finder-decorator.go

@@ -0,0 +1,54 @@
+package filing
+
+import (
+	"path/filepath"
+
+	"github.com/snivilised/extendio/xfs/nav"
+	"github.com/snivilised/pixa/src/app/proxy/common"
+)
+
+func ComposeFake(name, label string) string {
+	return FilenameWithoutExtension(name) + label + filepath.Ext(name)
+}
+
+type dryRunPathFinderDecorator struct {
+	decorated *PathFinder
+}
+
+func (d *dryRunPathFinderDecorator) Transfer(info *common.PathInfo) (folder, file string) {
+	if d.decorated.TransparentInput() {
+		folder = info.Origin
+		file = info.Item.Extension.Name
+	} else {
+		folder, file = d.decorated.Transfer(info)
+	}
+
+	return folder, file
+}
+
+func (d *dryRunPathFinderDecorator) Result(info *common.PathInfo) (folder, file string) {
+	if d.decorated.TransparentInput() {
+		folder = info.Origin
+		file = ComposeFake(info.Item.Extension.Name, d.decorated.Statics().Fake)
+	} else {
+		folder, file = d.decorated.Result(info)
+	}
+
+	return folder, file
+}
+
+func (d *dryRunPathFinderDecorator) TransparentInput() bool {
+	return d.decorated.TransparentInput()
+}
+
+func (d *dryRunPathFinderDecorator) JournalFullPath(item *nav.TraverseItem) string {
+	return d.decorated.JournalFullPath(item)
+}
+
+func (d *dryRunPathFinderDecorator) Statics() *common.StaticInfo {
+	return d.decorated.Statics()
+}
+
+func (d *dryRunPathFinderDecorator) Scheme() string {
+	return d.decorated.Scheme()
+}

src/app/proxy/filing/path-finder.go

@@ -24,6 +24,7 @@ func NewFinder(
 			Adhoc:  advancedCFG.AdhocLabel(),
 			Legacy: advancedCFG.LegacyLabel(),
 			Trash:  advancedCFG.TrashLabel(),
+			Fake:   advancedCFG.FakeLabel(),
 		},
 		Ext: &ExtensionTransformation{
 			Transformers: strings.Split(extensions.Transforms(), ","),
@@ -67,6 +68,12 @@ func NewFinder(
 		Tag:        common.JournalTag,
 	}
 
+	if inputs.Root.PreviewFam.Native.DryRun {
+		return &dryRunPathFinderDecorator{
+			decorated: finder,
+		}
+	}
+
 	return finder
 }
 

src/app/proxy/ipc/agent.go

@@ -2,10 +2,16 @@ package ipc
 
 import (
 	"github.com/snivilised/cobrass/src/clif"
+	"github.com/snivilised/extendio/xfs/storage"
 	"github.com/snivilised/pixa/src/app/proxy/common"
 	"github.com/snivilised/pixa/src/cfg"
 )
 
+const (
+	PacifyWithDummy = true
+	PacifyWithFake  = false
+)
+
 type baseAgent struct {
 	knownBy clif.KnownByCollection
 	program common.Executor
@@ -14,22 +20,18 @@ type baseAgent struct {
 func New(
 	advanced cfg.AdvancedConfig,
 	knownBy clif.KnownByCollection,
+	vfs storage.VirtualFS,
+	dryRun bool,
 ) (common.ExecutionAgent, error) {
 	var (
 		agent common.ExecutionAgent
-		// dummy uses the same agent as magick
-		//
-		dummy = &magickAgent{
-			baseAgent{
-				knownBy: knownBy,
-				program: &DummyExecutor{
-					Name: advanced.Executable().Symbol(),
-				},
-			},
-		}
-		err error
+		err   error
 	)
 
+	if dryRun {
+		return Pacify(advanced, knownBy, vfs, PacifyWithFake), nil
+	}
+
 	switch advanced.Executable().Symbol() {
 	case "magick":
 		agent = &magickAgent{
@@ -42,16 +44,46 @@ func New(
 		}
 
 		if !agent.IsInstalled() {
-			err = ErrUsingDummyExecutor
-
-			agent = dummy
+			err = ErrUseDummyExecutor
 		}
 
 	case "dummy":
-		err = ErrUsingDummyExecutor
+		agent = Pacify(advanced, knownBy, vfs, PacifyWithDummy)
 
-		agent = dummy
+	case "fake":
+		agent = Pacify(advanced, knownBy, vfs, PacifyWithFake)
+
+	default:
+		err = ErrUnsupportedExecutor
 	}
 
 	return agent, err
 }
+
+func Pacify(
+	advanced cfg.AdvancedConfig,
+	knownBy clif.KnownByCollection,
+	vfs storage.VirtualFS,
+	dummy bool,
+) common.ExecutionAgent {
+	if dummy {
+		return &magickAgent{
+			baseAgent{
+				knownBy: knownBy,
+				program: &ProgramExecutor{
+					Name: advanced.Executable().Symbol(),
+				},
+			},
+		}
+	}
+
+	return &fakeAgent{
+		baseAgent: baseAgent{
+			knownBy: knownBy,
+			program: &ProgramExecutor{
+				Name: advanced.Executable().Symbol(),
+			},
+		},
+		vfs: vfs,
+	}
+}

src/app/proxy/ipc/execution-agent-fake.go

@@ -0,0 +1,49 @@
+package ipc
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/snivilised/cobrass/src/clif"
+	"github.com/snivilised/extendio/xfs/storage"
+	"github.com/snivilised/pixa/src/cfg"
+)
+
+type fakeAgent struct {
+	baseAgent
+	vfs      storage.VirtualFS
+	advanced cfg.AdvancedConfig
+}
+
+func (a *fakeAgent) IsInstalled() bool {
+	_, err := a.program.Look()
+
+	return err == nil
+}
+
+func (a *fakeAgent) Invoke(thirdPartyCL clif.ThirdPartyCommandLine, source, destination string) error {
+	var (
+		err  error
+		fake *os.File
+	)
+
+	before := []string{source}
+
+	if a.vfs.FileExists(destination) {
+		return os.ErrExist
+	}
+
+	if fake, err = a.vfs.Create(destination); err != nil {
+		return err
+	}
+
+	// for this to work, the dry run decorator needs to be in place ...
+	//
+	fmt.Printf("---> 🚀 created fake destination at '%v'\n", destination)
+
+	defer fake.Close()
+
+	return a.program.Execute(
+		clif.Expand(before, thirdPartyCL, destination)...,
+	)
+}

src/app/proxy/ipc/internal-ipc-errors.go

@@ -6,4 +6,5 @@ import "errors"
 // internally and are of no significance to the user directly, which
 // means they also don't need to be i18n error messages.
 
-var ErrUsingDummyExecutor = errors.New("using dummy executor")
+var ErrUseDummyExecutor = errors.New("using dummy executor")
+var ErrUnsupportedExecutor = errors.New("unsupported executor")