What is canonical way to execute target function as a regular function?

[mloskot]

I believe the question in hand is not addressed in the Mage docs, so please consider the following simple target function which I hope is self-explanatory even w/o providing its domain context:

func (Environment) Init(environmentName string) error {
	mg.Deps(Environment.Config)

	env, exist := envsConfig.Environments[environmentName]
	if !exist {
		return say.error("Environment '%s' not found", environmentName)
	}

	for _, stack := range env.Stacks {
		mg.SerialDeps(mg.F(Stack.Init, stack.Path, environmentName))
	}

	return nil
}

Question: is the line mg.SerialDeps(mg.F(Stack.Init, stack.Path, environmentName)) a terrible hack or is close to canonical way of calling target function as a regular function?

If it is a hack, then what is the right way to do it?

I consciously wamt to avoid extracting definition of Stack.Init into a func stackInit callable by both Environment.Init or `Stack.Init.

[natefinch]

So, you can just call Init like a regular old function. Mage targets are just go functions. Putting it inside a call to mg.SerialDeps will mean that if the function has already been called previously with those arguments using mg.Deps or mg.SerialDeps, then it won't get executed again.

I'm not sure if that's the effect you're going for or not. If you don't care if the function gets executed a second time (or if you know that it won't because of how the code is structured) then you can just call Init(environmentName) like it's a normal go function (because it is).

It's a little hard to follow your example because I think you have some copy and paste errors from editing out the extraneous information, but this might be close?

func (Environment) Init(environmentName string) error {
	mg.Deps(Environment.Config)

	env, exist := envsConfig.Environments[environmentName]
	if !exist {
		return say.error("Environment '%s' not found", environmentName)
	}

	for _, stack := range env.Stacks {
		err := stack.Init(stack.Path)
		if err != nil {
			return fmt.Errorf("failed to run init on stack %q under environment %q: %w", stack.Path, environmentName, err)
		}
	}

	return nil
}

[mloskot]

First, @natefinch, thank you for the answer.

It's a little hard to follow your example because I think you have some copy and paste errors from editing out the extraneous information, but this might be close?

Unfortunately, it is not as stack.Init does not really exist - unless stack is auto-created for the Stack mg.Namespace but I'm failing to see how to access it.

However, I see where I did not make my example clear. I should have posted a minimal sample instead.

So. here is such self-contained example that should illustrate my issue better and the question is basically how to avoid the call to mg.SerialDeps (or mg.Deps)?

//go:build mage
// +build mage

package main

import (
	"fmt"

	"github.com/magefile/mage/mg"
)

type Stack mg.Namespace

func (Stack) Build(name string) error {
	fmt.Println("Building", name)
        // ... some lengthy logic here
        
	mg.SerialDeps(mg.F(Stack.Clean, name)) // How to simplify this ?

        // ... some lengthy logic here too
	return nil
}

func (Stack) Clean(name string) error {
	fmt.Println("Cleaning", name)
        // ... some lengthy logic here
	return nil
}

[natefinch]

Mage code is just go code. The examples sometimes ignore the receiver variable in mg.Namespace methods, but you can put it back. Then you can just call stack.Clean like you would in any other struct.

//go:build mage
// +build mage

package main

import (
	"fmt"

	"github.com/magefile/mage/mg"
)

type Stack mg.Namespace

//    ↓ add the receiver back
func (s Stack) Build(name string) error {
	fmt.Println("Building", name)
        
	s.Clean(name) // then you can use it like normal

	return nil
}

func (Stack) Clean(name string) error {
	fmt.Println("Cleaning", name)
	return nil
}

[mloskot]

Ha! 🤦 Thank you very much for patient mentoring.

p.s. I started using Go as a replacement for scripting in Bash after I discovered Mage, so here comes my lack of Go fu.

There is one case where this technique cannot be used, that is, when a function is not passed the instance of Stack

func (Environment) Build(name string) error {
	fmt.Println("Building", name)
        
        // How to ask Mage for the `s` of type `Stack` ?       
	s.Clean(name)

	return nil
}

The only way seems to be, for example:

func (Environment) Run(name string) error {
	var s Stack
	s.Build(name)

	return nil
}