

// redo - global option redo
// 
// Redo global option via automatic code-gen

package main

////////////////////////////////////////////////////////////////////////////
// Program: redo
// Purpose: global option redo
// Authors: Myself <me@mine.org> (c) 2022-2023, All rights reserved
////////////////////////////////////////////////////////////////////////////

import (
//  	"fmt"
//  	"os"

//  	"github.com/go-easygen/go-flags"
)

// Template for main starts here

//////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions

////////////////////////////////////////////////////////////////////////////
// Global variables definitions

//  var (
//          progname  = "redo"
//          version   = "0.1.0"
//          date = "2023-01-23"

//  	// opts store all the configurable options
//  	opts optsT
//  )
//  
//  var gfParser = flags.NewParser(&opts, flags.Default)

////////////////////////////////////////////////////////////////////////////
// Function definitions

//==========================================================================
// Function main
//  func main() {
//  	opts.Version = showVersion
//  	opts.Verbflg = func() {
//  		opts.Verbose++
//  	}
//  
//  	if _, err := gfParser.Parse(); err != nil {
//  		fmt.Println()
//  		gfParser.WriteHelp(os.Stdout)
//  		os.Exit(1)
//  	}
//  	fmt.Println()
//  	//DoRedo()
//  }
//
//  //==========================================================================
//  // support functions
//
//  func showVersion() {
//   	fmt.Fprintf(os.Stderr, "redo - global option redo, version %s\n", version)
//  	fmt.Fprintf(os.Stderr, "Built on %s\n", date)
//   	fmt.Fprintf(os.Stderr, "Copyright (C) 2022-2023, Myself <me@mine.org>\n\n")
//  	fmt.Fprintf(os.Stderr, "Redo global option via automatic code-gen\n")
//  	os.Exit(0)
//  }
// Template for main ends here

// DoRedo implements the business logic of command `redo`
//  func DoRedo() error {
//  	return nil
//  }

// Template for type define starts here

// The optsT type defines all the configurable options from cli.
type optsT struct {
	Host	string	`short:"H" long:"host" env:"REDO_HOST" description:"Host address" default:"localhost"`
	Port	int	`short:"p" long:"port" env:"REDO_PORT" description:"Listening port" default:"80"`
	Force	bool	`short:"f" long:"force" env:"REDO_FORCE" description:"Force start"`
	Verbflg func()  `short:"v" long:"verbose" description:"Verbose mode (Multiple -v options increase the verbosity)"`
	Verbose int
	Version func()  `short:"V" long:"version" description:"Show program version and exit"`
}
// Template for type define ends here


// Template for "build" CLI handling starts here
////////////////////////////////////////////////////////////////////////////
// Program: redo
// Purpose: global option redo
// Authors: Myself <me@mine.org> (c) 2022-2023, All rights reserved
////////////////////////////////////////////////////////////////////////////

//  package main

//  import (
//  	"fmt"
//  	"os"
//
//  	"github.com/go-easygen/go-flags/clis"
//  )

// *** Sub-command: build ***

////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions

// The BuildCommand type defines all the configurable options from cli.
//  type BuildCommand struct {
//  	Dir	string	`long:"dir" description:"source code root dir" default:"./"`
//  }

//  
//  var buildCommand BuildCommand
//  
//  ////////////////////////////////////////////////////////////////////////////
//  // Function definitions
//  
//  func init() {
//  	gfParser.AddCommand("build",
//  		"Build the network application",
//  		"Usage:\n  redo build [Options] Arch(i386|amd64)",
//  		&buildCommand)
//  }
//
//  func (x *BuildCommand) Execute(args []string) error {
//   	fmt.Fprintf(os.Stderr, "Build the network application\n")
//   	// fmt.Fprintf(os.Stderr, "Copyright (C) 2022-2023, Myself <me@mine.org>\n\n")
//   	clis.Setup("redo::build", opts.Verbose)
//   	clis.Verbose(1, "Doing Build, with %+v, %+v", opts, args)
//   	// fmt.Println(x.Dir)
//  	return x.Exec(args)
//  }
//  
// // Exec implements the business logic of command `build`
// func (x *BuildCommand) Exec(args []string) error {
// 	// err := ...
// 	// clis.WarnOn("build::Exec", err)
// 	// or,
// 	// clis.AbortOn("build::Exec", err)
// 	return nil
// }
// Template for "build" CLI handling ends here

