From 4165372ec8fd142475a4e35fd0cf4f8042132208 Mon Sep 17 00:00:00 2001 From: Taras Madan Date: Wed, 22 Feb 2023 22:16:50 +0100 Subject: dependencies: update set go min requirements to 1.19 update dependencies update vendor --- .../sashamelentyev/interfacebloat/LICENSE | 21 + .../interfacebloat/pkg/analyzer/analyzer.go | 57 +++ .../sashamelentyev/usestdlibvars/LICENSE | 21 + .../usestdlibvars/pkg/analyzer/analyzer.go | 569 +++++++++++++++++++++ .../pkg/analyzer/internal/mapping/mapping.go | 199 +++++++ 5 files changed, 867 insertions(+) create mode 100644 vendor/github.com/sashamelentyev/interfacebloat/LICENSE create mode 100644 vendor/github.com/sashamelentyev/interfacebloat/pkg/analyzer/analyzer.go create mode 100644 vendor/github.com/sashamelentyev/usestdlibvars/LICENSE create mode 100644 vendor/github.com/sashamelentyev/usestdlibvars/pkg/analyzer/analyzer.go create mode 100644 vendor/github.com/sashamelentyev/usestdlibvars/pkg/analyzer/internal/mapping/mapping.go (limited to 'vendor/github.com/sashamelentyev') diff --git a/vendor/github.com/sashamelentyev/interfacebloat/LICENSE b/vendor/github.com/sashamelentyev/interfacebloat/LICENSE new file mode 100644 index 000000000..a52602b3d --- /dev/null +++ b/vendor/github.com/sashamelentyev/interfacebloat/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 Sasha Melentyev + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendor/github.com/sashamelentyev/interfacebloat/pkg/analyzer/analyzer.go b/vendor/github.com/sashamelentyev/interfacebloat/pkg/analyzer/analyzer.go new file mode 100644 index 000000000..4a6afdf8c --- /dev/null +++ b/vendor/github.com/sashamelentyev/interfacebloat/pkg/analyzer/analyzer.go @@ -0,0 +1,57 @@ +package analyzer + +import ( + "flag" + "go/ast" + + "golang.org/x/tools/go/analysis" + "golang.org/x/tools/go/analysis/passes/inspect" + "golang.org/x/tools/go/ast/inspector" +) + +const InterfaceMaxMethodsFlag = "max" + +const defaultMaxMethods = 10 + +// New returns new interfacebloat analyzer. +func New() *analysis.Analyzer { + return &analysis.Analyzer{ + Name: "interfacebloat", + Doc: "A linter that checks the number of methods inside an interface.", + Run: run, + Flags: flags(), + Requires: []*analysis.Analyzer{inspect.Analyzer}, + } +} + +func flags() flag.FlagSet { + flags := flag.NewFlagSet("", flag.ExitOnError) + flags.Int(InterfaceMaxMethodsFlag, 10, "maximum number of methods") + return *flags +} + +func run(pass *analysis.Pass) (interface{}, error) { + maxMethods, ok := pass.Analyzer.Flags.Lookup(InterfaceMaxMethodsFlag).Value.(flag.Getter).Get().(int) + if !ok { + maxMethods = defaultMaxMethods + } + + insp := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector) + + filter := []ast.Node{ + (*ast.InterfaceType)(nil), + } + + insp.Preorder(filter, func(node ast.Node) { + i, ok := node.(*ast.InterfaceType) + if !ok { + return + } + + if len(i.Methods.List) > maxMethods { + pass.Reportf(node.Pos(), `the interface has more than %d methods: %d`, maxMethods, len(i.Methods.List)) + } + }) + + return nil, nil +} diff --git a/vendor/github.com/sashamelentyev/usestdlibvars/LICENSE b/vendor/github.com/sashamelentyev/usestdlibvars/LICENSE new file mode 100644 index 000000000..a52602b3d --- /dev/null +++ b/vendor/github.com/sashamelentyev/usestdlibvars/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 Sasha Melentyev + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendor/github.com/sashamelentyev/usestdlibvars/pkg/analyzer/analyzer.go b/vendor/github.com/sashamelentyev/usestdlibvars/pkg/analyzer/analyzer.go new file mode 100644 index 000000000..4d6ab3cca --- /dev/null +++ b/vendor/github.com/sashamelentyev/usestdlibvars/pkg/analyzer/analyzer.go @@ -0,0 +1,569 @@ +package analyzer + +import ( + "flag" + "go/ast" + "go/token" + "strings" + + "golang.org/x/tools/go/analysis" + "golang.org/x/tools/go/analysis/passes/inspect" + "golang.org/x/tools/go/ast/inspector" + + "github.com/sashamelentyev/usestdlibvars/pkg/analyzer/internal/mapping" +) + +const ( + TimeWeekdayFlag = "time-weekday" + TimeMonthFlag = "time-month" + TimeLayoutFlag = "time-layout" + CryptoHashFlag = "crypto-hash" + HTTPMethodFlag = "http-method" + HTTPStatusCodeFlag = "http-status-code" + RPCDefaultPathFlag = "rpc-default-path" + OSDevNullFlag = "os-dev-null" + SQLIsolationLevelFlag = "sql-isolation-level" + TLSSignatureSchemeFlag = "tls-signature-scheme" + ConstantKindFlag = "constant-kind" + SyslogPriorityFlag = "syslog-priority" +) + +// New returns new usestdlibvars analyzer. +func New() *analysis.Analyzer { + return &analysis.Analyzer{ + Name: "usestdlibvars", + Doc: "A linter that detect the possibility to use variables/constants from the Go standard library.", + Run: run, + Flags: flags(), + Requires: []*analysis.Analyzer{inspect.Analyzer}, + } +} + +func flags() flag.FlagSet { + flags := flag.NewFlagSet("", flag.ExitOnError) + flags.Bool(HTTPMethodFlag, true, "suggest the use of http.MethodXX") + flags.Bool(HTTPStatusCodeFlag, true, "suggest the use of http.StatusXX") + flags.Bool(TimeWeekdayFlag, false, "suggest the use of time.Weekday.String()") + flags.Bool(TimeMonthFlag, false, "suggest the use of time.Month.String()") + flags.Bool(TimeLayoutFlag, false, "suggest the use of time.Layout") + flags.Bool(CryptoHashFlag, false, "suggest the use of crypto.Hash.String()") + flags.Bool(RPCDefaultPathFlag, false, "suggest the use of rpc.DefaultXXPath") + flags.Bool(OSDevNullFlag, false, "[DEPRECATED] suggest the use of os.DevNull") + flags.Bool(SQLIsolationLevelFlag, false, "suggest the use of sql.LevelXX.String()") + flags.Bool(TLSSignatureSchemeFlag, false, "suggest the use of tls.SignatureScheme.String()") + flags.Bool(ConstantKindFlag, false, "suggest the use of constant.Kind.String()") + flags.Bool(SyslogPriorityFlag, false, "[DEPRECATED] suggest the use of syslog.Priority") + return *flags +} + +func run(pass *analysis.Pass) (interface{}, error) { + insp := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector) + + types := []ast.Node{ + (*ast.CallExpr)(nil), + (*ast.BasicLit)(nil), + (*ast.CompositeLit)(nil), + (*ast.IfStmt)(nil), + (*ast.SwitchStmt)(nil), + (*ast.ForStmt)(nil), + } + + insp.Preorder(types, func(node ast.Node) { + switch n := node.(type) { + case *ast.CallExpr: + fun, ok := n.Fun.(*ast.SelectorExpr) + if !ok { + return + } + + x, ok := fun.X.(*ast.Ident) + if !ok { + return + } + + funArgs(pass, x, fun, n.Args) + + case *ast.BasicLit: + for _, c := range []struct { + flag string + checkFunc func(pass *analysis.Pass, basicLit *ast.BasicLit) + }{ + {flag: TimeWeekdayFlag, checkFunc: checkTimeWeekday}, + {flag: TimeMonthFlag, checkFunc: checkTimeMonth}, + {flag: TimeLayoutFlag, checkFunc: checkTimeLayout}, + {flag: CryptoHashFlag, checkFunc: checkCryptoHash}, + {flag: RPCDefaultPathFlag, checkFunc: checkRPCDefaultPath}, + {flag: OSDevNullFlag, checkFunc: checkOSDevNull}, + {flag: SQLIsolationLevelFlag, checkFunc: checkSQLIsolationLevel}, + {flag: TLSSignatureSchemeFlag, checkFunc: checkTLSSignatureScheme}, + {flag: ConstantKindFlag, checkFunc: checkConstantKind}, + } { + if lookupFlag(pass, c.flag) { + c.checkFunc(pass, n) + } + } + + case *ast.CompositeLit: + typ, ok := n.Type.(*ast.SelectorExpr) + if !ok { + return + } + + x, ok := typ.X.(*ast.Ident) + if !ok { + return + } + + typeElts(pass, x, typ, n.Elts) + + case *ast.IfStmt: + cond, ok := n.Cond.(*ast.BinaryExpr) + if !ok { + return + } + + switch cond.Op { + case token.LSS, token.GTR, token.LEQ, token.GEQ: + return + } + + x, ok := cond.X.(*ast.SelectorExpr) + if !ok { + return + } + + y, ok := cond.Y.(*ast.BasicLit) + if !ok { + return + } + + ifElseStmt(pass, x, y) + + case *ast.SwitchStmt: + x, ok := n.Tag.(*ast.SelectorExpr) + if ok { + switchStmt(pass, x, n.Body.List) + } else { + switchStmtAsIfElseStmt(pass, n.Body.List) + } + + case *ast.ForStmt: + cond, ok := n.Cond.(*ast.BinaryExpr) + if !ok { + return + } + + x, ok := cond.X.(*ast.SelectorExpr) + if !ok { + return + } + + y, ok := cond.Y.(*ast.BasicLit) + if !ok { + return + } + + ifElseStmt(pass, x, y) + } + }) + + return nil, nil +} + +// funArgs checks arguments of function or method. +func funArgs(pass *analysis.Pass, x *ast.Ident, fun *ast.SelectorExpr, args []ast.Expr) { + switch x.Name { + case "http": + switch fun.Sel.Name { + // http.NewRequest(http.MethodGet, "localhost", http.NoBody) + case "NewRequest": + if !lookupFlag(pass, HTTPMethodFlag) { + return + } + + if basicLit := getBasicLitFromArgs(args, 3, 0, token.STRING); basicLit != nil { + checkHTTPMethod(pass, basicLit) + } + + // http.NewRequestWithContext(context.Background(), http.MethodGet, "localhost", http.NoBody) + case "NewRequestWithContext": + if !lookupFlag(pass, HTTPMethodFlag) { + return + } + + if basicLit := getBasicLitFromArgs(args, 4, 1, token.STRING); basicLit != nil { + checkHTTPMethod(pass, basicLit) + } + + // http.Error(w, err, http.StatusInternalServerError) + case "Error": + if !lookupFlag(pass, HTTPStatusCodeFlag) { + return + } + + if basicLit := getBasicLitFromArgs(args, 3, 2, token.INT); basicLit != nil { + checkHTTPStatusCode(pass, basicLit) + } + + // http.StatusText(http.StatusOK) + case "StatusText": + if !lookupFlag(pass, HTTPStatusCodeFlag) { + return + } + + if basicLit := getBasicLitFromArgs(args, 1, 0, token.INT); basicLit != nil { + checkHTTPStatusCode(pass, basicLit) + } + + // http.Redirect(w, r, "localhost", http.StatusMovedPermanently) + case "Redirect": + if !lookupFlag(pass, HTTPStatusCodeFlag) { + return + } + + if basicLit := getBasicLitFromArgs(args, 4, 3, token.INT); basicLit != nil { + checkHTTPStatusCode(pass, basicLit) + } + + // http.RedirectHandler("localhost", http.StatusMovedPermanently) + case "RedirectHandler": + if !lookupFlag(pass, HTTPStatusCodeFlag) { + return + } + + if basicLit := getBasicLitFromArgs(args, 2, 1, token.INT); basicLit != nil { + checkHTTPStatusCode(pass, basicLit) + } + } + case "httptest": + if fun.Sel.Name == "NewRequest" { + if !lookupFlag(pass, HTTPMethodFlag) { + return + } + + if basicLit := getBasicLitFromArgs(args, 3, 0, token.STRING); basicLit != nil { + checkHTTPMethod(pass, basicLit) + } + } + case "syslog": + if !lookupFlag(pass, SyslogPriorityFlag) { + return + } + + switch fun.Sel.Name { + case "New": + if basicLit := getBasicLitFromArgs(args, 2, 0, token.INT); basicLit != nil { + checkSyslogPriority(pass, basicLit) + } + + case "Dial": + if basicLit := getBasicLitFromArgs(args, 4, 2, token.INT); basicLit != nil { + checkSyslogPriority(pass, basicLit) + } + + case "NewLogger": + if basicLit := getBasicLitFromArgs(args, 2, 0, token.INT); basicLit != nil { + checkSyslogPriority(pass, basicLit) + } + } + default: + // w.WriteHeader(http.StatusOk) + if fun.Sel.Name == "WriteHeader" { + if !lookupFlag(pass, HTTPStatusCodeFlag) { + return + } + + if basicLit := getBasicLitFromArgs(args, 1, 0, token.INT); basicLit != nil { + checkHTTPStatusCode(pass, basicLit) + } + } + } +} + +// typeElts checks elements of type. +func typeElts(pass *analysis.Pass, x *ast.Ident, typ *ast.SelectorExpr, elts []ast.Expr) { + switch x.Name { + case "http": + switch typ.Sel.Name { + // http.Request{Method: http.MethodGet} + case "Request": + if !lookupFlag(pass, HTTPMethodFlag) { + return + } + + if basicLit := getBasicLitFromElts(elts, "Method"); basicLit != nil { + checkHTTPMethod(pass, basicLit) + } + + // http.Response{StatusCode: http.StatusOK} + case "Response": + if !lookupFlag(pass, HTTPStatusCodeFlag) { + return + } + + if basicLit := getBasicLitFromElts(elts, "StatusCode"); basicLit != nil { + checkHTTPStatusCode(pass, basicLit) + } + } + case "httptest": + if typ.Sel.Name == "ResponseRecorder" { + if !lookupFlag(pass, HTTPStatusCodeFlag) { + return + } + + if basicLit := getBasicLitFromElts(elts, "Code"); basicLit != nil { + checkHTTPStatusCode(pass, basicLit) + } + } + } +} + +// ifElseStmt checks X and Y in if-else-statement. +func ifElseStmt(pass *analysis.Pass, x *ast.SelectorExpr, y *ast.BasicLit) { + switch x.Sel.Name { + case "StatusCode": + if !lookupFlag(pass, HTTPStatusCodeFlag) { + return + } + + checkHTTPStatusCode(pass, y) + + case "Method": + if !lookupFlag(pass, HTTPMethodFlag) { + return + } + + checkHTTPMethod(pass, y) + } +} + +func switchStmt(pass *analysis.Pass, x *ast.SelectorExpr, cases []ast.Stmt) { + var checkFunc func(pass *analysis.Pass, basicLit *ast.BasicLit) + + switch x.Sel.Name { + case "StatusCode": + if !lookupFlag(pass, HTTPStatusCodeFlag) { + return + } + + checkFunc = checkHTTPStatusCode + + case "Method": + if !lookupFlag(pass, HTTPMethodFlag) { + return + } + + checkFunc = checkHTTPMethod + + default: + return + } + + for _, c := range cases { + caseClause, ok := c.(*ast.CaseClause) + if !ok { + continue + } + + for _, expr := range caseClause.List { + basicLit, ok := expr.(*ast.BasicLit) + if !ok { + continue + } + + checkFunc(pass, basicLit) + } + } +} + +func switchStmtAsIfElseStmt(pass *analysis.Pass, cases []ast.Stmt) { + for _, c := range cases { + caseClause, ok := c.(*ast.CaseClause) + if !ok { + continue + } + + for _, expr := range caseClause.List { + binaryExpr, ok := expr.(*ast.BinaryExpr) + if !ok { + continue + } + + x, ok := binaryExpr.X.(*ast.SelectorExpr) + if !ok { + continue + } + + y, ok := binaryExpr.Y.(*ast.BasicLit) + if !ok { + continue + } + + ifElseStmt(pass, x, y) + } + } +} + +func lookupFlag(pass *analysis.Pass, name string) bool { + return pass.Analyzer.Flags.Lookup(name).Value.(flag.Getter).Get().(bool) +} + +func checkHTTPMethod(pass *analysis.Pass, basicLit *ast.BasicLit) { + currentVal := getBasicLitValue(basicLit) + + key := strings.ToUpper(currentVal) + + if newVal, ok := mapping.HTTPMethod[key]; ok { + report(pass, basicLit.Pos(), currentVal, newVal) + } +} + +func checkHTTPStatusCode(pass *analysis.Pass, basicLit *ast.BasicLit) { + currentVal := getBasicLitValue(basicLit) + + if newVal, ok := mapping.HTTPStatusCode[currentVal]; ok { + report(pass, basicLit.Pos(), currentVal, newVal) + } +} + +func checkTimeWeekday(pass *analysis.Pass, basicLit *ast.BasicLit) { + currentVal := getBasicLitValue(basicLit) + + if newVal, ok := mapping.TimeWeekday[currentVal]; ok { + report(pass, basicLit.Pos(), currentVal, newVal) + } +} + +func checkTimeMonth(pass *analysis.Pass, basicLit *ast.BasicLit) { + currentVal := getBasicLitValue(basicLit) + + if newVal, ok := mapping.TimeMonth[currentVal]; ok { + report(pass, basicLit.Pos(), currentVal, newVal) + } +} + +func checkTimeLayout(pass *analysis.Pass, basicLit *ast.BasicLit) { + currentVal := getBasicLitValue(basicLit) + + if newVal, ok := mapping.TimeLayout[currentVal]; ok { + report(pass, basicLit.Pos(), currentVal, newVal) + } +} + +func checkCryptoHash(pass *analysis.Pass, basicLit *ast.BasicLit) { + currentVal := getBasicLitValue(basicLit) + + if newVal, ok := mapping.CryptoHash[currentVal]; ok { + report(pass, basicLit.Pos(), currentVal, newVal) + } +} + +func checkRPCDefaultPath(pass *analysis.Pass, basicLit *ast.BasicLit) { + currentVal := getBasicLitValue(basicLit) + + if newVal, ok := mapping.RPCDefaultPath[currentVal]; ok { + report(pass, basicLit.Pos(), currentVal, newVal) + } +} + +func checkOSDevNull(pass *analysis.Pass, basicLit *ast.BasicLit) {} + +func checkSQLIsolationLevel(pass *analysis.Pass, basicLit *ast.BasicLit) { + currentVal := getBasicLitValue(basicLit) + + if newVal, ok := mapping.SQLIsolationLevel[currentVal]; ok { + report(pass, basicLit.Pos(), currentVal, newVal) + } +} + +func checkTLSSignatureScheme(pass *analysis.Pass, basicLit *ast.BasicLit) { + currentVal := getBasicLitValue(basicLit) + + if newVal, ok := mapping.TLSSignatureScheme[currentVal]; ok { + report(pass, basicLit.Pos(), currentVal, newVal) + } +} + +func checkConstantKind(pass *analysis.Pass, basicLit *ast.BasicLit) { + currentVal := getBasicLitValue(basicLit) + + if newVal, ok := mapping.ConstantKind[currentVal]; ok { + report(pass, basicLit.Pos(), currentVal, newVal) + } +} + +func checkSyslogPriority(pass *analysis.Pass, basicLit *ast.BasicLit) {} + +// getBasicLitFromArgs gets the *ast.BasicLit of a function argument. +// +// Arguments: +// - args - slice of function arguments +// - count - expected number of argument in function +// - idx - index of the argument to get the *ast.BasicLit +// - typ - argument type +func getBasicLitFromArgs(args []ast.Expr, count, idx int, typ token.Token) *ast.BasicLit { + if len(args) != count { + return nil + } + + if idx > count-1 { + return nil + } + + basicLit, ok := args[idx].(*ast.BasicLit) + if !ok { + return nil + } + + if basicLit.Kind != typ { + return nil + } + + return basicLit +} + +// getBasicLitFromElts gets the *ast.BasicLit of a struct elements. +// +// Arguments: +// - elts - slice of a struct elements +// - key - name of key in struct +func getBasicLitFromElts(elts []ast.Expr, key string) *ast.BasicLit { + for _, e := range elts { + keyValueExpr, ok := e.(*ast.KeyValueExpr) + if !ok { + continue + } + + ident, ok := keyValueExpr.Key.(*ast.Ident) + if !ok { + continue + } + + if ident.Name != key { + continue + } + + if basicLit, ok := keyValueExpr.Value.(*ast.BasicLit); ok { + return basicLit + } + } + + return nil +} + +// getBasicLitValue returns BasicLit value as string without quotes. +func getBasicLitValue(basicLit *ast.BasicLit) string { + var val strings.Builder + for _, r := range basicLit.Value { + if r == '"' { + continue + } else { + val.WriteRune(r) + } + } + return val.String() +} + +func report(pass *analysis.Pass, pos token.Pos, currentVal, newVal string) { + pass.Reportf(pos, "%q can be replaced by %s", currentVal, newVal) +} diff --git a/vendor/github.com/sashamelentyev/usestdlibvars/pkg/analyzer/internal/mapping/mapping.go b/vendor/github.com/sashamelentyev/usestdlibvars/pkg/analyzer/internal/mapping/mapping.go new file mode 100644 index 000000000..b081edea3 --- /dev/null +++ b/vendor/github.com/sashamelentyev/usestdlibvars/pkg/analyzer/internal/mapping/mapping.go @@ -0,0 +1,199 @@ +package mapping + +import ( + "crypto" + "crypto/tls" + "database/sql" + "go/constant" + "net/http" + "net/rpc" + "strconv" + "time" +) + +var CryptoHash = map[string]string{ + crypto.MD4.String(): "crypto.MD4.String()", + crypto.MD5.String(): "crypto.MD5.String()", + crypto.SHA1.String(): "crypto.SHA1.String()", + crypto.SHA224.String(): "crypto.SHA224.String()", + crypto.SHA256.String(): "crypto.SHA256.String()", + crypto.SHA384.String(): "crypto.SHA384.String()", + crypto.SHA512.String(): "crypto.SHA512.String()", + crypto.MD5SHA1.String(): "crypto.MD5SHA1.String()", + crypto.RIPEMD160.String(): "crypto.RIPEMD160.String()", + crypto.SHA3_224.String(): "crypto.SHA3_224.String()", + crypto.SHA3_256.String(): "crypto.SHA3_256.String()", + crypto.SHA3_384.String(): "crypto.SHA3_384.String()", + crypto.SHA3_512.String(): "crypto.SHA3_512.String()", + crypto.SHA512_224.String(): "crypto.SHA512_224.String()", + crypto.SHA512_256.String(): "crypto.SHA512_256.String()", + crypto.BLAKE2s_256.String(): "crypto.BLAKE2s_256.String()", + crypto.BLAKE2b_256.String(): "crypto.BLAKE2b_256.String()", + crypto.BLAKE2b_384.String(): "crypto.BLAKE2b_384.String()", + crypto.BLAKE2b_512.String(): "crypto.BLAKE2b_512.String()", +} + +var HTTPMethod = map[string]string{ + http.MethodGet: "http.MethodGet", + http.MethodHead: "http.MethodHead", + http.MethodPost: "http.MethodPost", + http.MethodPut: "http.MethodPut", + http.MethodPatch: "http.MethodPatch", + http.MethodDelete: "http.MethodDelete", + http.MethodConnect: "http.MethodConnect", + http.MethodOptions: "http.MethodOptions", + http.MethodTrace: "http.MethodTrace", +} + +var HTTPStatusCode = map[string]string{ + strconv.Itoa(http.StatusContinue): "http.StatusContinue", + strconv.Itoa(http.StatusSwitchingProtocols): "http.StatusSwitchingProtocols", + strconv.Itoa(http.StatusProcessing): "http.StatusProcessing", + strconv.Itoa(http.StatusEarlyHints): "http.StatusEarlyHints", + + strconv.Itoa(http.StatusOK): "http.StatusOK", + strconv.Itoa(http.StatusCreated): "http.StatusCreated", + strconv.Itoa(http.StatusAccepted): "http.StatusAccepted", + strconv.Itoa(http.StatusNonAuthoritativeInfo): "http.StatusNonAuthoritativeInfo", + strconv.Itoa(http.StatusNoContent): "http.StatusNoContent", + strconv.Itoa(http.StatusResetContent): "http.StatusResetContent", + strconv.Itoa(http.StatusPartialContent): "http.StatusPartialContent", + strconv.Itoa(http.StatusMultiStatus): "http.StatusMultiStatus", + strconv.Itoa(http.StatusAlreadyReported): "http.StatusAlreadyReported", + strconv.Itoa(http.StatusIMUsed): "http.StatusIMUsed", + + strconv.Itoa(http.StatusMultipleChoices): "http.StatusMultipleChoices", + strconv.Itoa(http.StatusMovedPermanently): "http.StatusMovedPermanently", + strconv.Itoa(http.StatusFound): "http.StatusFound", + strconv.Itoa(http.StatusSeeOther): "http.StatusSeeOther", + strconv.Itoa(http.StatusNotModified): "http.StatusNotModified", + strconv.Itoa(http.StatusUseProxy): "http.StatusUseProxy", + strconv.Itoa(http.StatusTemporaryRedirect): "http.StatusTemporaryRedirect", + strconv.Itoa(http.StatusPermanentRedirect): "http.StatusPermanentRedirect", + + strconv.Itoa(http.StatusBadRequest): "http.StatusBadRequest", + strconv.Itoa(http.StatusUnauthorized): "http.StatusUnauthorized", + strconv.Itoa(http.StatusPaymentRequired): "http.StatusPaymentRequired", + strconv.Itoa(http.StatusForbidden): "http.StatusForbidden", + strconv.Itoa(http.StatusNotFound): "http.StatusNotFound", + strconv.Itoa(http.StatusMethodNotAllowed): "http.StatusMethodNotAllowed", + strconv.Itoa(http.StatusNotAcceptable): "http.StatusNotAcceptable", + strconv.Itoa(http.StatusProxyAuthRequired): "http.StatusProxyAuthRequired", + strconv.Itoa(http.StatusRequestTimeout): "http.StatusRequestTimeout", + strconv.Itoa(http.StatusConflict): "http.StatusConflict", + strconv.Itoa(http.StatusGone): "http.StatusGone", + strconv.Itoa(http.StatusLengthRequired): "http.StatusLengthRequired", + strconv.Itoa(http.StatusPreconditionFailed): "http.StatusPreconditionFailed", + strconv.Itoa(http.StatusRequestEntityTooLarge): "http.StatusRequestEntityTooLarge", + strconv.Itoa(http.StatusRequestURITooLong): "http.StatusRequestURITooLong", + strconv.Itoa(http.StatusUnsupportedMediaType): "http.StatusUnsupportedMediaType", + strconv.Itoa(http.StatusRequestedRangeNotSatisfiable): "http.StatusRequestedRangeNotSatisfiable", + strconv.Itoa(http.StatusExpectationFailed): "http.StatusExpectationFailed", + strconv.Itoa(http.StatusTeapot): "http.StatusTeapot", + strconv.Itoa(http.StatusMisdirectedRequest): "http.StatusMisdirectedRequest", + strconv.Itoa(http.StatusUnprocessableEntity): "http.StatusUnprocessableEntity", + strconv.Itoa(http.StatusLocked): "http.StatusLocked", + strconv.Itoa(http.StatusFailedDependency): "http.StatusFailedDependency", + strconv.Itoa(http.StatusTooEarly): "http.StatusTooEarly", + strconv.Itoa(http.StatusUpgradeRequired): "http.StatusUpgradeRequired", + strconv.Itoa(http.StatusPreconditionRequired): "http.StatusPreconditionRequired", + strconv.Itoa(http.StatusTooManyRequests): "http.StatusTooManyRequests", + strconv.Itoa(http.StatusRequestHeaderFieldsTooLarge): "http.StatusRequestHeaderFieldsTooLarge", + strconv.Itoa(http.StatusUnavailableForLegalReasons): "http.StatusUnavailableForLegalReasons", + + strconv.Itoa(http.StatusInternalServerError): "http.StatusInternalServerError", + strconv.Itoa(http.StatusNotImplemented): "http.StatusNotImplemented", + strconv.Itoa(http.StatusBadGateway): "http.StatusBadGateway", + strconv.Itoa(http.StatusServiceUnavailable): "http.StatusServiceUnavailable", + strconv.Itoa(http.StatusGatewayTimeout): "http.StatusGatewayTimeout", + strconv.Itoa(http.StatusHTTPVersionNotSupported): "http.StatusHTTPVersionNotSupported", + strconv.Itoa(http.StatusVariantAlsoNegotiates): "http.StatusVariantAlsoNegotiates", + strconv.Itoa(http.StatusInsufficientStorage): "http.StatusInsufficientStorage", + strconv.Itoa(http.StatusLoopDetected): "http.StatusLoopDetected", + strconv.Itoa(http.StatusNotExtended): "http.StatusNotExtended", + strconv.Itoa(http.StatusNetworkAuthenticationRequired): "http.StatusNetworkAuthenticationRequired", +} + +var RPCDefaultPath = map[string]string{ + rpc.DefaultRPCPath: "rpc.DefaultRPCPath", + rpc.DefaultDebugPath: "rpc.DefaultDebugPath", +} + +var TimeWeekday = map[string]string{ + time.Sunday.String(): "time.Sunday.String()", + time.Monday.String(): "time.Monday.String()", + time.Tuesday.String(): "time.Tuesday.String()", + time.Wednesday.String(): "time.Wednesday.String()", + time.Thursday.String(): "time.Thursday.String()", + time.Friday.String(): "time.Friday.String()", + time.Saturday.String(): "time.Saturday.String()", +} + +var TimeMonth = map[string]string{ + time.January.String(): "time.January.String()", + time.February.String(): "time.February.String()", + time.March.String(): "time.March.String()", + time.April.String(): "time.April.String()", + time.May.String(): "time.May.String()", + time.June.String(): "time.June.String()", + time.July.String(): "time.July.String()", + time.August.String(): "time.August.String()", + time.September.String(): "time.September.String()", + time.October.String(): "time.October.String()", + time.November.String(): "time.November.String()", + time.December.String(): "time.December.String()", +} + +var TimeLayout = map[string]string{ + time.Layout: "time.Layout", + time.ANSIC: "time.ANSIC", + time.UnixDate: "time.UnixDate", + time.RubyDate: "time.RubyDate", + time.RFC822: "time.RFC822", + time.RFC822Z: "time.RFC822Z", + time.RFC850: "time.RFC850", + time.RFC1123: "time.RFC1123", + time.RFC1123Z: "time.RFC1123Z", + time.RFC3339: "time.RFC3339", + time.RFC3339Nano: "time.RFC3339Nano", + time.Kitchen: "time.Kitchen", + time.Stamp: "time.Stamp", + time.StampMilli: "time.StampMilli", + time.StampMicro: "time.StampMicro", + time.StampNano: "time.StampNano", +} + +var SQLIsolationLevel = map[string]string{ + // sql.LevelDefault.String(): "sql.LevelDefault.String()", + sql.LevelReadUncommitted.String(): "sql.LevelReadUncommitted.String()", + sql.LevelReadCommitted.String(): "sql.LevelReadCommitted.String()", + sql.LevelWriteCommitted.String(): "sql.LevelWriteCommitted.String()", + sql.LevelRepeatableRead.String(): "sql.LevelRepeatableRead.String()", + // sql.LevelSnapshot.String(): "sql.LevelSnapshot.String()", + // sql.LevelSerializable.String(): "sql.LevelSerializable.String()", + // sql.LevelLinearizable.String(): "sql.LevelLinearizable.String()", +} + +var TLSSignatureScheme = map[string]string{ + tls.PSSWithSHA256.String(): "tls.PSSWithSHA256.String()", + tls.ECDSAWithP256AndSHA256.String(): "tls.ECDSAWithP256AndSHA256.String()", + tls.Ed25519.String(): "tls.Ed25519.String()", + tls.PSSWithSHA384.String(): "tls.PSSWithSHA384.String()", + tls.PSSWithSHA512.String(): "tls.PSSWithSHA512.String()", + tls.PKCS1WithSHA256.String(): "tls.PKCS1WithSHA256.String()", + tls.PKCS1WithSHA384.String(): "tls.PKCS1WithSHA384.String()", + tls.PKCS1WithSHA512.String(): "tls.PKCS1WithSHA512.String()", + tls.ECDSAWithP384AndSHA384.String(): "tls.ECDSAWithP384AndSHA384.String()", + tls.ECDSAWithP521AndSHA512.String(): "tls.ECDSAWithP521AndSHA512.String()", + tls.PKCS1WithSHA1.String(): "tls.PKCS1WithSHA1.String()", + tls.ECDSAWithSHA1.String(): "tls.ECDSAWithSHA1.String()", +} + +var ConstantKind = map[string]string{ + // constant.Unknown.String(): "constant.Unknown.String()", + constant.Bool.String(): "constant.Bool.String()", + constant.String.String(): "constant.String.String()", + constant.Int.String(): "constant.Int.String()", + constant.Float.String(): "constant.Float.String()", + constant.Complex.String(): "constant.Complex.String()", +} -- cgit mrf-deployment