merge: v1.16.4 (#1245)

* correctly set cc and bcc headers (#1144)

* correct the error return from SendMailJob handle (#1147)

* fix: [#743] package make command generates correct code (#1151) (#1152)

(cherry picked from commit 93dc8a3)

* fix: [#749] The path is incorrect when publishing package files (#1157)

* chore: optimize assertions for package installation (#1160)

* fix: The configuredServiceProviders, publishes and publishGroups are not reset when Booting (#1162)

* fix: The configuredServiceProviders, publishes and publishGroups are not reset when Booting

* optimize

* fix: [#738] The Orm Creating event can be triggered when the query with the Model method (#1166)

* fix: [#738] The Orm Creating event can be triggered when the query with the Model method

* fix tests

* upgrade: v1.16.1

* fix: [#762] handle panic when using transaction (#1183)

* fix: [#762] handle panic when using transaction

* v1.16.2

* optimize

* fix lint

* fix: [#768] facades.DB will panic when migrating a new column (#1185)

* fix: [#768] facades.DB will panic when migrating a new column

* optimize

* optimize

* feat: [#770] Add a SelectRaw function for the ORM (#1186)

* fix: [#770] Add a SelectRaw function for the ORM

* fix: [#770] Add a SelectRaw function for the ORM

* fix ci

* upgrade: v1.16.3

* fix: comand cannot be run concurrently (#1243)

* fix: comand cannot be run concurrently

* fix ci

* fix ci

* optimize

* optimize

* optimize

* optimize

* optimize global options

* fix ci

* upgrade v1.16.4

* optimize

* optimize

---------

Co-authored-by: krishan kumar <84431594+kkumar-gcc@users.noreply.github.com>
Co-authored-by: ALMAS <almas.cc@icloud.com>

Author: 3 people

console/application.go

@@ -2,6 +2,7 @@ package console
 
 import (
 	"context"
+	"io"
 	"os"
 	"slices"
 	"strings"
@@ -26,25 +27,25 @@ var (
 )
 
 type Application struct {
-	instance   *cli.Command
+	commands   []cli.Command
+	name       string
+	usage      string
+	usageText  string
 	useArtisan bool
+	version    string
+	writer     io.Writer
 }
 
 // NewApplication Create a new Artisan application.
 // Will add artisan flag to the command if useArtisan is true.
 func NewApplication(name, usage, usageText, version string, useArtisan bool) console.Artisan {
-	instance := &cli.Command{}
-	instance.Name = name
-	instance.Usage = usage
-	instance.UsageText = usageText
-	instance.Version = version
-	instance.CommandNotFound = commandNotFound
-	instance.OnUsageError = onUsageError
-	instance.Flags = []cli.Flag{noANSIFlag}
-
 	return &Application{
-		instance:   instance,
+		name:       name,
+		usage:      usage,
+		usageText:  usageText,
 		useArtisan: useArtisan,
+		version:    version,
+		writer:     os.Stdout,
 	}
 }
 
@@ -59,16 +60,22 @@ func (r *Application) Register(commands []console.Command) {
 		cliCommand := cli.Command{
 			Name:  item.Signature(),
 			Usage: item.Description(),
-			Action: func(_ context.Context, cmd *cli.Command) error {
-				return item.Handle(NewCliContext(cmd))
+			Action: func(ctx context.Context, cmd *cli.Command) error {
+				cliCtx := NewCliContext(cmd)
+				if cliCtx.OptionBool("help") {
+					return cli.ShowCommandHelp(ctx, cmd, cmd.Name)
+				}
+
+				return item.Handle(cliCtx)
 			},
 			Category:     item.Extend().Category,
 			ArgsUsage:    item.Extend().ArgsUsage,
 			Flags:        flagsToCliFlags(item.Extend().Flags),
 			Arguments:    arguments,
 			OnUsageError: onUsageError,
 		}
-		r.instance.Commands = append(r.instance.Commands, &cliCommand)
+
+		r.commands = append(r.commands, cliCommand)
 	}
 }
 
@@ -123,13 +130,13 @@ func (r *Application) Run(args []string, exitIfArtisan bool) error {
 	}
 
 	if artisanIndex != -1 {
-		// Add --help if no command argument is provided.
+		command := r.command()
 		if artisanIndex+1 == len(args) {
-			args = append(args, "--help")
+			args = append(args, "help")
 		}
 
 		cliArgs := append([]string{args[0]}, args[artisanIndex+1:]...)
-		if err := r.instance.Run(context.Background(), cliArgs); err != nil {
+		if err := command.Run(context.Background(), cliArgs); err != nil {
 			if exitIfArtisan {
 				panic(err.Error())
 			}
@@ -145,6 +152,29 @@ func (r *Application) Run(args []string, exitIfArtisan bool) error {
 	return nil
 }
 
+func (r *Application) command() *cli.Command {
+	commands := make([]*cli.Command, len(r.commands))
+	for i, cmd := range r.commands {
+		commands[i] = &cmd
+	}
+
+	command := &cli.Command{}
+	command.CommandNotFound = commandNotFound
+	command.Commands = commands
+	command.Flags = []cli.Flag{noANSIFlag}
+	command.Name = r.name
+	command.OnUsageError = onUsageError
+	command.Usage = r.usage
+	command.UsageText = r.usageText
+	command.Version = r.version
+	command.Writer = r.writer
+
+	// There is a concurrency issue with urfave/cli v3 when help is not hidden.
+	command.HideHelp = true
+
+	return command
+}
+
 func flagsToCliFlags(flags []command.Flag) []cli.Flag {
 	var cliFlags []cli.Flag
 	for _, flag := range flags {
@@ -234,6 +264,34 @@ func flagsToCliFlags(flags []command.Flag) []cli.Flag {
 		}
 	}
 
+	var (
+		existHelp bool
+		existH    bool
+	)
+	for _, flag := range cliFlags {
+		names := flag.Names()
+		if slices.Contains(names, "help") {
+			existHelp = true
+		}
+		if slices.Contains(names, "h") {
+			existH = true
+		}
+	}
+
+	if !existHelp {
+		helpFlag := &cli.BoolFlag{
+			Name:        "help",
+			Usage:       "Show help",
+			HideDefault: true,
+		}
+		if !existH {
+			helpFlag.Aliases = []string{"h"}
+		}
+		cliFlags = append(cliFlags, helpFlag)
+	}
+
+	cliFlags = append(cliFlags, noANSIFlag)
+
 	return cliFlags
 }
 

console/application_test.go

@@ -1,6 +1,8 @@
 package console
 
 import (
+	"sync"
+	"sync/atomic"
 	"testing"
 	"time"
 
@@ -11,16 +13,47 @@ import (
 	"github.com/goravel/framework/contracts/console/command"
 )
 
-var testCommand = 0
+var (
+	testCommand  int64
+	testCommand1 atomic.Int64
+	testCommand2 atomic.Int64
+)
 
 func TestRun(t *testing.T) {
+	testCommand = 0
 	cliApp := NewApplication("test", "test", "test", "test", true)
 	cliApp.Register([]console.Command{
 		&TestCommand{},
 	})
 
 	assert.NoError(t, cliApp.Call("test"))
-	assert.Equal(t, 1, testCommand)
+	assert.Equal(t, int64(1), testCommand)
+}
+
+func TestRun_Concurrent(t *testing.T) {
+	testCommand1.Store(0)
+	testCommand2.Store(0)
+
+	cliApp := NewApplication("test", "test", "test", "test", true)
+	cliApp.Register([]console.Command{
+		&TestCommand1{},
+		&TestCommand2{},
+	})
+
+	var wg sync.WaitGroup
+	for i := 0; i < 100; i++ {
+		wg.Add(1)
+		go func() {
+			_ = cliApp.Call("test1")
+			_ = cliApp.Call("test2")
+			wg.Done()
+		}()
+	}
+
+	wg.Wait()
+
+	assert.Equal(t, int64(100), testCommand1.Load())
+	assert.Equal(t, int64(100), testCommand2.Load())
 }
 
 func TestFlagsToCliFlags(t *testing.T) {
@@ -43,7 +76,7 @@ func TestFlagsToCliFlags(t *testing.T) {
 	assert.NotNil(t, cliFlags)
 
 	// Assert that the number of CLI flags matches the number of command flags
-	assert.Equal(t, len(cliFlags), len(flags))
+	assert.Equal(t, len(cliFlags), len(flags)+2) // +2 for noANSIFlag and helpFlag
 
 	// Assert that each CLI flag has the expected name, aliases, usage, required, and value
 	for i, flag := range flags {
@@ -438,3 +471,45 @@ func (receiver *TestCommand) Handle(ctx console.Context) error {
 
 	return nil
 }
+
+type TestCommand1 struct {
+}
+
+func (receiver *TestCommand1) Signature() string {
+	return "test1"
+}
+
+func (receiver *TestCommand1) Description() string {
+	return "Test command1"
+}
+
+func (receiver *TestCommand1) Extend() command.Extend {
+	return command.Extend{}
+}
+
+func (receiver *TestCommand1) Handle(ctx console.Context) error {
+	testCommand1.Add(1)
+
+	return nil
+}
+
+type TestCommand2 struct {
+}
+
+func (receiver *TestCommand2) Signature() string {
+	return "test2"
+}
+
+func (receiver *TestCommand2) Description() string {
+	return "Test command2"
+}
+
+func (receiver *TestCommand2) Extend() command.Extend {
+	return command.Extend{}
+}
+
+func (receiver *TestCommand2) Handle(ctx console.Context) error {
+	testCommand2.Add(1)
+
+	return nil
+}

console/cli_context.go

@@ -141,6 +141,10 @@ func (r *CliContext) Info(message string) {
 	color.Infoln(message)
 }
 
+func (r *CliContext) Instance() *cli.Command {
+	return r.instance
+}
+
 func (r *CliContext) Line(message string) {
 	color.Default().Println(message)
 }

console/cli_helper.go

@@ -25,7 +25,7 @@ func init() {
 	cli.CommandHelpTemplate = commandHelpTemplate
 	cli.SubcommandHelpTemplate = commandHelpTemplate
 	cli.VersionPrinter = printVersion
-	huh.ErrUserAborted = cli.Exit(color.Red().Sprint("Cancelled."), 0)
+	huh.ErrUserAborted = cli.Exit(color.Red().Sprint("Cancelled"), 0)
 }
 
 const maxLineLength = 10000
@@ -46,9 +46,7 @@ var (
    {{ (colorize .Usage) }}
 
 {{ yellow "Usage:" }}
-   {{template "usageTemplate" .}}{{with $root := .Root}}
-
-{{ yellow "Global options:" }}{{template "flagTemplate"  (sortVisibleFlags $root)}}{{end}}{{if .VisibleFlags}}
+   {{template "usageTemplate" .}}{{with $root := .Root}}{{end}}{{if .VisibleFlags}}
 
 {{ yellow "Options:" }}{{template "flagTemplate" (sortVisibleFlags .)}}{{end}}
 `
@@ -209,18 +207,6 @@ func handleNoANSI() {
 }
 
 func helpName(fullName string) string {
-	var namePath []string
-	for i, name := range strings.Split(fullName, " ") {
-		namePath = append(namePath, name)
-		if i == 0 {
-			namePath = append(namePath, "[global options]")
-		}
-	}
-
-	if len(namePath) > 1 {
-		fullName = strings.Join(namePath, " ")
-	}
-
 	return fullName
 }