feat: send flagset instead of cmd

License: MIT
Signed-off-by: Henrique Dias <hacdias@gmail.com>

cmd/cmds_ls.go

@@ -17,7 +17,7 @@ var cmdsLsCmd = &cobra.Command{
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
 		s, err := d.store.Settings.Get()
 		checkErr(err)
-		evt := mustGetString(cmd, "event")
+		evt := mustGetString(cmd.Flags(), "event")
 
 		if evt == "" {
 			printEvents(s.Commands)

cmd/config.go

@@ -44,12 +44,12 @@ func addConfigFlags(flags *pflag.FlagSet) {
 	flags.Bool("branding.disableExternal", false, "disable external links such as GitHub links")
 }
 
-func getAuthentication(cmd *cobra.Command) (settings.AuthMethod, auth.Auther) {
+func getAuthentication(flags *pflag.FlagSet) (settings.AuthMethod, auth.Auther) {
-	method := settings.AuthMethod(mustGetString(cmd, "auth.method"))
+	method := settings.AuthMethod(mustGetString(flags, "auth.method"))
 
 	var auther auth.Auther
 	if method == auth.MethodProxyAuth {
-		header := mustGetString(cmd, "auth.header")
+		header := mustGetString(flags, "auth.header")
 		if header == "" {
 			panic(nerrors.New("you must set the flag 'auth.header' for method 'proxy'"))
 		}
@@ -63,9 +63,9 @@ func getAuthentication(cmd *cobra.Command) (settings.AuthMethod, auth.Auther) {
 	if method == auth.MethodJSONAuth {
 		jsonAuth := &auth.JSONAuth{}
 
-		host := mustGetString(cmd, "recaptcha.host")
+		host := mustGetString(flags, "recaptcha.host")
-		key := mustGetString(cmd, "recaptcha.key")
+		key := mustGetString(flags, "recaptcha.key")
-		secret := mustGetString(cmd, "recaptcha.secret")
+		secret := mustGetString(flags, "recaptcha.secret")
 
 		if key != "" && secret != "" {
 			jsonAuth.ReCaptcha = &auth.ReCaptcha{

cmd/config_init.go

@@ -24,30 +24,31 @@ override the options.`,
 	Args: cobra.NoArgs,
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
 		defaults := settings.UserDefaults{}
-		getUserDefaults(cmd, &defaults, true)
+		flags := cmd.Flags()
-		authMethod, auther := getAuthentication(cmd)
+		getUserDefaults(flags, &defaults, true)
+		authMethod, auther := getAuthentication(flags)
 
 		s := &settings.Settings{
 			Key:        generateRandomBytes(64), // 256 bit
-			Signup:     mustGetBool(cmd, "signup"),
+			Signup:     mustGetBool(flags, "signup"),
-			Shell:      strings.Split(strings.TrimSpace(mustGetString(cmd, "shell")), " "),
+			Shell:      strings.Split(strings.TrimSpace(mustGetString(flags, "shell")), " "),
 			AuthMethod: authMethod,
 			Defaults:   defaults,
 			Branding: settings.Branding{
-				Name:            mustGetString(cmd, "branding.name"),
+				Name:            mustGetString(flags, "branding.name"),
-				DisableExternal: mustGetBool(cmd, "branding.disableExternal"),
+				DisableExternal: mustGetBool(flags, "branding.disableExternal"),
-				Files:           mustGetString(cmd, "branding.files"),
+				Files:           mustGetString(flags, "branding.files"),
 			},
 		}
 
 		ser := &settings.Server{
-			Address: mustGetString(cmd, "address"),
+			Address: mustGetString(flags, "address"),
-			Root:    mustGetString(cmd, "root"),
+			Root:    mustGetString(flags, "root"),
-			BaseURL: mustGetString(cmd, "baseurl"),
+			BaseURL: mustGetString(flags, "baseurl"),
-			TLSKey:  mustGetString(cmd, "key"),
+			TLSKey:  mustGetString(flags, "key"),
-			TLSCert: mustGetString(cmd, "cert"),
+			TLSCert: mustGetString(flags, "cert"),
-			Port:    mustGetString(cmd, "port"),
+			Port:    mustGetString(flags, "port"),
-			Log:     mustGetString(cmd, "log"),
+			Log:     mustGetString(flags, "log"),
 		}
 
 		err := d.store.Settings.Save(s)

cmd/config_set.go

@@ -20,6 +20,7 @@ var configSetCmd = &cobra.Command{
 you want to change.`,
 	Args: cobra.NoArgs,
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
+		flags := cmd.Flags()
 		set, err := d.store.Settings.Get()
 		checkErr(err)
 
@@ -27,42 +28,42 @@ you want to change.`,
 		checkErr(err)
 
 		hasAuth := false
-		cmd.Flags().Visit(func(flag *pflag.Flag) {
+		flags.Visit(func(flag *pflag.Flag) {
 			switch flag.Name {
 			case "baseurl":
-				ser.BaseURL = mustGetString(cmd, flag.Name)
+				ser.BaseURL = mustGetString(flags, flag.Name)
 			case "root":
-				ser.Root = mustGetString(cmd, flag.Name)
+				ser.Root = mustGetString(flags, flag.Name)
 			case "cert":
-				ser.TLSCert = mustGetString(cmd, flag.Name)
+				ser.TLSCert = mustGetString(flags, flag.Name)
 			case "key":
-				ser.TLSKey = mustGetString(cmd, flag.Name)
+				ser.TLSKey = mustGetString(flags, flag.Name)
 			case "address":
-				ser.Address = mustGetString(cmd, flag.Name)
+				ser.Address = mustGetString(flags, flag.Name)
 			case "port":
-				ser.Port = mustGetString(cmd, flag.Name)
+				ser.Port = mustGetString(flags, flag.Name)
 			case "log":
-				ser.Log = mustGetString(cmd, flag.Name)
+				ser.Log = mustGetString(flags, flag.Name)
 			case "signup":
-				set.Signup = mustGetBool(cmd, flag.Name)
+				set.Signup = mustGetBool(flags, flag.Name)
 			case "auth.method":
 				hasAuth = true
 			case "shell":
-				set.Shell = strings.Split(strings.TrimSpace(mustGetString(cmd, flag.Name)), " ")
+				set.Shell = strings.Split(strings.TrimSpace(mustGetString(flags, flag.Name)), " ")
 			case "branding.name":
-				set.Branding.Name = mustGetString(cmd, flag.Name)
+				set.Branding.Name = mustGetString(flags, flag.Name)
 			case "branding.disableExternal":
-				set.Branding.DisableExternal = mustGetBool(cmd, flag.Name)
+				set.Branding.DisableExternal = mustGetBool(flags, flag.Name)
 			case "branding.files":
-				set.Branding.Files = mustGetString(cmd, flag.Name)
+				set.Branding.Files = mustGetString(flags, flag.Name)
 			}
 		})
 
-		getUserDefaults(cmd, &set.Defaults, false)
+		getUserDefaults(flags, &set.Defaults, false)
 
 		var auther auth.Auther
 		if hasAuth {
-			set.AuthMethod, auther = getAuthentication(cmd)
+			set.AuthMethod, auther = getAuthentication(flags)
 			err = d.store.Auth.Save(auther)
 			checkErr(err)
 		} else {

cmd/docs.go

@@ -40,7 +40,7 @@ var docsCmd = &cobra.Command{
 	Hidden: true,
 	Args:   cobra.NoArgs,
 	Run: func(cmd *cobra.Command, args []string) {
-		dir := mustGetString(cmd, "path")
+		dir := mustGetString(cmd.Flags(), "path")
 		generateDocs(rootCmd, dir)
 		names := []string{}
 

cmd/rules.go

@@ -8,6 +8,7 @@ import (
 	"github.com/filebrowser/filebrowser/v2/storage"
 	"github.com/filebrowser/filebrowser/v2/users"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 func init() {
@@ -28,7 +29,7 @@ rules.`,
 }
 
 func runRules(st *storage.Storage, cmd *cobra.Command, users func(*users.User), global func(*settings.Settings)) {
-	id := getUserIdentifier(cmd)
+	id := getUserIdentifier(cmd.Flags())
 	if id != nil {
 		user, err := st.Users.Get("", id)
 		checkErr(err)
@@ -51,9 +52,9 @@ func runRules(st *storage.Storage, cmd *cobra.Command, users func(*users.User),
 	printRules(settings.Rules, id)
 }
 
-func getUserIdentifier(cmd *cobra.Command) interface{} {
+func getUserIdentifier(flags *pflag.FlagSet) interface{} {
-	id := mustGetUint(cmd, "id")
+	id := mustGetUint(flags, "id")
-	username := mustGetString(cmd, "username")
+	username := mustGetString(flags, "username")
 
 	if id != 0 {
 		return id

cmd/rules_add.go

@@ -21,8 +21,8 @@ var rulesAddCmd = &cobra.Command{
 	Long:  `Add a global rule or user rule.`,
 	Args:  cobra.ExactArgs(1),
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		allow := mustGetBool(cmd, "allow")
+		allow := mustGetBool(cmd.Flags(), "allow")
-		regex := mustGetBool(cmd, "regex")
+		regex := mustGetBool(cmd.Flags(), "regex")
 		exp := args[0]
 
 		if regex {

cmd/upgrade.go

@@ -21,10 +21,10 @@ import share links because they are incompatible with
 this version.`,
 	Args: cobra.NoArgs,
 	Run: func(cmd *cobra.Command, args []string) {
-		oldDB := mustGetString(cmd, "old.database")
+		flags := cmd.Flags()
-		oldConf := mustGetString(cmd, "old.config")
+		oldDB := mustGetString(flags, "old.database")
-
+		oldConf := mustGetString(flags, "old.config")
-		err := importer.Import(oldDB, oldConf, mustGetStringViperFlag(cmd.Flags(), "database"))
+		err := importer.Import(oldDB, oldConf, mustGetStringViperFlag(flags, "database"))
 		checkErr(err)
 	},
 }

cmd/users.go

@@ -76,53 +76,53 @@ func addUserFlags(flags *pflag.FlagSet) {
 	flags.String("viewMode", string(users.ListViewMode), "view mode for users")
 }
 
-func getViewMode(cmd *cobra.Command) users.ViewMode {
+func getViewMode(flags *pflag.FlagSet) users.ViewMode {
-	viewMode := users.ViewMode(mustGetString(cmd, "viewMode"))
+	viewMode := users.ViewMode(mustGetString(flags, "viewMode"))
 	if viewMode != users.ListViewMode && viewMode != users.MosaicViewMode {
 		checkErr(errors.New("view mode must be \"" + string(users.ListViewMode) + "\" or \"" + string(users.MosaicViewMode) + "\""))
 	}
 	return viewMode
 }
 
-func getUserDefaults(cmd *cobra.Command, defaults *settings.UserDefaults, all bool) {
+func getUserDefaults(flags *pflag.FlagSet, defaults *settings.UserDefaults, all bool) {
 	visit := func(flag *pflag.Flag) {
 		switch flag.Name {
 		case "scope":
-			defaults.Scope = mustGetString(cmd, flag.Name)
+			defaults.Scope = mustGetString(flags, flag.Name)
 		case "locale":
-			defaults.Locale = mustGetString(cmd, flag.Name)
+			defaults.Locale = mustGetString(flags, flag.Name)
 		case "viewMode":
-			defaults.ViewMode = getViewMode(cmd)
+			defaults.ViewMode = getViewMode(flags)
 		case "perm.admin":
-			defaults.Perm.Admin = mustGetBool(cmd, flag.Name)
+			defaults.Perm.Admin = mustGetBool(flags, flag.Name)
 		case "perm.execute":
-			defaults.Perm.Execute = mustGetBool(cmd, flag.Name)
+			defaults.Perm.Execute = mustGetBool(flags, flag.Name)
 		case "perm.create":
-			defaults.Perm.Create = mustGetBool(cmd, flag.Name)
+			defaults.Perm.Create = mustGetBool(flags, flag.Name)
 		case "perm.rename":
-			defaults.Perm.Rename = mustGetBool(cmd, flag.Name)
+			defaults.Perm.Rename = mustGetBool(flags, flag.Name)
 		case "perm.modify":
-			defaults.Perm.Modify = mustGetBool(cmd, flag.Name)
+			defaults.Perm.Modify = mustGetBool(flags, flag.Name)
 		case "perm.delete":
-			defaults.Perm.Delete = mustGetBool(cmd, flag.Name)
+			defaults.Perm.Delete = mustGetBool(flags, flag.Name)
 		case "perm.share":
-			defaults.Perm.Share = mustGetBool(cmd, flag.Name)
+			defaults.Perm.Share = mustGetBool(flags, flag.Name)
 		case "perm.download":
-			defaults.Perm.Download = mustGetBool(cmd, flag.Name)
+			defaults.Perm.Download = mustGetBool(flags, flag.Name)
 		case "commands":
-			commands, err := cmd.Flags().GetStringSlice(flag.Name)
+			commands, err := flags.GetStringSlice(flag.Name)
 			checkErr(err)
 			defaults.Commands = commands
 		case "sorting.by":
-			defaults.Sorting.By = mustGetString(cmd, flag.Name)
+			defaults.Sorting.By = mustGetString(flags, flag.Name)
 		case "sorting.asc":
-			defaults.Sorting.Asc = mustGetBool(cmd, flag.Name)
+			defaults.Sorting.Asc = mustGetBool(flags, flag.Name)
 		}
 	}
 
 	if all {
-		cmd.Flags().VisitAll(visit)
+		flags.VisitAll(visit)
 	} else {
-		cmd.Flags().Visit(visit)
+		flags.Visit(visit)
 	}
 }

cmd/users_add.go

@@ -18,7 +18,7 @@ var usersAddCmd = &cobra.Command{
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
 		s, err := d.store.Settings.Get()
 		checkErr(err)
-		getUserDefaults(cmd, &s.Defaults, false)
+		getUserDefaults(cmd.Flags(), &s.Defaults, false)
 
 		password, err := users.HashPwd(args[1])
 		checkErr(err)
@@ -26,7 +26,7 @@ var usersAddCmd = &cobra.Command{
 		user := &users.User{
 			Username:     args[0],
 			Password:     password,
-			LockPassword: mustGetBool(cmd, "lockPassword"),
+			LockPassword: mustGetBool(cmd.Flags(), "lockPassword"),
 		}
 
 		s.Defaults.Apply(user)

cmd/users_import.go

@@ -32,7 +32,7 @@ var usersImportCmd = &cobra.Command{
 			checkErr(err)
 		}
 
-		overwrite := mustGetBool(cmd, "overwrite")
+		overwrite := mustGetBool(cmd.Flags(), "overwrite")
 
 		for _, user := range list {
 			old, err := d.store.Users.Get("", user.ID)

cmd/users_update.go

@@ -22,8 +22,9 @@ options you want to change.`,
 	Args: cobra.ExactArgs(1),
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
 		username, id := parseUsernameOrID(args[0])
-		password := mustGetString(cmd, "password")
+		flags := cmd.Flags()
-		newUsername := mustGetString(cmd, "username")
+		password := mustGetString(flags, "password")
+		newUsername := mustGetString(flags, "username")
 
 		var err error
 		var user *users.User
@@ -44,14 +45,14 @@ options you want to change.`,
 			Sorting:  user.Sorting,
 			Commands: user.Commands,
 		}
-		getUserDefaults(cmd, &defaults, false)
+		getUserDefaults(flags, &defaults, false)
 		user.Scope = defaults.Scope
 		user.Locale = defaults.Locale
 		user.ViewMode = defaults.ViewMode
 		user.Perm = defaults.Perm
 		user.Commands = defaults.Commands
 		user.Sorting = defaults.Sorting
-		user.LockPassword = mustGetBool(cmd, "lockPassword")
+		user.LockPassword = mustGetBool(flags, "lockPassword")
 
 		if newUsername != "" {
 			user.Username = newUsername

cmd/utils.go

@@ -13,6 +13,7 @@ import (
 	"github.com/filebrowser/filebrowser/v2/storage"
 	"github.com/filebrowser/filebrowser/v2/storage/bolt"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 	yaml "gopkg.in/yaml.v2"
 )
 
@@ -23,20 +24,20 @@ func checkErr(err error) {
 	}
 }
 
-func mustGetString(cmd *cobra.Command, flag string) string {
+func mustGetString(flags *pflag.FlagSet, flag string) string {
-	s, err := cmd.Flags().GetString(flag)
+	s, err := flags.GetString(flag)
 	checkErr(err)
 	return s
 }
 
-func mustGetBool(cmd *cobra.Command, flag string) bool {
+func mustGetBool(flags *pflag.FlagSet, flag string) bool {
-	b, err := cmd.Flags().GetBool(flag)
+	b, err := flags.GetBool(flag)
 	checkErr(err)
 	return b
 }
 
-func mustGetUint(cmd *cobra.Command, flag string) uint {
+func mustGetUint(flags *pflag.FlagSet, flag string) uint {
-	b, err := cmd.Flags().GetUint(flag)
+	b, err := flags.GetUint(flag)
 	checkErr(err)
 	return b
 }