Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "ShowCommandCompletions", "(", "ctx", "*", "Context", ",", "command", "string", ")", "{", "c", ":=", "ctx", ".", "App", ".", "Command", "(", "command", ")", "\n", "if", "c", "!=", "nil", "&&", "c", ".", "BashComplete", "!=", "nil", "{", "c", ".", "BashComplete", "(", "ctx", ")", "\n", "}", "\n", "}" ]

[ "ShowCommandCompletions", "prints", "the", "custom", "completions", "for", "a", "given", "command" ]

[ "func", "(", "c", "CommandCategories", ")", "AddCommand", "(", "category", "string", ",", "command", "Command", ")", "CommandCategories", "{", "for", "_", ",", "commandCategory", ":=", "range", "c", "{", "if", "commandCategory", ".", "Name", "==", "category", "{", "commandCategory", ".", "Commands", "=", "append", "(", "commandCategory", ".", "Commands", ",", "command", ")", "\n", "return", "c", "\n", "}", "\n", "}", "\n", "return", "append", "(", "c", ",", "&", "CommandCategory", "{", "Name", ":", "category", ",", "Commands", ":", "[", "]", "Command", "{", "command", "}", "}", ")", "\n", "}" ]

[ "AddCommand", "adds", "a", "command", "to", "a", "category", "." ]

[ "func", "(", "c", "*", "Context", ")", "Bool", "(", "name", "string", ")", "bool", "{", "return", "lookupBool", "(", "name", ",", "c", ".", "flagSet", ")", "\n", "}" ]

[ "Bool", "looks", "up", "the", "value", "of", "a", "local", "BoolFlag", "returns", "false", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "GlobalBool", "(", "name", "string", ")", "bool", "{", "if", "fs", ":=", "lookupGlobalFlagSet", "(", "name", ",", "c", ")", ";", "fs", "!=", "nil", "{", "return", "lookupBool", "(", "name", ",", "fs", ")", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "GlobalBool", "looks", "up", "the", "value", "of", "a", "global", "BoolFlag", "returns", "false", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "BoolT", "(", "name", "string", ")", "bool", "{", "return", "lookupBoolT", "(", "name", ",", "c", ".", "flagSet", ")", "\n", "}" ]

[ "BoolT", "looks", "up", "the", "value", "of", "a", "local", "BoolTFlag", "returns", "false", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "GlobalBoolT", "(", "name", "string", ")", "bool", "{", "if", "fs", ":=", "lookupGlobalFlagSet", "(", "name", ",", "c", ")", ";", "fs", "!=", "nil", "{", "return", "lookupBoolT", "(", "name", ",", "fs", ")", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "GlobalBoolT", "looks", "up", "the", "value", "of", "a", "global", "BoolTFlag", "returns", "false", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "Duration", "(", "name", "string", ")", "time", ".", "Duration", "{", "return", "lookupDuration", "(", "name", ",", "c", ".", "flagSet", ")", "\n", "}" ]

[ "Duration", "looks", "up", "the", "value", "of", "a", "local", "DurationFlag", "returns", "0", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "GlobalDuration", "(", "name", "string", ")", "time", ".", "Duration", "{", "if", "fs", ":=", "lookupGlobalFlagSet", "(", "name", ",", "c", ")", ";", "fs", "!=", "nil", "{", "return", "lookupDuration", "(", "name", ",", "fs", ")", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "GlobalDuration", "looks", "up", "the", "value", "of", "a", "global", "DurationFlag", "returns", "0", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "Float64", "(", "name", "string", ")", "float64", "{", "return", "lookupFloat64", "(", "name", ",", "c", ".", "flagSet", ")", "\n", "}" ]

