github.com/gobuffalo/buffalo-cli/v2@v2.0.0-alpha.15.0.20200919213536-a7350c8e6799/cli/cmds/newapp/exec.go (about)

     1  package newapp
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"io"
     7  
     8  	"github.com/gobuffalo/buffalo-cli/v2/internal/flagger"
     9  	"github.com/gobuffalo/plugins"
    10  	"github.com/gobuffalo/plugins/plugflag"
    11  	"github.com/gobuffalo/plugins/plugio"
    12  	"github.com/gobuffalo/plugins/plugprint"
    13  	"github.com/spf13/pflag"
    14  )
    15  
    16  type Executer struct {
    17  	pluginsFn plugins.Feeder
    18  	flags     *pflag.FlagSet
    19  	help      bool
    20  }
    21  
    22  func (Executer) PluginName() string {
    23  	return "newapp/executer"
    24  }
    25  
    26  func (e *Executer) WithPlugins(f plugins.Feeder) {
    27  	e.pluginsFn = f
    28  }
    29  
    30  func (e *Executer) ScopedPlugins() []plugins.Plugin {
    31  	if e.pluginsFn == nil {
    32  		return nil
    33  	}
    34  
    35  	var plugs []plugins.Plugin
    36  	for _, p := range e.pluginsFn() {
    37  		switch p.(type) {
    38  		case Stdouter:
    39  			plugs = append(plugs, p)
    40  		case Stdiner:
    41  			plugs = append(plugs, p)
    42  		case Stderrer:
    43  			plugs = append(plugs, p)
    44  		case Newapper:
    45  			plugs = append(plugs, p)
    46  		case AfterNewapper:
    47  			plugs = append(plugs, p)
    48  		case Flagger:
    49  			plugs = append(plugs, p)
    50  		case Pflagger:
    51  			plugs = append(plugs, p)
    52  		}
    53  	}
    54  	return plugs
    55  }
    56  
    57  func (e *Executer) Execute(ctx context.Context, root string, name string, args []string) error {
    58  	flags := e.Flags()
    59  	if err := flags.Parse(args); err != nil {
    60  		return err
    61  	}
    62  
    63  	plugs := e.ScopedPlugins()
    64  	if e.help {
    65  		return plugprint.Print(plugio.Stdout(plugs...), e)
    66  	}
    67  
    68  	var during []Newapper
    69  	var after []AfterNewapper
    70  
    71  	for _, p := range plugs {
    72  		switch t := p.(type) {
    73  		case Newapper:
    74  			during = append(during, t)
    75  		case AfterNewapper:
    76  			after = append(after, t)
    77  		}
    78  	}
    79  
    80  	var err error
    81  	for _, p := range during {
    82  		fmt.Println(">>>TODO DURING ", p.PluginName())
    83  		if err = p.Newapp(ctx, root, name, args); err != nil {
    84  			break
    85  		}
    86  	}
    87  
    88  	for _, p := range after {
    89  		fmt.Println(">>>TODO AFTER ", p.PluginName())
    90  		if err := p.AfterNewapp(ctx, root, name, args, err); err != nil {
    91  			return err
    92  		}
    93  	}
    94  	return err
    95  }
    96  
    97  func (ex *Executer) PrintFlags(w io.Writer) error {
    98  	flags := ex.Flags()
    99  	flags.SetOutput(w)
   100  	flags.PrintDefaults()
   101  	return nil
   102  }
   103  
   104  func (ex *Executer) Flags() *pflag.FlagSet {
   105  	if ex.flags != nil {
   106  		return ex.flags
   107  	}
   108  	flags := (&Cmd{}).Flags()
   109  	flags.BoolVarP(&ex.help, "help", "h", false, "print this help")
   110  
   111  	plugs := ex.ScopedPlugins()
   112  
   113  	for _, p := range plugs {
   114  		switch t := p.(type) {
   115  		case Flagger:
   116  			for _, f := range plugflag.Clean(p, t.NewappFlags()) {
   117  				flags.AddGoFlag(f)
   118  			}
   119  		case Pflagger:
   120  			for _, f := range flagger.CleanPflags(p, t.NewappFlags()) {
   121  				flags.AddFlag(f)
   122  			}
   123  		}
   124  	}
   125  
   126  	ex.flags = flags
   127  	return ex.flags
   128  }
   129  
   130  func Execute(plugs []plugins.Plugin, ctx context.Context, root string, name string, args []string) error {
   131  	e := &Executer{}
   132  	e.WithPlugins(func() []plugins.Plugin {
   133  		return plugs
   134  	})
   135  	return e.Execute(ctx, root, name, args)
   136  }