#24 Allow to define multiple discovery directories. (#25)

Author: lexbritvin

app.go

@@ -3,7 +3,6 @@ package launchr
 import (
 	"errors"
 	"fmt"
-	"io/fs"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -33,7 +32,7 @@ type appImpl struct {
 	actionMngr action.Manager
 	pluginMngr PluginManager
 	config     Config
-	regFS      []fs.FS
+	mFS        []ManagedFS
 }
 
 // getPluginByType returns specific plugins from the app.
@@ -70,8 +69,8 @@ func (app *appImpl) Name() string         { return name }
 func (app *appImpl) GetWD() string        { return app.workDir }
 func (app *appImpl) Streams() cli.Streams { return app.streams }
 
-func (app *appImpl) AddDiscoveryFS(fs fs.FS) { app.regFS = append(app.regFS, fs) }
-func (app *appImpl) GetDiscoveryFS() []fs.FS { return app.regFS }
+func (app *appImpl) RegisterFS(fs ManagedFS)      { app.mFS = append(app.mFS, fs) }
+func (app *appImpl) GetRegisteredFS() []ManagedFS { return app.mFS }
 
 func (app *appImpl) AddService(s Service) {
 	info := s.ServiceInfo()
@@ -112,12 +111,12 @@ func (app *appImpl) init() error {
 	var err error
 	// Set working dir and config dir.
 	app.cfgDir = "." + name
-	app.workDir, err = filepath.Abs("./")
+	app.workDir, err = filepath.Abs(".")
 	if err != nil {
 		return err
 	}
-	app.regFS = make([]fs.FS, 0, 4)
-	app.AddDiscoveryFS(os.DirFS(app.workDir))
+	app.mFS = make([]ManagedFS, 0, 4)
+	app.RegisterFS(action.NewDiscoveryFS(os.DirFS(app.workDir), app.GetWD()))
 	// Prepare dependencies.
 	app.streams = cli.StandardStreams()
 	app.services = make(map[ServiceInfo]Service)
@@ -142,7 +141,7 @@ func (app *appImpl) init() error {
 
 	// Discover actions.
 	for _, p := range getPluginByType[ActionDiscoveryPlugin](app) {
-		for _, fs := range app.GetDiscoveryFS() {
+		for _, fs := range app.GetRegisteredFS() {
 			actions, err := p.DiscoverActions(fs)
 			if err != nil {
 				return err

internal/launchr/tools.go

@@ -6,7 +6,6 @@ import (
 	"os"
 	"path/filepath"
 	"reflect"
-	"strings"
 )
 
 // GetFsAbsPath returns absolute path for a FS struct.
@@ -44,41 +43,3 @@ func GetTypePkgPathName(v interface{}) (string, string) {
 	}
 	return t.PkgPath(), t.Name()
 }
-
-// ToCamelCase converts a string to CamelCase.
-// @todo reference module and license.
-func ToCamelCase(s string, capFirst bool) string {
-	s = strings.TrimSpace(s)
-	if s == "" {
-		return s
-	}
-
-	n := strings.Builder{}
-	n.Grow(len(s))
-	capNext := capFirst
-	for i, v := range []byte(s) {
-		vIsCap := v >= 'A' && v <= 'Z'
-		vIsLow := v >= 'a' && v <= 'z'
-		if capNext {
-			if vIsLow {
-				v += 'A'
-				v -= 'a'
-			}
-		} else if i == 0 {
-			if vIsCap {
-				v += 'a'
-				v -= 'A'
-			}
-		}
-		if vIsCap || vIsLow {
-			n.WriteByte(v)
-			capNext = false
-		} else if vIsNum := v >= '0' && v <= '9'; vIsNum {
-			n.WriteByte(v)
-			capNext = true
-		} else {
-			capNext = v == '_' || v == ' ' || v == '-' || v == '.'
-		}
-	}
-	return n.String()
-}

internal/launchr/types.go

@@ -26,10 +26,11 @@ type App interface {
 	// GetService retrieves a service of type v and assigns it to v.
 	// Panics if a service is not found.
 	GetService(v interface{})
-	// AddDiscoveryFS registers a File System for discovery of actions in launchr.
-	AddDiscoveryFS(fs fs.FS)
-	// GetDiscoveryFS returns an array of registered File Systems for action discovery.
-	GetDiscoveryFS() []fs.FS
+	// RegisterFS registers a File System in launchr.
+	// It may be a FS for action discovery, see action.DiscoveryFS.
+	RegisterFS(fs ManagedFS)
+	// GetRegisteredFS returns an array of registered File Systems.
+	GetRegisteredFS() []ManagedFS
 }
 
 // AppVersion stores application version.
@@ -146,3 +147,9 @@ type Service interface {
 func InitServiceInfo(si *ServiceInfo, s Service) {
 	si.pkgPath, si.typeName = GetTypePkgPathName(s)
 }
+
+// ManagedFS is a common interface for FS registered in launchr.
+type ManagedFS interface {
+	fs.FS
+	FS() fs.FS
+}

pkg/action/action.go

@@ -68,11 +68,14 @@ func (a *Action) Reset() { a.def = nil }
 // GetInput returns action input.
 func (a *Action) GetInput() Input { return a.input }
 
+// WorkDir returns action working directory.
+func (a *Action) WorkDir() string { return a.wd }
+
 // Filepath returns action file path.
 func (a *Action) Filepath() string { return a.fpath }
 
 // Dir returns an action file directory.
-func (a *Action) Dir() string { return filepath.Dir(filepath.Join(a.wd, a.Filepath())) }
+func (a *Action) Dir() string { return filepath.Dir(a.Filepath()) }
 
 // SetRunEnvironment sets environment to run the action.
 func (a *Action) SetRunEnvironment(env RunEnvironment) { a.env = env }

pkg/action/action_test.go

@@ -13,7 +13,7 @@ func Test_Action(t *testing.T) {
 	assert := assert.New(t)
 	// Prepare an action.
 	fs := _getFsMapActions(1, validFullYaml, true)
-	ad := NewYamlDiscovery(fs)
+	ad := NewYamlDiscovery(NewDiscoveryFS(fs, ""))
 	actions, err := ad.Discover()
 	assert.NoError(err)
 	assert.NotEmpty(actions)

pkg/action/discover.go

@@ -20,7 +20,25 @@ var actionsSubdir = strings.Join([]string{"", actionsDirname, ""}, string(filepa
 // DiscoveryPlugin is a launchr plugin to discover actions.
 type DiscoveryPlugin interface {
 	launchr.Plugin
-	DiscoverActions(fs fs.FS) ([]*Action, error)
+	DiscoverActions(fs launchr.ManagedFS) ([]*Action, error)
+}
+
+// DiscoveryFS is a file system to discover actions.
+type DiscoveryFS struct {
+	fs fs.FS
+	wd string
+}
+
+// NewDiscoveryFS creates a DiscoveryFS given fs - a filesystem to discover
+// and wd - working directory for an action, leave empty for current path.
+func NewDiscoveryFS(fs fs.FS, wd string) DiscoveryFS { return DiscoveryFS{fs, wd} }
+
+// FS implements launchr.ManagedFS.
+func (f DiscoveryFS) FS() fs.FS { return f.fs }
+
+// Open implements fs.FS and decorates the managed fs.
+func (f DiscoveryFS) Open(name string) (fs.File, error) {
+	return f.FS().Open(name)
 }
 
 // FileLoadFn is a type for loading a file.
@@ -34,15 +52,15 @@ type DiscoveryStrategy interface {
 
 // Discovery defines a common functionality for discovering action files.
 type Discovery struct {
-	fs  fs.FS
-	cwd string
-	s   DiscoveryStrategy
+	fs    DiscoveryFS
+	fsDir string
+	s     DiscoveryStrategy
 }
 
 // NewDiscovery creates an instance of action discovery.
-func NewDiscovery(fs fs.FS, ds DiscoveryStrategy) *Discovery {
-	cwd := launchr.GetFsAbsPath(fs)
-	return &Discovery{fs, cwd, ds}
+func NewDiscovery(fs DiscoveryFS, ds DiscoveryStrategy) *Discovery {
+	fsDir := launchr.GetFsAbsPath(fs)
+	return &Discovery{fs, fsDir, ds}
 }
 
 func (ad *Discovery) isValid(path string, d fs.DirEntry) bool {
@@ -123,7 +141,7 @@ func (ad *Discovery) parseFile(f string) *Action {
 	if id == "" {
 		panic(fmt.Errorf("action id cannot be empty, file %q", f))
 	}
-	a := NewAction(id, ad.cwd, f)
+	a := NewAction(id, absPath(ad.fs.wd), filepath.Join(ad.fsDir, f))
 	a.Loader = ad.s.Loader(
 		func() (fs.File, error) { return ad.fs.Open(f) },
 		envProcessor{},

pkg/action/discover_test.go

@@ -8,6 +8,7 @@ import (
 	"testing/fstest"
 
 	"github.com/moby/moby/pkg/namesgenerator"
+	"github.com/stretchr/testify/assert"
 )
 
 func Test_Discover(t *testing.T) {
@@ -44,7 +45,7 @@ func Test_Discover(t *testing.T) {
 
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			ad := NewYamlDiscovery(tt.fs)
+			ad := NewYamlDiscovery(NewDiscoveryFS(tt.fs, ""))
 			actions, err := ad.Discover()
 			if err != nil {
 				t.Errorf("unexpected error %v", err)
@@ -56,6 +57,27 @@ func Test_Discover(t *testing.T) {
 	}
 }
 
+func Test_Discover_ActionWD(t *testing.T) {
+	// Test if working directory is correctly set to actions on discovery.
+	tfs := _getFsMapActions(1, validEmptyVersionYaml, true)
+	var expFPath string
+	for expFPath = range tfs {
+		break
+	}
+	expectedWD := "expectedWD"
+	ad := NewYamlDiscovery(NewDiscoveryFS(tfs, expectedWD))
+	actions, err := ad.Discover()
+	assert.NoError(t, err)
+	assert.Equal(t, expFPath, actions[0].fpath)
+	assert.Equal(t, absPath(expectedWD), actions[0].wd)
+
+	ad = NewYamlDiscovery(NewDiscoveryFS(tfs, ""))
+	actions, err = ad.Discover()
+	assert.NoError(t, err)
+	assert.Equal(t, expFPath, actions[0].fpath)
+	assert.Equal(t, absPath(""), actions[0].wd)
+}
+
 type dirEntry string
 
 func (d dirEntry) DirEntry() fs.DirEntry {
@@ -94,7 +116,7 @@ func Test_Discover_isValid(t *testing.T) {
 	}
 
 	// Run tests.
-	ad := NewYamlDiscovery(fstest.MapFS{})
+	ad := NewYamlDiscovery(NewDiscoveryFS(fstest.MapFS{}, ""))
 	for _, tt := range tts {
 		tt := tt
 		t.Run(tt.name, func(t *testing.T) {

pkg/action/env.container.go

@@ -158,7 +158,7 @@ func (c *containerEnv) Execute(ctx context.Context, a *Action) (err error) {
 	if c.useVolWD {
 		// @todo test somehow.
 		cli.Println(`Flag "--%s" is set. Copying the working directory inside the container.`, containerFlagUseVolumeWD)
-		err = c.copyDirToContainer(ctx, cid, ".", containerHostMount)
+		err = c.copyDirToContainer(ctx, cid, a.WorkDir(), containerHostMount)
 		if err != nil {
 			return err
 		}
@@ -229,7 +229,7 @@ func (c *containerEnv) Execute(ctx context.Context, a *Action) (err error) {
 	// Copy back the result from the volume.
 	// @todo it's a bad implementation considering consequential runs, need to find a better way to sync with remote.
 	if c.useVolWD {
-		path := absPath(".")
+		path := a.WorkDir()
 		cli.Println(`Flag "--%s" is set. Copying back the result of the action run.`, containerFlagUseVolumeWD)
 		err = c.copyFromContainer(ctx, cid, containerHostMount, filepath.Dir(path), filepath.Base(path))
 		defer func() {
@@ -384,7 +384,7 @@ func (c *containerEnv) containerCreate(ctx context.Context, a *Action, opts *typ
 		}
 	} else {
 		createOpts.Binds = []string{
-			absPath(".") + ":" + containerHostMount,
+			absPath(a.WorkDir()) + ":" + containerHostMount,
 			absPath(a.Dir()) + ":" + containerActionMount,
 		}
 	}

pkg/action/env.container_test.go

@@ -74,6 +74,7 @@ func testContainerAction(aconf *DefAction) *Action {
 		ID:     "test",
 		Loader: &Definition{Action: aconf},
 		fpath:  "my/action/test/action.yaml",
+		wd:     absPath("test"),
 	}
 }
 
@@ -292,7 +293,7 @@ func Test_ContainerExec_containerCreate(t *testing.T) {
 
 	eqCfg := *runCfg
 	eqCfg.Binds = []string{
-		absPath(".") + ":" + containerHostMount,
+		absPath(a.WorkDir()) + ":" + containerHostMount,
 		absPath(a.Dir()) + ":" + containerActionMount,
 	}
 	eqCfg.WorkingDir = containerHostMount
@@ -522,7 +523,7 @@ func Test_ContainerExec(t *testing.T) {
 		NetworkMode:   types.NetworkModeHost,
 		ExtraHosts:    actConf.ExtraHosts,
 		Binds: []string{
-			absPath(".") + ":" + containerHostMount,
+			absPath(act.WorkDir()) + ":" + containerHostMount,
 			absPath(act.Dir()) + ":" + containerActionMount,
 		},
 		WorkingDir:   containerHostMount,

pkg/action/yaml.discovery.go

@@ -12,7 +12,7 @@ import (
 var rgxYamlFile = regexp.MustCompile(`^action\.(yaml|yml)$`)
 
 // NewYamlDiscovery is an implementation of discovery for searching yaml files.
-func NewYamlDiscovery(fs fs.FS) *Discovery {
+func NewYamlDiscovery(fs DiscoveryFS) *Discovery {
 	return NewDiscovery(fs, YamlDiscoveryStrategy{TargetRgx: rgxYamlFile})
 }