mirror of
https://gitee.com/johng/gf.git
synced 2024-12-02 04:07:47 +08:00
136 lines
3.4 KiB
Go
136 lines
3.4 KiB
Go
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
|
||
//
|
||
// This Source Code Form is subject to the terms of the MIT License.
|
||
// If a copy of the MIT was not distributed with this file,
|
||
// You can obtain one at https://github.com/gogf/gf.
|
||
//
|
||
|
||
// Package command provides console operations, like options/arguments reading.
|
||
package command
|
||
|
||
import (
|
||
"os"
|
||
"regexp"
|
||
"strings"
|
||
)
|
||
|
||
var (
|
||
defaultParsedArgs = make([]string, 0)
|
||
defaultParsedOptions = make(map[string]string)
|
||
argumentOptionRegex = regexp.MustCompile(`^\-{1,2}([\w\?\.\-]+)(=){0,1}(.*)$`)
|
||
)
|
||
|
||
// Init does custom initialization.
|
||
func Init(args ...string) {
|
||
if len(args) == 0 {
|
||
if len(defaultParsedArgs) == 0 && len(defaultParsedOptions) == 0 {
|
||
args = os.Args
|
||
} else {
|
||
return
|
||
}
|
||
} else {
|
||
defaultParsedArgs = make([]string, 0)
|
||
defaultParsedOptions = make(map[string]string)
|
||
}
|
||
// Parsing os.Args with default algorithm.
|
||
defaultParsedArgs, defaultParsedOptions = ParseUsingDefaultAlgorithm(args...)
|
||
}
|
||
|
||
// ParseUsingDefaultAlgorithm parses arguments using default algorithm.
|
||
func ParseUsingDefaultAlgorithm(args ...string) (parsedArgs []string, parsedOptions map[string]string) {
|
||
parsedArgs = make([]string, 0)
|
||
parsedOptions = make(map[string]string)
|
||
for i := 0; i < len(args); {
|
||
array := argumentOptionRegex.FindStringSubmatch(args[i])
|
||
if len(array) > 2 {
|
||
if array[2] == "=" {
|
||
parsedOptions[array[1]] = array[3]
|
||
} else if i < len(args)-1 {
|
||
if len(args[i+1]) > 0 && args[i+1][0] == '-' {
|
||
// Example: gf gen -d -n 1
|
||
parsedOptions[array[1]] = array[3]
|
||
} else {
|
||
// Example: gf gen -n 2
|
||
parsedOptions[array[1]] = args[i+1]
|
||
i += 2
|
||
continue
|
||
}
|
||
} else {
|
||
// Example: gf gen -h
|
||
parsedOptions[array[1]] = array[3]
|
||
}
|
||
} else {
|
||
parsedArgs = append(parsedArgs, args[i])
|
||
}
|
||
i++
|
||
}
|
||
return
|
||
}
|
||
|
||
// GetOpt returns the option value named `name`.
|
||
func GetOpt(name string, def ...string) string {
|
||
Init()
|
||
if v, ok := defaultParsedOptions[name]; ok {
|
||
return v
|
||
}
|
||
if len(def) > 0 {
|
||
return def[0]
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// GetOptAll returns all parsed options.
|
||
func GetOptAll() map[string]string {
|
||
Init()
|
||
return defaultParsedOptions
|
||
}
|
||
|
||
// ContainsOpt checks whether option named `name` exist in the arguments.
|
||
func ContainsOpt(name string) bool {
|
||
Init()
|
||
_, ok := defaultParsedOptions[name]
|
||
return ok
|
||
}
|
||
|
||
// GetArg returns the argument at `index`.
|
||
func GetArg(index int, def ...string) string {
|
||
Init()
|
||
if index < len(defaultParsedArgs) {
|
||
return defaultParsedArgs[index]
|
||
}
|
||
if len(def) > 0 {
|
||
return def[0]
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// GetArgAll returns all parsed arguments.
|
||
func GetArgAll() []string {
|
||
Init()
|
||
return defaultParsedArgs
|
||
}
|
||
|
||
// GetOptWithEnv returns the command line argument of the specified `key`.
|
||
// If the argument does not exist, then it returns the environment variable with specified `key`.
|
||
// It returns the default value `def` if none of them exists.
|
||
//
|
||
// Fetching Rules:
|
||
// 1. Command line arguments are in lowercase format, eg: gf.package.variable;
|
||
// 2. Environment arguments are in uppercase format, eg: GF_PACKAGE_VARIABLE；
|
||
func GetOptWithEnv(key string, def ...string) string {
|
||
cmdKey := strings.ToLower(strings.ReplaceAll(key, "_", "."))
|
||
if ContainsOpt(cmdKey) {
|
||
return GetOpt(cmdKey)
|
||
} else {
|
||
envKey := strings.ToUpper(strings.ReplaceAll(key, ".", "_"))
|
||
if r, ok := os.LookupEnv(envKey); ok {
|
||
return r
|
||
} else {
|
||
if len(def) > 0 {
|
||
return def[0]
|
||
}
|
||
}
|
||
}
|
||
return ""
|
||
}
|