add value processors. Now it's possible for user to process options i… (#36)

add value processors. Now it's possible for user to process options input before passing to command

Author: iignatevich

app.go

@@ -125,6 +125,7 @@ func (app *appImpl) init() error {
 	app.actionMngr = action.NewManager(
 		action.WithDefaultRunEnvironment,
 		action.WithContainerRunEnvironmentConfig(app.config, name+"_"),
+		action.WithValueProcessors(),
 	)
 
 	// Register services for other modules.

pkg/action/action.go

@@ -4,14 +4,23 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
+	"fmt"
 	"path/filepath"
 
-	"github.com/santhosh-tekuri/jsonschema/v5"
+	jsvalidate "github.com/santhosh-tekuri/jsonschema/v5"
 
 	"github.com/launchrctl/launchr/pkg/cli"
+	"github.com/launchrctl/launchr/pkg/jsonschema"
 	"github.com/launchrctl/launchr/pkg/types"
 )
 
+var (
+	errInvalidProcessor          = errors.New("invalid configuration, processor is required")
+	errTplNotApplicableProcessor = "invalid configuration, processor can't be applied to value of type %s"
+	errTplNonExistProcessor      = "requested processor %q doesn't exist"
+)
+
 // Action is an action definition with a contextual id (name), working directory path
 // and a runtime context such as input arguments and options.
 type Action struct {
@@ -25,8 +34,9 @@ type Action struct {
 	fpath string      // fpath is a path to action definition file.
 	def   *Definition // def is an action definition. Loaded by Loader, may be nil when not initialized.
 
-	env   RunEnvironment // env is the run environment driver to execute the action.
-	input Input          // input is a container for env variables.
+	env        RunEnvironment            // env is the run environment driver to execute the action.
+	input      Input                     // input is a container for env variables.
+	processors map[string]ValueProcessor // processors are ValueProcessors for manipulating input.
 }
 
 // Input is a container for action input arguments and options.
@@ -68,6 +78,16 @@ func (a *Action) Clone() *Action {
 	return c
 }
 
+// SetProcessors sets the value processors for an Action.
+func (a *Action) SetProcessors(list map[string]ValueProcessor) {
+	a.processors = list
+}
+
+// GetProcessors returns processors map.
+func (a *Action) GetProcessors() map[string]ValueProcessor {
+	return a.processors
+}
+
 // Reset unsets loaded action to force reload.
 func (a *Action) Reset() { a.def = nil }
 
@@ -128,14 +148,94 @@ func (a *Action) SetInput(input Input) (err error) {
 	//if err = a.ValidateInput(input); err != nil {
 	//	return err
 	//}
+
+	err = a.processArgs(input.Args)
+	if err != nil {
+		return err
+	}
+
+	err = a.processOptions(input.Opts)
+	if err != nil {
+		return err
+	}
+
 	a.input = input
 	// Reset to load the action file again with new replacements.
 	a.Reset()
 	return a.EnsureLoaded()
 }
 
+func (a *Action) processOptions(opts TypeOpts) error {
+	for _, optDef := range a.ActionDef().Options {
+		if _, ok := opts[optDef.Name]; !ok {
+			continue
+		}
+
+		value := opts[optDef.Name]
+		toApply := optDef.Process
+
+		value, err := a.processValue(value, optDef.Type, toApply)
+		if err != nil {
+			return err
+		}
+
+		opts[optDef.Name] = value
+	}
+
+	return nil
+}
+
+func (a *Action) processArgs(args TypeArgs) error {
+	for _, argDef := range a.ActionDef().Arguments {
+		if _, ok := args[argDef.Name]; !ok {
+			continue
+		}
+
+		value := args[argDef.Name]
+		toApply := argDef.Process
+		value, err := a.processValue(value, argDef.Type, toApply)
+		if err != nil {
+			return err
+		}
+
+		args[argDef.Name] = value
+	}
+
+	return nil
+}
+
+func (a *Action) processValue(value interface{}, valueType jsonschema.Type, toApplyProcessors []ValueProcessDef) (interface{}, error) {
+	newValue := value
+	processors := a.GetProcessors()
+
+	for _, processor := range toApplyProcessors {
+		if processor.Processor == "" {
+			return value, errInvalidProcessor
+		}
+
+		proc, ok := processors[processor.Processor]
+		if !ok {
+			return value, fmt.Errorf(errTplNonExistProcessor, processor.Processor)
+		}
+
+		if !proc.IsApplicable(valueType) {
+			return value, fmt.Errorf(errTplNotApplicableProcessor, valueType)
+		}
+
+		processedValue, err := proc.Execute(newValue, processor.Options)
+		if err != nil {
+			return value, err
+		}
+
+		newValue = processedValue
+	}
+
+	return newValue, nil
+}
+
 // ValidateInput validates arguments and options according to
 // a specified json schema in action definition.
+// @todo move to jsonschema
 func (a *Action) ValidateInput(inp Input) error {
 	jsch := a.JSONSchema()
 	// @todo cache jsonschema and resources.
@@ -144,7 +244,7 @@ func (a *Action) ValidateInput(inp Input) error {
 		return err
 	}
 	buf := bytes.NewBuffer(b)
-	c := jsonschema.NewCompiler()
+	c := jsvalidate.NewCompiler()
 	err = c.AddResource(a.Filepath(), buf)
 	if err != nil {
 		return err

pkg/action/manager.go

@@ -2,6 +2,7 @@ package action
 
 import (
 	"context"
+	"fmt"
 	"strconv"
 	"sync"
 	"time"
@@ -22,6 +23,10 @@ type Manager interface {
 	Get(id string) (*Action, bool)
 	// GetRef returns an original action value from the storage.
 	GetRef(id string) (*Action, bool)
+	// AddValueProcessor adds processor to list of available processors
+	AddValueProcessor(name string, vp ValueProcessor)
+	// GetValueProcessors returns list of available processors
+	GetValueProcessors() map[string]ValueProcessor
 	// Decorate decorates an action with given behaviors and returns its copy.
 	// If functions withFn are not provided, default functions are applied.
 	Decorate(a *Action, withFn ...DecorateWithFn) *Action
@@ -49,6 +54,7 @@ type actionManagerMap struct {
 	mx          sync.Mutex
 	mxRun       sync.Mutex
 	dwFns       []DecorateWithFn
+	processors  map[string]ValueProcessor
 }
 
 // NewManager constructs a new action manager.
@@ -57,6 +63,7 @@ func NewManager(withFns ...DecorateWithFn) Manager {
 		actionStore: make(map[string]*Action),
 		runStore:    make(map[string]RunInfo),
 		dwFns:       withFns,
+		processors:  make(map[string]ValueProcessor),
 	}
 }
 
@@ -97,6 +104,18 @@ func (m *actionManagerMap) GetRef(id string) (*Action, bool) {
 	return a, ok
 }
 
+func (m *actionManagerMap) AddValueProcessor(name string, vp ValueProcessor) {
+	if _, ok := m.processors[name]; ok {
+		panic(fmt.Sprintf("processor `%q` with the same name already exists", name))
+	}
+
+	m.processors[name] = vp
+}
+
+func (m *actionManagerMap) GetValueProcessors() map[string]ValueProcessor {
+	return m.processors
+}
+
 func (m *actionManagerMap) Decorate(a *Action, withFns ...DecorateWithFn) *Action {
 	if a == nil {
 		return nil
@@ -206,3 +225,10 @@ func WithContainerRunEnvironmentConfig(cfg launchr.Config, prefix string) Decora
 		}
 	}
 }
+
+// WithValueProcessors sets processors for action from manager.
+func WithValueProcessors() DecorateWithFn {
+	return func(m Manager, a *Action) {
+		a.SetProcessors(m.GetValueProcessors())
+	}
+}

pkg/action/process.go

@@ -0,0 +1,44 @@
+package action
+
+import (
+	"github.com/launchrctl/launchr/pkg/jsonschema"
+)
+
+// ValueProcessor defines an interface for processing a value based on its type and some options.
+type ValueProcessor interface {
+	IsApplicable(valueType jsonschema.Type) bool
+	Execute(value interface{}, options map[string]interface{}) (interface{}, error)
+}
+
+// ValueProcessorFn is a function signature used as a callback in processors.
+type ValueProcessorFn func(value interface{}, options map[string]interface{}) (interface{}, error)
+
+// NewFuncProcessor creates a new instance of FuncProcessor with the specified formats and callback.
+func NewFuncProcessor(formats []jsonschema.Type, callback ValueProcessorFn) FuncProcessor {
+	return FuncProcessor{
+		applicableFormats: formats,
+		callback:          callback,
+	}
+}
+
+// FuncProcessor represents a processor that applies a callback function to values based on certain applicable formats.
+type FuncProcessor struct {
+	applicableFormats []jsonschema.Type
+	callback          ValueProcessorFn
+}
+
+// IsApplicable checks if the given valueType is present in the applicableFormats slice of the FuncProcessor.
+func (p FuncProcessor) IsApplicable(valueType jsonschema.Type) bool {
+	for _, item := range p.applicableFormats {
+		if valueType == item {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Execute applies the callback function of the FuncProcessor to the given value with options.
+func (p FuncProcessor) Execute(value interface{}, options map[string]interface{}) (interface{}, error) {
+	return p.callback(value, options)
+}

pkg/action/yaml.def.go

@@ -247,10 +247,11 @@ func (l *ArgumentsList) UnmarshalYAML(nodeList *yaml.Node) (err error) {
 
 // Argument stores command arguments declaration.
 type Argument struct {
-	Name        string          `yaml:"name"`
-	Title       string          `yaml:"title"`
-	Description string          `yaml:"description"`
-	Type        jsonschema.Type `yaml:"type"`
+	Name        string            `yaml:"name"`
+	Title       string            `yaml:"title"`
+	Description string            `yaml:"description"`
+	Type        jsonschema.Type   `yaml:"type"`
+	Process     []ValueProcessDef `yaml:"process"`
 	RawMap      map[string]interface{}
 }
 
@@ -277,16 +278,23 @@ func (l *OptionsList) UnmarshalYAML(nodeList *yaml.Node) (err error) {
 
 // Option stores command options declaration.
 type Option struct {
-	Name        string          `yaml:"name"`
-	Shorthand   string          `yaml:"shorthand"` // @todo test definition, validate, catch panic if overlay, add to readme.
-	Title       string          `yaml:"title"`
-	Description string          `yaml:"description"`
-	Type        jsonschema.Type `yaml:"type"`
-	Default     interface{}     `yaml:"default"`
-	Required    bool            `yaml:"required"` // @todo that conflicts with json schema object definition
+	Name        string            `yaml:"name"`
+	Shorthand   string            `yaml:"shorthand"` // @todo test definition, validate, catch panic if overlay, add to readme.
+	Title       string            `yaml:"title"`
+	Description string            `yaml:"description"`
+	Type        jsonschema.Type   `yaml:"type"`
+	Default     interface{}       `yaml:"default"`
+	Required    bool              `yaml:"required"` // @todo that conflicts with json schema object definition
+	Process     []ValueProcessDef `yaml:"process"`
 	RawMap      map[string]interface{}
 }
 
+// ValueProcessDef stores information about processor and options that should be applied to processor.
+type ValueProcessDef struct {
+	Processor string                 `yaml:"processor"`
+	Options   map[string]interface{} `yaml:"options"`
+}
+
 // UnmarshalYAML implements yaml.Unmarshaler to parse Option.
 func (o *Option) UnmarshalYAML(node *yaml.Node) (err error) {
 	type yamlT Option