// Template for "install" CLI handling starts here
////////////////////////////////////////////////////////////////////////////
// Program: redo
// Purpose: global option redo
// Authors: Myself <me@mine.org> (c) 2022-2023, All rights reserved
////////////////////////////////////////////////////////////////////////////

//  package main

//  import (
//  	"fmt"
//  	"os"
//
//  	"github.com/go-easygen/go-flags/clis"
//  )

// *** Sub-command: install ***

////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions

// The InstallCommand type defines all the configurable options from cli.
//  type InstallCommand struct {
//  	Dir	string	`short:"d" description:"source code root dir" default:"./"`
//  	Suffix	string	`long:"suffix" description:"source file suffix" default:".go,.c,.s"`
//  }

//  
//  var installCommand InstallCommand
//  
//  ////////////////////////////////////////////////////////////////////////////
//  // Function definitions
//  
//  func init() {
//  	gfParser.AddCommand("install",
//  		"Install the network application",
//  		"The add command adds a file to the repository. Use -a to add all files",
//  		&installCommand)
//  }
//
//  func (x *InstallCommand) Execute(args []string) error {
//   	fmt.Fprintf(os.Stderr, "Install the network application\n")
//   	// fmt.Fprintf(os.Stderr, "Copyright (C) 2022-2023, Myself <me@mine.org>\n\n")
//   	clis.Setup("redo::install", opts.Verbose)
//   	clis.Verbose(1, "Doing Install, with %+v, %+v", opts, args)
//   	// fmt.Println(x.Dir, x.Suffix)
//  	return x.Exec(args)
//  }
//  
// // Exec implements the business logic of command `install`
// func (x *InstallCommand) Exec(args []string) error {
// 	// err := ...
// 	// clis.WarnOn("install::Exec", err)
// 	// or,
// 	// clis.AbortOn("install::Exec", err)
// 	return nil
// }
// Template for "install" CLI handling ends here

// Template for "publish" CLI handling starts here
////////////////////////////////////////////////////////////////////////////
// Program: redo
// Purpose: global option redo
// Authors: Myself <me@mine.org> (c) 2022-2023, All rights reserved
////////////////////////////////////////////////////////////////////////////

//  package main

//  import (
//  	"fmt"
//  	"os"
//
//  	"github.com/go-easygen/go-flags/clis"
//  )

// *** Sub-command: publish ***

////////////////////////////////////////////////////////////////////////////
// Constant and data type/structure definitions

// The PublishCommand type defines all the configurable options from cli.
//  type PublishCommand struct {
//  	Dir	string	`short:"d" long:"dir" description:"publish dir" required:"true"`
//  	Suffix	[]string	`short:"s" long:"suffix" description:"source file suffix for publish" choice:".go" choice:".c" choice:".h"`
//  	Out	string	`short:"o" long:"out" description:"output filename"`
//  
//  	// Example of positional arguments
//  	Args struct {
//  	  ID   string
//  	  Num  int
//  	  Rest []string
//  	} `positional-args:"yes" required:"yes"`
//  }

//  
//  var publishCommand PublishCommand
//  
//  ////////////////////////////////////////////////////////////////////////////
//  // Function definitions
//  
//  func init() {
//  	gfParser.AddCommand("publish",
//  		"Publish the network application",
//  		"Publish the built network application to central repo",
//  		&publishCommand)
//  }
//
//  func (x *PublishCommand) Execute(args []string) error {
//   	fmt.Fprintf(os.Stderr, "Publish the network application\n")
//   	// fmt.Fprintf(os.Stderr, "Copyright (C) 2022-2023, Myself <me@mine.org>\n\n")
//   	clis.Setup("redo::publish", opts.Verbose)
//   	clis.Verbose(1, "Doing Publish, with %+v, %+v", opts, args)
//   	// fmt.Println(x.Dir, x.Suffix, x.Out, x.Args)
//  	return x.Exec(args)
//  }
//  
// // Exec implements the business logic of command `publish`
// func (x *PublishCommand) Exec(args []string) error {
// 	// err := ...
// 	// clis.WarnOn("publish::Exec", err)
// 	// or,
// 	// clis.AbortOn("publish::Exec", err)
// 	return nil
// }
// Template for "publish" CLI handling ends here