[ "Float64", "looks", "up", "the", "value", "of", "a", "local", "Float64Flag", "returns", "0", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "GlobalFloat64", "(", "name", "string", ")", "float64", "{", "if", "fs", ":=", "lookupGlobalFlagSet", "(", "name", ",", "c", ")", ";", "fs", "!=", "nil", "{", "return", "lookupFloat64", "(", "name", ",", "fs", ")", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "GlobalFloat64", "looks", "up", "the", "value", "of", "a", "global", "Float64Flag", "returns", "0", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "GlobalGeneric", "(", "name", "string", ")", "interface", "{", "}", "{", "if", "fs", ":=", "lookupGlobalFlagSet", "(", "name", ",", "c", ")", ";", "fs", "!=", "nil", "{", "return", "lookupGeneric", "(", "name", ",", "fs", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GlobalGeneric", "looks", "up", "the", "value", "of", "a", "global", "GenericFlag", "returns", "nil", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "Int64", "(", "name", "string", ")", "int64", "{", "return", "lookupInt64", "(", "name", ",", "c", ".", "flagSet", ")", "\n", "}" ]

[ "Int64", "looks", "up", "the", "value", "of", "a", "local", "Int64Flag", "returns", "0", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "GlobalInt64", "(", "name", "string", ")", "int64", "{", "if", "fs", ":=", "lookupGlobalFlagSet", "(", "name", ",", "c", ")", ";", "fs", "!=", "nil", "{", "return", "lookupInt64", "(", "name", ",", "fs", ")", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "GlobalInt64", "looks", "up", "the", "value", "of", "a", "global", "Int64Flag", "returns", "0", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "Int", "(", "name", "string", ")", "int", "{", "return", "lookupInt", "(", "name", ",", "c", ".", "flagSet", ")", "\n", "}" ]

[ "Int", "looks", "up", "the", "value", "of", "a", "local", "IntFlag", "returns", "0", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "GlobalInt", "(", "name", "string", ")", "int", "{", "if", "fs", ":=", "lookupGlobalFlagSet", "(", "name", ",", "c", ")", ";", "fs", "!=", "nil", "{", "return", "lookupInt", "(", "name", ",", "fs", ")", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "GlobalInt", "looks", "up", "the", "value", "of", "a", "global", "IntFlag", "returns", "0", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "IntSlice", "(", "name", "string", ")", "[", "]", "int", "{", "return", "lookupIntSlice", "(", "name", ",", "c", ".", "flagSet", ")", "\n", "}" ]

[ "IntSlice", "looks", "up", "the", "value", "of", "a", "local", "IntSliceFlag", "returns", "nil", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "GlobalIntSlice", "(", "name", "string", ")", "[", "]", "int", "{", "if", "fs", ":=", "lookupGlobalFlagSet", "(", "name", ",", "c", ")", ";", "fs", "!=", "nil", "{", "return", "lookupIntSlice", "(", "name", ",", "fs", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GlobalIntSlice", "looks", "up", "the", "value", "of", "a", "global", "IntSliceFlag", "returns", "nil", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "Int64Slice", "(", "name", "string", ")", "[", "]", "int64", "{", "return", "lookupInt64Slice", "(", "name", ",", "c", ".", "flagSet", ")", "\n", "}" ]

[ "Int64Slice", "looks", "up", "the", "value", "of", "a", "local", "Int64SliceFlag", "returns", "nil", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "GlobalInt64Slice", "(", "name", "string", ")", "[", "]", "int64", "{", "if", "fs", ":=", "lookupGlobalFlagSet", "(", "name", ",", "c", ")", ";", "fs", "!=", "nil", "{", "return", "lookupInt64Slice", "(", "name", ",", "fs", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GlobalInt64Slice", "looks", "up", "the", "value", "of", "a", "global", "Int64SliceFlag", "returns", "nil", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "String", "(", "name", "string", ")", "string", "{", "return", "lookupString", "(", "name", ",", "c", ".", "flagSet", ")", "\n", "}" ]

[ "String", "looks", "up", "the", "value", "of", "a", "local", "StringFlag", "returns", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "GlobalString", "(", "name", "string", ")", "string", "{", "if", "fs", ":=", "lookupGlobalFlagSet", "(", "name", ",", "c", ")", ";", "fs", "!=", "nil", "{", "return", "lookupString", "(", "name", ",", "fs", ")", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "GlobalString", "looks", "up", "the", "value", "of", "a", "global", "StringFlag", "returns", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "StringSlice", "(", "name", "string", ")", "[", "]", "string", "{", "return", "lookupStringSlice", "(", "name", ",", "c", ".", "flagSet", ")", "\n", "}" ]

[ "StringSlice", "looks", "up", "the", "value", "of", "a", "local", "StringSliceFlag", "returns", "nil", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "GlobalStringSlice", "(", "name", "string", ")", "[", "]", "string", "{", "if", "fs", ":=", "lookupGlobalFlagSet", "(", "name", ",", "c", ")", ";", "fs", "!=", "nil", "{", "return", "lookupStringSlice", "(", "name", ",", "fs", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GlobalStringSlice", "looks", "up", "the", "value", "of", "a", "global", "StringSliceFlag", "returns", "nil", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "Uint64", "(", "name", "string", ")", "uint64", "{", "return", "lookupUint64", "(", "name", ",", "c", ".", "flagSet", ")", "\n", "}" ]

[ "Uint64", "looks", "up", "the", "value", "of", "a", "local", "Uint64Flag", "returns", "0", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "GlobalUint64", "(", "name", "string", ")", "uint64", "{", "if", "fs", ":=", "lookupGlobalFlagSet", "(", "name", ",", "c", ")", ";", "fs", "!=", "nil", "{", "return", "lookupUint64", "(", "name", ",", "fs", ")", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "GlobalUint64", "looks", "up", "the", "value", "of", "a", "global", "Uint64Flag", "returns", "0", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "Uint", "(", "name", "string", ")", "uint", "{", "return", "lookupUint", "(", "name", ",", "c", ".", "flagSet", ")", "\n", "}" ]

[ "Uint", "looks", "up", "the", "value", "of", "a", "local", "UintFlag", "returns", "0", "if", "not", "found" ]

[ "func", "(", "c", "*", "Context", ")", "GlobalUint", "(", "name", "string", ")", "uint", "{", "if", "fs", ":=", "lookupGlobalFlagSet", "(", "name", ",", "c", ")", ";", "fs", "!=", "nil", "{", "return", "lookupUint", "(", "name", ",", "fs", ")", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "GlobalUint", "looks", "up", "the", "value", "of", "a", "global", "UintFlag", "returns", "0", "if", "not", "found" ]

[ "func", "nestedVal", "(", "name", "string", ",", "tree", "map", "[", "interface", "{", "}", "]", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "bool", ")", "{", "if", "sections", ":=", "strings", ".", "Split", "(", "name", ",", "\"", "\"", ")", ";", "len", "(", "sections", ")", ">", "1", "{", "node", ":=", "tree", "\n", "for", "_", ",", "section", ":=", "range", "sections", "[", ":", "len", "(", "sections", ")", "-", "1", "]", "{", "child", ",", "ok", ":=", "node", "[", "section", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "false", "\n", "}", "\n", "ctype", ",", "ok", ":=", "child", ".", "(", "map", "[", "interface", "{", "}", "]", "interface", "{", "}", ")", "\n", "if", "!", "ok", "{", "return", "nil", ",", "false", "\n", "}", "\n", "node", "=", "ctype", "\n", "}", "\n", "if", "val", ",", "ok", ":=", "node", "[", "sections", "[", "len", "(", "sections", ")", "-", "1", "]", "]", ";", "ok", "{", "return", "val", ",", "true", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "false", "\n", "}" ]

[ "nestedVal", "checks", "if", "the", "name", "has", ".", "delimiters", ".", "If", "so", "it", "tries", "to", "traverse", "the", "tree", "by", "the", ".", "delimited", "sections", "to", "find", "a", "nested", "value", "for", "the", "key", "." ]

[ "func", "(", "fsm", "*", "MapInputSource", ")", "Int", "(", "name", "string", ")", "(", "int", ",", "error", ")", "{", "otherGenericValue", ",", "exists", ":=", "fsm", ".", "valueMap", "[", "name", "]", "\n", "if", "exists", "{", "otherValue", ",", "isType", ":=", "otherGenericValue", ".", "(", "int", ")", "\n", "if", "!", "isType", "{", "return", "0", ",", "incorrectTypeForFlagError", "(", "name", ",", "\"", "\"", ",", "otherGenericValue", ")", "\n", "}", "\n", "return", "otherValue", ",", "nil", "\n", "}", "\n", "nestedGenericValue", ",", "exists", ":=", "nestedVal", "(", "name", ",", "fsm", ".", "valueMap", ")", "\n", "if", "exists", "{", "otherValue", ",", "isType", ":=", "nestedGenericValue", ".", "(", "int", ")", "\n", "if", "!", "isType", "{", "return", "0", ",", "incorrectTypeForFlagError", "(", "name", ",", "\"", "\"", ",", "nestedGenericValue", ")", "\n", "}", "\n", "return", "otherValue", ",", "nil", "\n", "}", "\n\n", "return", "0", ",", "nil", "\n", "}" ]

[ "Int", "returns", "an", "int", "from", "the", "map", "if", "it", "exists", "otherwise", "returns", "0" ]

[ "func", "(", "fsm", "*", "MapInputSource", ")", "Bool", "(", "name", "string", ")", "(", "bool", ",", "error", ")", "{", "otherGenericValue", ",", "exists", ":=", "fsm", ".", "valueMap", "[", "name", "]", "\n", "if", "exists", "{", "otherValue", ",", "isType", ":=", "otherGenericValue", ".", "(", "bool", ")", "\n", "if", "!", "isType", "{", "return", "false", ",", "incorrectTypeForFlagError", "(", "name", ",", "\"", "\"", ",", "otherGenericValue", ")", "\n", "}", "\n", "return", "otherValue", ",", "nil", "\n", "}", "\n", "nestedGenericValue", ",", "exists", ":=", "nestedVal", "(", "name", ",", "fsm", ".", "valueMap", ")", "\n", "if", "exists", "{", "otherValue", ",", "isType", ":=", "nestedGenericValue", ".", "(", "bool", ")", "\n", "if", "!", "isType", "{", "return", "false", ",", "incorrectTypeForFlagError", "(", "name", ",", "\"", "\"", ",", "nestedGenericValue", ")", "\n", "}", "\n", "return", "otherValue", ",", "nil", "\n", "}", "\n\n", "return", "false", ",", "nil", "\n", "}" ]

[ "Bool", "returns", "an", "bool", "from", "the", "map", "otherwise", "returns", "false" ]

[ "func", "(", "fsm", "*", "MapInputSource", ")", "BoolT", "(", "name", "string", ")", "(", "bool", ",", "error", ")", "{", "otherGenericValue", ",", "exists", ":=", "fsm", ".", "valueMap", "[", "name", "]", "\n", "if", "exists", "{", "otherValue", ",", "isType", ":=", "otherGenericValue", ".", "(", "bool", ")", "\n", "if", "!", "isType", "{", "return", "true", ",", "incorrectTypeForFlagError", "(", "name", ",", "\"", "\"", ",", "otherGenericValue", ")", "\n", "}", "\n", "return", "otherValue", ",", "nil", "\n", "}", "\n", "nestedGenericValue", ",", "exists", ":=", "nestedVal", "(", "name", ",", "fsm", ".", "valueMap", ")", "\n", "if", "exists", "{", "otherValue", ",", "isType", ":=", "nestedGenericValue", ".", "(", "bool", ")", "\n", "if", "!", "isType", "{", "return", "true", ",", "incorrectTypeForFlagError", "(", "name", ",", "\"", "\"", ",", "nestedGenericValue", ")", "\n", "}", "\n", "return", "otherValue", ",", "nil", "\n", "}", "\n\n", "return", "true", ",", "nil", "\n", "}" ]

[ "BoolT", "returns", "an", "bool", "from", "the", "map", "otherwise", "returns", "true" ]

[ "func", "NewYamlSourceFromFile", "(", "file", "string", ")", "(", "InputSourceContext", ",", "error", ")", "{", "ysc", ":=", "&", "yamlSourceContext", "{", "FilePath", ":", "file", "}", "\n", "var", "results", "map", "[", "interface", "{", "}", "]", "interface", "{", "}", "\n", "err", ":=", "readCommandYaml", "(", "ysc", ".", "FilePath", ",", "&", "results", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "ysc", ".", "FilePath", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "return", "&", "MapInputSource", "{", "valueMap", ":", "results", "}", ",", "nil", "\n", "}" ]

[ "NewYamlSourceFromFile", "creates", "a", "new", "Yaml", "InputSourceContext", "from", "a", "filepath", "." ]

[ "func", "NewYamlSourceFromFlagFunc", "(", "flagFileName", "string", ")", "func", "(", "context", "*", "cli", ".", "Context", ")", "(", "InputSourceContext", ",", "error", ")", "{", "return", "func", "(", "context", "*", "cli", ".", "Context", ")", "(", "InputSourceContext", ",", "error", ")", "{", "filePath", ":=", "context", ".", "String", "(", "flagFileName", ")", "\n", "return", "NewYamlSourceFromFile", "(", "filePath", ")", "\n", "}", "\n", "}" ]

[ "NewYamlSourceFromFlagFunc", "creates", "a", "new", "Yaml", "InputSourceContext", "from", "a", "provided", "flag", "name", "and", "source", "context", "." ]

[ "func", "lexicographicLess", "(", "i", ",", "j", "string", ")", "bool", "{", "iRunes", ":=", "[", "]", "rune", "(", "i", ")", "\n", "jRunes", ":=", "[", "]", "rune", "(", "j", ")", "\n\n", "lenShared", ":=", "len", "(", "iRunes", ")", "\n", "if", "lenShared", ">", "len", "(", "jRunes", ")", "{", "lenShared", "=", "len", "(", "jRunes", ")", "\n", "}", "\n\n", "for", "index", ":=", "0", ";", "index", "<", "lenShared", ";", "index", "++", "{", "ir", ":=", "iRunes", "[", "index", "]", "\n", "jr", ":=", "jRunes", "[", "index", "]", "\n\n", "if", "lir", ",", "ljr", ":=", "unicode", ".", "ToLower", "(", "ir", ")", ",", "unicode", ".", "ToLower", "(", "jr", ")", ";", "lir", "!=", "ljr", "{", "return", "lir", "<", "ljr", "\n", "}", "\n\n", "if", "ir", "!=", "jr", "{", "return", "ir", "<", "jr", "\n", "}", "\n", "}", "\n\n", "return", "i", "<", "j", "\n", "}" ]

[ "lexicographicLess", "compares", "strings", "alphabetically", "considering", "case", "." ]

[ "func", "compileTime", "(", ")", "time", ".", "Time", "{", "info", ",", "err", ":=", "os", ".", "Stat", "(", "os", ".", "Args", "[", "0", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "time", ".", "Now", "(", ")", "\n", "}", "\n", "return", "info", ".", "ModTime", "(", ")", "\n", "}" ]

[ "Tries", "to", "find", "out", "when", "this", "binary", "was", "compiled", ".", "Returns", "the", "current", "time", "if", "it", "fails", "to", "find", "it", "." ]

[ "func", "NewApp", "(", ")", "*", "App", "{", "return", "&", "App", "{", "Name", ":", "filepath", ".", "Base", "(", "os", ".", "Args", "[", "0", "]", ")", ",", "HelpName", ":", "filepath", ".", "Base", "(", "os", ".", "Args", "[", "0", "]", ")", ",", "Usage", ":", "\"", "\"", ",", "UsageText", ":", "\"", "\"", ",", "Version", ":", "\"", "\"", ",", "BashComplete", ":", "DefaultAppComplete", ",", "Action", ":", "helpCommand", ".", "Action", ",", "Compiled", ":", "compileTime", "(", ")", ",", "Writer", ":", "os", ".", "Stdout", ",", "}", "\n", "}" ]

[ "NewApp", "creates", "a", "new", "cli", "Application", "with", "some", "reasonable", "defaults", "for", "Name", "Usage", "Version", "and", "Action", "." ]

[ "func", "(", "a", "*", "App", ")", "Setup", "(", ")", "{", "if", "a", ".", "didSetup", "{", "return", "\n", "}", "\n\n", "a", ".", "didSetup", "=", "true", "\n\n", "if", "a", ".", "Author", "!=", "\"", "\"", "||", "a", ".", "Email", "!=", "\"", "\"", "{", "a", ".", "Authors", "=", "append", "(", "a", ".", "Authors", ",", "Author", "{", "Name", ":", "a", ".", "Author", ",", "Email", ":", "a", ".", "Email", "}", ")", "\n", "}", "\n\n", "newCmds", ":=", "[", "]", "Command", "{", "}", "\n", "for", "_", ",", "c", ":=", "range", "a", ".", "Commands", "{", "if", "c", ".", "HelpName", "==", "\"", "\"", "{", "c", ".", "HelpName", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "a", ".", "HelpName", ",", "c", ".", "Name", ")", "\n", "}", "\n", "newCmds", "=", "append", "(", "newCmds", ",", "c", ")", "\n", "}", "\n", "a", ".", "Commands", "=", "newCmds", "\n\n", "if", "a", ".", "Command", "(", "helpCommand", ".", "Name", ")", "==", "nil", "&&", "!", "a", ".", "HideHelp", "{", "a", ".", "Commands", "=", "append", "(", "a", ".", "Commands", ",", "helpCommand", ")", "\n", "if", "(", "HelpFlag", "!=", "BoolFlag", "{", "}", ")", "{", "a", ".", "appendFlag", "(", "HelpFlag", ")", "\n", "}", "\n", "}", "\n\n", "if", "!", "a", ".", "HideVersion", "{", "a", ".", "appendFlag", "(", "VersionFlag", ")", "\n", "}", "\n\n", "a", ".", "categories", "=", "CommandCategories", "{", "}", "\n", "for", "_", ",", "command", ":=", "range", "a", ".", "Commands", "{", "a", ".", "categories", "=", "a", ".", "categories", ".", "AddCommand", "(", "command", ".", "Category", ",", "command", ")", "\n", "}", "\n", "sort", ".", "Sort", "(", "a", ".", "categories", ")", "\n\n", "if", "a", ".", "Metadata", "==", "nil", "{", "a", ".", "Metadata", "=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "}", "\n\n", "if", "a", ".", "Writer", "==", "nil", "{", "a", ".", "Writer", "=", "os", ".", "Stdout", "\n", "}", "\n", "}" ]

[ "Setup", "runs", "initialization", "code", "to", "ensure", "all", "data", "structures", "are", "ready", "for", "Run", "or", "inspection", "prior", "to", "Run", ".", "It", "is", "internally", "called", "by", "Run", "but", "will", "return", "early", "if", "setup", "has", "already", "happened", "." ]

[ "func", "(", "a", "*", "App", ")", "Command", "(", "name", "string", ")", "*", "Command", "{", "for", "_", ",", "c", ":=", "range", "a", ".", "Commands", "{", "if", "c", ".", "HasName", "(", "name", ")", "{", "return", "&", "c", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Command", "returns", "the", "named", "command", "on", "App", ".", "Returns", "nil", "if", "the", "command", "does", "not", "exist" ]

[ "func", "(", "a", "*", "App", ")", "VisibleCategories", "(", ")", "[", "]", "*", "CommandCategory", "{", "ret", ":=", "[", "]", "*", "CommandCategory", "{", "}", "\n", "for", "_", ",", "category", ":=", "range", "a", ".", "categories", "{", "if", "visible", ":=", "func", "(", ")", "*", "CommandCategory", "{", "for", "_", ",", "command", ":=", "range", "category", ".", "Commands", "{", "if", "!", "command", ".", "Hidden", "{", "return", "category", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "(", ")", ";", "visible", "!=", "nil", "{", "ret", "=", "append", "(", "ret", ",", "visible", ")", "\n", "}", "\n", "}", "\n", "return", "ret", "\n", "}" ]

[ "VisibleCategories", "returns", "a", "slice", "of", "categories", "and", "commands", "that", "are", "Hidden", "=", "false" ]

[ "func", "(", "a", "Author", ")", "String", "(", ")", "string", "{", "e", ":=", "\"", "\"", "\n", "if", "a", ".", "Email", "!=", "\"", "\"", "{", "e", "=", "\"", "\"", "+", "a", ".", "Email", "+", "\"", "\"", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "a", ".", "Name", ",", "e", ")", "\n", "}" ]

[ "String", "makes", "Author", "comply", "to", "the", "Stringer", "interface", "to", "allow", "an", "easy", "print", "in", "the", "templating", "process" ]

[ "func", "HandleAction", "(", "action", "interface", "{", "}", ",", "context", "*", "Context", ")", "(", "err", "error", ")", "{", "switch", "a", ":=", "action", ".", "(", "type", ")", "{", "case", "ActionFunc", ":", "return", "a", "(", "context", ")", "\n", "case", "func", "(", "*", "Context", ")", "error", ":", "return", "a", "(", "context", ")", "\n", "case", "func", "(", "*", "Context", ")", ":", "// deprecated function signature", "a", "(", "context", ")", "\n", "return", "nil", "\n", "}", "\n\n", "return", "errInvalidActionType", "\n", "}" ]

[ "HandleAction", "attempts", "to", "figure", "out", "which", "Action", "signature", "was", "used", ".", "If", "it", "s", "an", "ActionFunc", "or", "a", "func", "with", "the", "legacy", "signature", "for", "Action", "the", "func", "is", "run!" ]

[ "func", "ApplyInputSourceValues", "(", "context", "*", "cli", ".", "Context", ",", "inputSourceContext", "InputSourceContext", ",", "flags", "[", "]", "cli", ".", "Flag", ")", "error", "{", "for", "_", ",", "f", ":=", "range", "flags", "{", "inputSourceExtendedFlag", ",", "isType", ":=", "f", ".", "(", "FlagInputSourceExtension", ")", "\n", "if", "isType", "{", "err", ":=", "inputSourceExtendedFlag", ".", "ApplyInputSourceValue", "(", "context", ",", "inputSourceContext", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "ApplyInputSourceValues", "iterates", "over", "all", "provided", "flags", "and", "executes", "ApplyInputSourceValue", "on", "flags", "implementing", "the", "FlagInputSourceExtension", "interface", "to", "initialize", "these", "flags", "to", "an", "alternate", "input", "source", "." ]

[ "func", "InitInputSource", "(", "flags", "[", "]", "cli", ".", "Flag", ",", "createInputSource", "func", "(", ")", "(", "InputSourceContext", ",", "error", ")", ")", "cli", ".", "BeforeFunc", "{", "return", "func", "(", "context", "*", "cli", ".", "Context", ")", "error", "{", "inputSource", ",", "err", ":=", "createInputSource", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "return", "ApplyInputSourceValues", "(", "context", ",", "inputSource", ",", "flags", ")", "\n", "}", "\n", "}" ]

[ "InitInputSource", "is", "used", "to", "to", "setup", "an", "InputSourceContext", "on", "a", "cli", ".", "Command", "Before", "method", ".", "It", "will", "create", "a", "new", "input", "source", "based", "on", "the", "func", "provided", ".", "If", "there", "is", "no", "error", "it", "will", "then", "apply", "the", "new", "input", "source", "to", "any", "flags", "that", "are", "supported", "by", "the", "input", "source" ]

[ "func", "(", "f", "*", "GenericFlag", ")", "ApplyInputSourceValue", "(", "context", "*", "cli", ".", "Context", ",", "isc", "InputSourceContext", ")", "error", "{", "if", "f", ".", "set", "!=", "nil", "{", "if", "!", "context", ".", "IsSet", "(", "f", ".", "Name", ")", "&&", "!", "isEnvVarSet", "(", "f", ".", "EnvVar", ")", "{", "value", ",", "err", ":=", "isc", ".", "Generic", "(", "f", ".", "GenericFlag", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "value", "!=", "nil", "{", "eachName", "(", "f", ".", "Name", ",", "func", "(", "name", "string", ")", "{", "f", ".", "set", ".", "Set", "(", "f", ".", "Name", ",", "value", ".", "String", "(", ")", ")", "\n", "}", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "ApplyInputSourceValue", "applies", "a", "generic", "value", "to", "the", "flagSet", "if", "required" ]

[ "func", "(", "f", "*", "StringSliceFlag", ")", "ApplyInputSourceValue", "(", "context", "*", "cli", ".", "Context", ",", "isc", "InputSourceContext", ")", "error", "{", "if", "f", ".", "set", "!=", "nil", "{", "if", "!", "context", ".", "IsSet", "(", "f", ".", "Name", ")", "&&", "!", "isEnvVarSet", "(", "f", ".", "EnvVar", ")", "{", "value", ",", "err", ":=", "isc", ".", "StringSlice", "(", "f", ".", "StringSliceFlag", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "value", "!=", "nil", "{", "var", "sliceValue", "cli", ".", "StringSlice", "=", "value", "\n", "eachName", "(", "f", ".", "Name", ",", "func", "(", "name", "string", ")", "{", "underlyingFlag", ":=", "f", ".", "set", ".", "Lookup", "(", "f", ".", "Name", ")", "\n", "if", "underlyingFlag", "!=", "nil", "{", "underlyingFlag", ".", "Value", "=", "&", "sliceValue", "\n", "}", "\n", "}", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ApplyInputSourceValue", "applies", "a", "StringSlice", "value", "to", "the", "flagSet", "if", "required" ]

[ "func", "(", "f", "*", "BoolFlag", ")", "ApplyInputSourceValue", "(", "context", "*", "cli", ".", "Context", ",", "isc", "InputSourceContext", ")", "error", "{", "if", "f", ".", "set", "!=", "nil", "{", "if", "!", "context", ".", "IsSet", "(", "f", ".", "Name", ")", "&&", "!", "isEnvVarSet", "(", "f", ".", "EnvVar", ")", "{", "value", ",", "err", ":=", "isc", ".", "Bool", "(", "f", ".", "BoolFlag", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "value", "{", "eachName", "(", "f", ".", "Name", ",", "func", "(", "name", "string", ")", "{", "f", ".", "set", ".", "Set", "(", "f", ".", "Name", ",", "strconv", ".", "FormatBool", "(", "value", ")", ")", "\n", "}", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ApplyInputSourceValue", "applies", "a", "Bool", "value", "to", "the", "flagSet", "if", "required" ]

[ "func", "(", "f", "*", "IntFlag", ")", "ApplyInputSourceValue", "(", "context", "*", "cli", ".", "Context", ",", "isc", "InputSourceContext", ")", "error", "{", "if", "f", ".", "set", "!=", "nil", "{", "if", "!", "(", "context", ".", "IsSet", "(", "f", ".", "Name", ")", "||", "isEnvVarSet", "(", "f", ".", "EnvVar", ")", ")", "{", "value", ",", "err", ":=", "isc", ".", "Int", "(", "f", ".", "IntFlag", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "value", ">", "0", "{", "eachName", "(", "f", ".", "Name", ",", "func", "(", "name", "string", ")", "{", "f", ".", "set", ".", "Set", "(", "f", ".", "Name", ",", "strconv", ".", "FormatInt", "(", "int64", "(", "value", ")", ",", "10", ")", ")", "\n", "}", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ApplyInputSourceValue", "applies", "a", "int", "value", "to", "the", "flagSet", "if", "required" ]

[ "func", "(", "f", "*", "Float64Flag", ")", "ApplyInputSourceValue", "(", "context", "*", "cli", ".", "Context", ",", "isc", "InputSourceContext", ")", "error", "{", "if", "f", ".", "set", "!=", "nil", "{", "if", "!", "(", "context", ".", "IsSet", "(", "f", ".", "Name", ")", "||", "isEnvVarSet", "(", "f", ".", "EnvVar", ")", ")", "{", "value", ",", "err", ":=", "isc", ".", "Float64", "(", "f", ".", "Float64Flag", ".", "Name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "value", ">", "0", "{", "floatStr", ":=", "float64ToString", "(", "value", ")", "\n", "eachName", "(", "f", ".", "Name", ",", "func", "(", "name", "string", ")", "{", "f", ".", "set", ".", "Set", "(", "f", ".", "Name", ",", "floatStr", ")", "\n", "}", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ApplyInputSourceValue", "applies", "a", "Float64", "value", "to", "the", "flagSet", "if", "required" ]

[ "func", "NewContext", "(", "app", "*", "App", ",", "set", "*", "flag", ".", "FlagSet", ",", "parentCtx", "*", "Context", ")", "*", "Context", "{", "c", ":=", "&", "Context", "{", "App", ":", "app", ",", "flagSet", ":", "set", ",", "parentContext", ":", "parentCtx", "}", "\n\n", "if", "parentCtx", "!=", "nil", "{", "c", ".", "shellComplete", "=", "parentCtx", ".", "shellComplete", "\n", "}", "\n\n", "return", "c", "\n", "}" ]

[ "NewContext", "creates", "a", "new", "context", ".", "For", "use", "in", "when", "invoking", "an", "App", "or", "Command", "action", "." ]

[ "func", "(", "c", "*", "Context", ")", "Set", "(", "name", ",", "value", "string", ")", "error", "{", "c", ".", "setFlags", "=", "nil", "\n", "return", "c", ".", "flagSet", ".", "Set", "(", "name", ",", "value", ")", "\n", "}" ]

[ "Set", "sets", "a", "context", "flag", "to", "a", "value", "." ]

[ "func", "(", "c", "*", "Context", ")", "IsSet", "(", "name", "string", ")", "bool", "{", "if", "c", ".", "setFlags", "==", "nil", "{", "c", ".", "setFlags", "=", "make", "(", "map", "[", "string", "]", "bool", ")", "\n\n", "c", ".", "flagSet", ".", "Visit", "(", "func", "(", "f", "*", "flag", ".", "Flag", ")", "{", "c", ".", "setFlags", "[", "f", ".", "Name", "]", "=", "true", "\n", "}", ")", "\n\n", "c", ".", "flagSet", ".", "VisitAll", "(", "func", "(", "f", "*", "flag", ".", "Flag", ")", "{", "if", "_", ",", "ok", ":=", "c", ".", "setFlags", "[", "f", ".", "Name", "]", ";", "ok", "{", "return", "\n", "}", "\n", "c", ".", "setFlags", "[", "f", ".", "Name", "]", "=", "false", "\n", "}", ")", "\n\n", "// XXX hack to support IsSet for flags with EnvVar", "//", "// There isn't an easy way to do this with the current implementation since", "// whether a flag was set via an environment variable is very difficult to", "// determine here. Instead, we intend to introduce a backwards incompatible", "// change in version 2 to add `IsSet` to the Flag interface to push the", "// responsibility closer to where the information required to determine", "// whether a flag is set by non-standard means such as environment", "// variables is available.", "//", "// See https://github.com/urfave/cli/issues/294 for additional discussion", "flags", ":=", "c", ".", "Command", ".", "Flags", "\n", "if", "c", ".", "Command", ".", "Name", "==", "\"", "\"", "{", "// cannot == Command{} since it contains slice types", "if", "c", ".", "App", "!=", "nil", "{", "flags", "=", "c", ".", "App", ".", "Flags", "\n", "}", "\n", "}", "\n", "for", "_", ",", "f", ":=", "range", "flags", "{", "eachName", "(", "f", ".", "GetName", "(", ")", ",", "func", "(", "name", "string", ")", "{", "if", "isSet", ",", "ok", ":=", "c", ".", "setFlags", "[", "name", "]", ";", "isSet", "||", "!", "ok", "{", "return", "\n", "}", "\n\n", "val", ":=", "reflect", ".", "ValueOf", "(", "f", ")", "\n", "if", "val", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "{", "val", "=", "val", ".", "Elem", "(", ")", "\n", "}", "\n\n", "filePathValue", ":=", "val", ".", "FieldByName", "(", "\"", "\"", ")", "\n", "if", "filePathValue", ".", "IsValid", "(", ")", "{", "eachName", "(", "filePathValue", ".", "String", "(", ")", ",", "func", "(", "filePath", "string", ")", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "filePath", ")", ";", "err", "==", "nil", "{", "c", ".", "setFlags", "[", "name", "]", "=", "true", "\n", "return", "\n", "}", "\n", "}", ")", "\n", "}", "\n\n", "envVarValue", ":=", "val", ".", "FieldByName", "(", "\"", "\"", ")", "\n", "if", "envVarValue", ".", "IsValid", "(", ")", "{", "eachName", "(", "envVarValue", ".", "String", "(", ")", ",", "func", "(", "envVar", "string", ")", "{", "envVar", "=", "strings", ".", "TrimSpace", "(", "envVar", ")", "\n", "if", "_", ",", "ok", ":=", "syscall", ".", "Getenv", "(", "envVar", ")", ";", "ok", "{", "c", ".", "setFlags", "[", "name", "]", "=", "true", "\n", "return", "\n", "}", "\n", "}", ")", "\n", "}", "\n", "}", ")", "\n", "}", "\n", "}", "\n\n", "return", "c", ".", "setFlags", "[", "name", "]", "\n", "}" ]

[ "IsSet", "determines", "if", "the", "flag", "was", "actually", "set" ]

[ "func", "(", "c", "*", "Context", ")", "GlobalIsSet", "(", "name", "string", ")", "bool", "{", "ctx", ":=", "c", "\n", "if", "ctx", ".", "parentContext", "!=", "nil", "{", "ctx", "=", "ctx", ".", "parentContext", "\n", "}", "\n\n", "for", ";", "ctx", "!=", "nil", ";", "ctx", "=", "ctx", ".", "parentContext", "{", "if", "ctx", ".", "IsSet", "(", "name", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "GlobalIsSet", "determines", "if", "the", "global", "flag", "was", "actually", "set" ]

[ "func", "(", "c", "*", "Context", ")", "FlagNames", "(", ")", "(", "names", "[", "]", "string", ")", "{", "for", "_", ",", "flag", ":=", "range", "c", ".", "Command", ".", "Flags", "{", "name", ":=", "strings", ".", "Split", "(", "flag", ".", "GetName", "(", ")", ",", "\"", "\"", ")", "[", "0", "]", "\n", "if", "name", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "names", "=", "append", "(", "names", ",", "name", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "FlagNames", "returns", "a", "slice", "of", "flag", "names", "used", "in", "this", "context", "." ]

[ "func", "(", "c", "*", "Context", ")", "GlobalFlagNames", "(", ")", "(", "names", "[", "]", "string", ")", "{", "for", "_", ",", "flag", ":=", "range", "c", ".", "App", ".", "Flags", "{", "name", ":=", "strings", ".", "Split", "(", "flag", ".", "GetName", "(", ")", ",", "\"", "\"", ")", "[", "0", "]", "\n", "if", "name", "==", "\"", "\"", "||", "name", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "names", "=", "append", "(", "names", ",", "name", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "GlobalFlagNames", "returns", "a", "slice", "of", "global", "flag", "names", "used", "by", "the", "app", "." ]

[ "func", "(", "c", "*", "Context", ")", "value", "(", "name", "string", ")", "interface", "{", "}", "{", "return", "c", ".", "flagSet", ".", "Lookup", "(", "name", ")", ".", "Value", ".", "(", "flag", ".", "Getter", ")", ".", "Get", "(", ")", "\n", "}" ]

[ "value", "returns", "the", "value", "of", "the", "flag", "coressponding", "to", "name" ]

[ "func", "(", "c", "*", "Context", ")", "Args", "(", ")", "Args", "{", "args", ":=", "Args", "(", "c", ".", "flagSet", ".", "Args", "(", ")", ")", "\n", "return", "args", "\n", "}" ]

[ "Args", "returns", "the", "command", "line", "arguments", "associated", "with", "the", "context", "." ]

[ "func", "(", "a", "Args", ")", "Get", "(", "n", "int", ")", "string", "{", "if", "len", "(", "a", ")", ">", "n", "{", "return", "a", "[", "n", "]", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "Get", "returns", "the", "nth", "argument", "or", "else", "a", "blank", "string" ]

[ "func", "(", "a", "Args", ")", "Swap", "(", "from", ",", "to", "int", ")", "error", "{", "if", "from", ">=", "len", "(", "a", ")", "||", "to", ">=", "len", "(", "a", ")", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "a", "[", "from", "]", ",", "a", "[", "to", "]", "=", "a", "[", "to", "]", ",", "a", "[", "from", "]", "\n", "return", "nil", "\n", "}" ]

[ "Swap", "swaps", "arguments", "at", "the", "given", "indexes" ]

[ "func", "NewBoolFlag", "(", "fl", "cli", ".", "BoolFlag", ")", "*", "BoolFlag", "{", "return", "&", "BoolFlag", "{", "BoolFlag", ":", "fl", ",", "set", ":", "nil", "}", "\n", "}" ]

[ "NewBoolFlag", "creates", "a", "new", "BoolFlag" ]

[ "func", "(", "f", "*", "BoolFlag", ")", "Apply", "(", "set", "*", "flag", ".", "FlagSet", ")", "{", "f", ".", "set", "=", "set", "\n", "f", ".", "BoolFlag", ".", "Apply", "(", "set", ")", "\n", "}" ]

[ "Apply", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "BoolFlag", ".", "Apply" ]

[ "func", "(", "f", "*", "BoolFlag", ")", "ApplyWithError", "(", "set", "*", "flag", ".", "FlagSet", ")", "error", "{", "f", ".", "set", "=", "set", "\n", "return", "f", ".", "BoolFlag", ".", "ApplyWithError", "(", "set", ")", "\n", "}" ]

[ "ApplyWithError", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "BoolFlag", ".", "ApplyWithError" ]

[ "func", "NewBoolTFlag", "(", "fl", "cli", ".", "BoolTFlag", ")", "*", "BoolTFlag", "{", "return", "&", "BoolTFlag", "{", "BoolTFlag", ":", "fl", ",", "set", ":", "nil", "}", "\n", "}" ]

[ "NewBoolTFlag", "creates", "a", "new", "BoolTFlag" ]

[ "func", "(", "f", "*", "BoolTFlag", ")", "Apply", "(", "set", "*", "flag", ".", "FlagSet", ")", "{", "f", ".", "set", "=", "set", "\n", "f", ".", "BoolTFlag", ".", "Apply", "(", "set", ")", "\n", "}" ]

[ "Apply", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "BoolTFlag", ".", "Apply" ]

[ "func", "(", "f", "*", "BoolTFlag", ")", "ApplyWithError", "(", "set", "*", "flag", ".", "FlagSet", ")", "error", "{", "f", ".", "set", "=", "set", "\n", "return", "f", ".", "BoolTFlag", ".", "ApplyWithError", "(", "set", ")", "\n", "}" ]

[ "ApplyWithError", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "BoolTFlag", ".", "ApplyWithError" ]

[ "func", "NewDurationFlag", "(", "fl", "cli", ".", "DurationFlag", ")", "*", "DurationFlag", "{", "return", "&", "DurationFlag", "{", "DurationFlag", ":", "fl", ",", "set", ":", "nil", "}", "\n", "}" ]

[ "NewDurationFlag", "creates", "a", "new", "DurationFlag" ]

[ "func", "(", "f", "*", "DurationFlag", ")", "Apply", "(", "set", "*", "flag", ".", "FlagSet", ")", "{", "f", ".", "set", "=", "set", "\n", "f", ".", "DurationFlag", ".", "Apply", "(", "set", ")", "\n", "}" ]

[ "Apply", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "DurationFlag", ".", "Apply" ]

[ "func", "(", "f", "*", "DurationFlag", ")", "ApplyWithError", "(", "set", "*", "flag", ".", "FlagSet", ")", "error", "{", "f", ".", "set", "=", "set", "\n", "return", "f", ".", "DurationFlag", ".", "ApplyWithError", "(", "set", ")", "\n", "}" ]

[ "ApplyWithError", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "DurationFlag", ".", "ApplyWithError" ]

[ "func", "NewFloat64Flag", "(", "fl", "cli", ".", "Float64Flag", ")", "*", "Float64Flag", "{", "return", "&", "Float64Flag", "{", "Float64Flag", ":", "fl", ",", "set", ":", "nil", "}", "\n", "}" ]

[ "NewFloat64Flag", "creates", "a", "new", "Float64Flag" ]

[ "func", "(", "f", "*", "Float64Flag", ")", "Apply", "(", "set", "*", "flag", ".", "FlagSet", ")", "{", "f", ".", "set", "=", "set", "\n", "f", ".", "Float64Flag", ".", "Apply", "(", "set", ")", "\n", "}" ]

[ "Apply", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "Float64Flag", ".", "Apply" ]

[ "func", "(", "f", "*", "Float64Flag", ")", "ApplyWithError", "(", "set", "*", "flag", ".", "FlagSet", ")", "error", "{", "f", ".", "set", "=", "set", "\n", "return", "f", ".", "Float64Flag", ".", "ApplyWithError", "(", "set", ")", "\n", "}" ]

[ "ApplyWithError", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "Float64Flag", ".", "ApplyWithError" ]

[ "func", "NewGenericFlag", "(", "fl", "cli", ".", "GenericFlag", ")", "*", "GenericFlag", "{", "return", "&", "GenericFlag", "{", "GenericFlag", ":", "fl", ",", "set", ":", "nil", "}", "\n", "}" ]

[ "NewGenericFlag", "creates", "a", "new", "GenericFlag" ]

[ "func", "(", "f", "*", "GenericFlag", ")", "Apply", "(", "set", "*", "flag", ".", "FlagSet", ")", "{", "f", ".", "set", "=", "set", "\n", "f", ".", "GenericFlag", ".", "Apply", "(", "set", ")", "\n", "}" ]

[ "Apply", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "GenericFlag", ".", "Apply" ]

[ "func", "(", "f", "*", "GenericFlag", ")", "ApplyWithError", "(", "set", "*", "flag", ".", "FlagSet", ")", "error", "{", "f", ".", "set", "=", "set", "\n", "return", "f", ".", "GenericFlag", ".", "ApplyWithError", "(", "set", ")", "\n", "}" ]

[ "ApplyWithError", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "GenericFlag", ".", "ApplyWithError" ]

[ "func", "NewInt64Flag", "(", "fl", "cli", ".", "Int64Flag", ")", "*", "Int64Flag", "{", "return", "&", "Int64Flag", "{", "Int64Flag", ":", "fl", ",", "set", ":", "nil", "}", "\n", "}" ]

[ "NewInt64Flag", "creates", "a", "new", "Int64Flag" ]

[ "func", "(", "f", "*", "Int64Flag", ")", "Apply", "(", "set", "*", "flag", ".", "FlagSet", ")", "{", "f", ".", "set", "=", "set", "\n", "f", ".", "Int64Flag", ".", "Apply", "(", "set", ")", "\n", "}" ]

[ "Apply", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "Int64Flag", ".", "Apply" ]

[ "func", "(", "f", "*", "Int64Flag", ")", "ApplyWithError", "(", "set", "*", "flag", ".", "FlagSet", ")", "error", "{", "f", ".", "set", "=", "set", "\n", "return", "f", ".", "Int64Flag", ".", "ApplyWithError", "(", "set", ")", "\n", "}" ]

[ "ApplyWithError", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "Int64Flag", ".", "ApplyWithError" ]

[ "func", "NewIntFlag", "(", "fl", "cli", ".", "IntFlag", ")", "*", "IntFlag", "{", "return", "&", "IntFlag", "{", "IntFlag", ":", "fl", ",", "set", ":", "nil", "}", "\n", "}" ]

[ "NewIntFlag", "creates", "a", "new", "IntFlag" ]

[ "func", "(", "f", "*", "IntFlag", ")", "Apply", "(", "set", "*", "flag", ".", "FlagSet", ")", "{", "f", ".", "set", "=", "set", "\n", "f", ".", "IntFlag", ".", "Apply", "(", "set", ")", "\n", "}" ]

[ "Apply", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "IntFlag", ".", "Apply" ]

[ "func", "(", "f", "*", "IntFlag", ")", "ApplyWithError", "(", "set", "*", "flag", ".", "FlagSet", ")", "error", "{", "f", ".", "set", "=", "set", "\n", "return", "f", ".", "IntFlag", ".", "ApplyWithError", "(", "set", ")", "\n", "}" ]

[ "ApplyWithError", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "IntFlag", ".", "ApplyWithError" ]

[ "func", "NewIntSliceFlag", "(", "fl", "cli", ".", "IntSliceFlag", ")", "*", "IntSliceFlag", "{", "return", "&", "IntSliceFlag", "{", "IntSliceFlag", ":", "fl", ",", "set", ":", "nil", "}", "\n", "}" ]

[ "NewIntSliceFlag", "creates", "a", "new", "IntSliceFlag" ]

[ "func", "(", "f", "*", "IntSliceFlag", ")", "Apply", "(", "set", "*", "flag", ".", "FlagSet", ")", "{", "f", ".", "set", "=", "set", "\n", "f", ".", "IntSliceFlag", ".", "Apply", "(", "set", ")", "\n", "}" ]

[ "Apply", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "IntSliceFlag", ".", "Apply" ]

[ "func", "(", "f", "*", "IntSliceFlag", ")", "ApplyWithError", "(", "set", "*", "flag", ".", "FlagSet", ")", "error", "{", "f", ".", "set", "=", "set", "\n", "return", "f", ".", "IntSliceFlag", ".", "ApplyWithError", "(", "set", ")", "\n", "}" ]

[ "ApplyWithError", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "IntSliceFlag", ".", "ApplyWithError" ]

[ "func", "NewInt64SliceFlag", "(", "fl", "cli", ".", "Int64SliceFlag", ")", "*", "Int64SliceFlag", "{", "return", "&", "Int64SliceFlag", "{", "Int64SliceFlag", ":", "fl", ",", "set", ":", "nil", "}", "\n", "}" ]

[ "NewInt64SliceFlag", "creates", "a", "new", "Int64SliceFlag" ]

[ "func", "(", "f", "*", "Int64SliceFlag", ")", "Apply", "(", "set", "*", "flag", ".", "FlagSet", ")", "{", "f", ".", "set", "=", "set", "\n", "f", ".", "Int64SliceFlag", ".", "Apply", "(", "set", ")", "\n", "}" ]

[ "Apply", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "Int64SliceFlag", ".", "Apply" ]

[ "func", "(", "f", "*", "Int64SliceFlag", ")", "ApplyWithError", "(", "set", "*", "flag", ".", "FlagSet", ")", "error", "{", "f", ".", "set", "=", "set", "\n", "return", "f", ".", "Int64SliceFlag", ".", "ApplyWithError", "(", "set", ")", "\n", "}" ]

[ "ApplyWithError", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "Int64SliceFlag", ".", "ApplyWithError" ]

[ "func", "NewStringFlag", "(", "fl", "cli", ".", "StringFlag", ")", "*", "StringFlag", "{", "return", "&", "StringFlag", "{", "StringFlag", ":", "fl", ",", "set", ":", "nil", "}", "\n", "}" ]

[ "NewStringFlag", "creates", "a", "new", "StringFlag" ]

[ "func", "(", "f", "*", "StringFlag", ")", "Apply", "(", "set", "*", "flag", ".", "FlagSet", ")", "{", "f", ".", "set", "=", "set", "\n", "f", ".", "StringFlag", ".", "Apply", "(", "set", ")", "\n", "}" ]

[ "Apply", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "StringFlag", ".", "Apply" ]

[ "func", "(", "f", "*", "StringFlag", ")", "ApplyWithError", "(", "set", "*", "flag", ".", "FlagSet", ")", "error", "{", "f", ".", "set", "=", "set", "\n", "return", "f", ".", "StringFlag", ".", "ApplyWithError", "(", "set", ")", "\n", "}" ]

[ "ApplyWithError", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "StringFlag", ".", "ApplyWithError" ]

[ "func", "NewStringSliceFlag", "(", "fl", "cli", ".", "StringSliceFlag", ")", "*", "StringSliceFlag", "{", "return", "&", "StringSliceFlag", "{", "StringSliceFlag", ":", "fl", ",", "set", ":", "nil", "}", "\n", "}" ]

[ "NewStringSliceFlag", "creates", "a", "new", "StringSliceFlag" ]

[ "func", "(", "f", "*", "StringSliceFlag", ")", "Apply", "(", "set", "*", "flag", ".", "FlagSet", ")", "{", "f", ".", "set", "=", "set", "\n", "f", ".", "StringSliceFlag", ".", "Apply", "(", "set", ")", "\n", "}" ]

[ "Apply", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "StringSliceFlag", ".", "Apply" ]

[ "func", "(", "f", "*", "StringSliceFlag", ")", "ApplyWithError", "(", "set", "*", "flag", ".", "FlagSet", ")", "error", "{", "f", ".", "set", "=", "set", "\n", "return", "f", ".", "StringSliceFlag", ".", "ApplyWithError", "(", "set", ")", "\n", "}" ]

[ "ApplyWithError", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "StringSliceFlag", ".", "ApplyWithError" ]

[ "func", "NewUint64Flag", "(", "fl", "cli", ".", "Uint64Flag", ")", "*", "Uint64Flag", "{", "return", "&", "Uint64Flag", "{", "Uint64Flag", ":", "fl", ",", "set", ":", "nil", "}", "\n", "}" ]

[ "NewUint64Flag", "creates", "a", "new", "Uint64Flag" ]

[ "func", "(", "f", "*", "Uint64Flag", ")", "Apply", "(", "set", "*", "flag", ".", "FlagSet", ")", "{", "f", ".", "set", "=", "set", "\n", "f", ".", "Uint64Flag", ".", "Apply", "(", "set", ")", "\n", "}" ]

[ "Apply", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "Uint64Flag", ".", "Apply" ]

[ "func", "(", "f", "*", "Uint64Flag", ")", "ApplyWithError", "(", "set", "*", "flag", ".", "FlagSet", ")", "error", "{", "f", ".", "set", "=", "set", "\n", "return", "f", ".", "Uint64Flag", ".", "ApplyWithError", "(", "set", ")", "\n", "}" ]

[ "ApplyWithError", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "Uint64Flag", ".", "ApplyWithError" ]

[ "func", "NewUintFlag", "(", "fl", "cli", ".", "UintFlag", ")", "*", "UintFlag", "{", "return", "&", "UintFlag", "{", "UintFlag", ":", "fl", ",", "set", ":", "nil", "}", "\n", "}" ]

[ "NewUintFlag", "creates", "a", "new", "UintFlag" ]

[ "func", "(", "f", "*", "UintFlag", ")", "Apply", "(", "set", "*", "flag", ".", "FlagSet", ")", "{", "f", ".", "set", "=", "set", "\n", "f", ".", "UintFlag", ".", "Apply", "(", "set", ")", "\n", "}" ]

[ "Apply", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "UintFlag", ".", "Apply" ]

[ "func", "(", "f", "*", "UintFlag", ")", "ApplyWithError", "(", "set", "*", "flag", ".", "FlagSet", ")", "error", "{", "f", ".", "set", "=", "set", "\n", "return", "f", ".", "UintFlag", ".", "ApplyWithError", "(", "set", ")", "\n", "}" ]

[ "ApplyWithError", "saves", "the", "flagSet", "for", "later", "usage", "calls", "then", "calls", "the", "wrapped", "UintFlag", ".", "ApplyWithError" ]

[ "func", "(", "c", "Command", ")", "FullName", "(", ")", "string", "{", "if", "c", ".", "commandNamePath", "==", "nil", "{", "return", "c", ".", "Name", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "c", ".", "commandNamePath", ",", "\"", "\"", ")", "\n", "}" ]

[ "FullName", "returns", "the", "full", "name", "of", "the", "command", ".", "For", "subcommands", "this", "ensures", "that", "parent", "commands", "are", "part", "of", "the", "command", "path" ]

[ "func", "reorderArgs", "(", "args", "[", "]", "string", ")", "[", "]", "string", "{", "var", "nonflags", ",", "flags", "[", "]", "string", "\n\n", "readFlagValue", ":=", "false", "\n", "for", "i", ",", "arg", ":=", "range", "args", "{", "if", "arg", "==", "\"", "\"", "{", "nonflags", "=", "append", "(", "nonflags", ",", "args", "[", "i", ":", "]", "...", ")", "\n", "break", "\n", "}", "\n\n", "if", "readFlagValue", "&&", "!", "strings", ".", "HasPrefix", "(", "arg", ",", "\"", "\"", ")", "&&", "!", "strings", ".", "HasPrefix", "(", "arg", ",", "\"", "\"", ")", "{", "readFlagValue", "=", "false", "\n", "flags", "=", "append", "(", "flags", ",", "arg", ")", "\n", "continue", "\n", "}", "\n", "readFlagValue", "=", "false", "\n\n", "if", "arg", "!=", "\"", "\"", "&&", "strings", ".", "HasPrefix", "(", "arg", ",", "\"", "\"", ")", "{", "flags", "=", "append", "(", "flags", ",", "arg", ")", "\n\n", "readFlagValue", "=", "!", "strings", ".", "Contains", "(", "arg", ",", "\"", "\"", ")", "\n", "}", "else", "{", "nonflags", "=", "append", "(", "nonflags", ",", "arg", ")", "\n", "}", "\n", "}", "\n\n", "return", "append", "(", "flags", ",", "nonflags", "...", ")", "\n", "}" ]

[ "reorderArgs", "moves", "all", "flags", "before", "arguments", "as", "this", "is", "what", "flag", "expects" ]

[ "func", "(", "c", "Command", ")", "Names", "(", ")", "[", "]", "string", "{", "names", ":=", "[", "]", "string", "{", "c", ".", "Name", "}", "\n\n", "if", "c", ".", "ShortName", "!=", "\"", "\"", "{", "names", "=", "append", "(", "names", ",", "c", ".", "ShortName", ")", "\n", "}", "\n\n", "return", "append", "(", "names", ",", "c", ".", "Aliases", "...", ")", "\n", "}" ]

[ "Names", "returns", "the", "names", "including", "short", "names", "and", "aliases", "." ]