From 49bdac91e18cd22b76c15325f5810a37439ef314 Mon Sep 17 00:00:00 2001 From: Muhammad Luthfi Fahlevi Date: Fri, 9 Aug 2024 15:56:49 +0700 Subject: [PATCH] refactor: resolve all lint issues --- .../elasticsearch/discovery_repository.go | 4 ++-- internal/store/postgres/asset_repository.go | 4 ++-- pkg/query_expr/es_expr.go | 21 ++++++++++--------- pkg/query_expr/query_expr.go | 10 +++++---- pkg/query_expr/sql_expr.go | 19 +++++++++-------- 5 files changed, 31 insertions(+), 27 deletions(-) diff --git a/internal/store/elasticsearch/discovery_repository.go b/internal/store/elasticsearch/discovery_repository.go index 09357c13..368ba779 100644 --- a/internal/store/elasticsearch/discovery_repository.go +++ b/internal/store/elasticsearch/discovery_repository.go @@ -6,14 +6,14 @@ import ( "encoding/json" "errors" "fmt" - generichelper "github.com/goto/compass/pkg/generic_helper" - queryexpr "github.com/goto/compass/pkg/query_expr" "io" "net/url" "strings" "time" "github.com/goto/compass/core/asset" + generichelper "github.com/goto/compass/pkg/generic_helper" + queryexpr "github.com/goto/compass/pkg/query_expr" "github.com/goto/salt/log" ) diff --git a/internal/store/postgres/asset_repository.go b/internal/store/postgres/asset_repository.go index 4c815d85..1ba93ca6 100644 --- a/internal/store/postgres/asset_repository.go +++ b/internal/store/postgres/asset_repository.go @@ -6,8 +6,6 @@ import ( "encoding/json" "errors" "fmt" - generichelper "github.com/goto/compass/pkg/generic_helper" - queryexpr "github.com/goto/compass/pkg/query_expr" "log" "strings" "time" @@ -15,6 +13,8 @@ import ( sq "github.com/Masterminds/squirrel" "github.com/goto/compass/core/asset" "github.com/goto/compass/core/user" + generichelper "github.com/goto/compass/pkg/generic_helper" + queryexpr "github.com/goto/compass/pkg/query_expr" "github.com/jmoiron/sqlx" "github.com/r3labs/diff/v2" ) diff --git a/pkg/query_expr/es_expr.go b/pkg/query_expr/es_expr.go index cab7d9a6..e943941c 100644 --- a/pkg/query_expr/es_expr.go +++ b/pkg/query_expr/es_expr.go @@ -3,6 +3,7 @@ package queryexpr import ( "encoding/json" "fmt" + "github.com/expr-lang/expr/ast" ) @@ -41,11 +42,11 @@ func (*ESExpr) Validate() error { // translateToEsQuery The idea came from ast.Walk. Currently, the development focus implement for the node type that most likely used in our needs. // TODO: implement translator for node type that still not covered right now. -func (e *ESExpr) translateToEsQuery(node *ast.Node) interface{} { - if *node == nil { +func (e *ESExpr) translateToEsQuery(node ast.Node) interface{} { + if node == nil { return nil } - switch n := (*node).(type) { + switch n := (node).(type) { case *ast.BinaryNode: return e.translateBinaryNodeToEsQuery(n) case *ast.NilNode: @@ -78,7 +79,7 @@ func (e *ESExpr) translateToEsQuery(node *ast.Node) interface{} { return nil } if nodeV, ok := result.(ast.Node); ok { - return e.translateToEsQuery(&nodeV) + return e.translateToEsQuery(nodeV) } } @@ -86,8 +87,8 @@ func (e *ESExpr) translateToEsQuery(node *ast.Node) interface{} { } func (e *ESExpr) translateBinaryNodeToEsQuery(n *ast.BinaryNode) map[string]interface{} { - left := e.translateToEsQuery(&n.Left) - right := e.translateToEsQuery(&n.Right) + left := e.translateToEsQuery(n.Left) + right := e.translateToEsQuery(n.Right) switch n.Operator { case "&&": @@ -111,13 +112,13 @@ func (e *ESExpr) translateUnaryNodeToEsQuery(n *ast.UnaryNode) interface{} { switch n.Operator { case "not": if binaryNode, ok := n.Node.(*ast.BinaryNode); ok && binaryNode.Operator == "in" { - left := e.translateToEsQuery(&binaryNode.Left) - right := e.translateToEsQuery(&binaryNode.Right) + left := e.translateToEsQuery(binaryNode.Left) + right := e.translateToEsQuery(binaryNode.Right) return e.mustNotTermsQuery(left.(string), right) } return nil case "!": - nodeValue := e.translateToEsQuery(&n.Node) + nodeValue := e.translateToEsQuery(n.Node) switch value := nodeValue.(type) { case bool: return !value @@ -136,7 +137,7 @@ func (e *ESExpr) translateUnaryNodeToEsQuery(n *ast.UnaryNode) interface{} { func (e *ESExpr) translateArrayNodeToEsQuery(n *ast.ArrayNode) []interface{} { values := make([]interface{}, len(n.Nodes)) for i, node := range n.Nodes { - values[i] = e.translateToEsQuery(&node) + values[i] = e.translateToEsQuery(node) } return values } diff --git a/pkg/query_expr/query_expr.go b/pkg/query_expr/query_expr.go index cf85d2de..3e7cac61 100644 --- a/pkg/query_expr/query_expr.go +++ b/pkg/query_expr/query_expr.go @@ -2,6 +2,7 @@ package queryexpr import ( "fmt" + "github.com/expr-lang/expr" "github.com/expr-lang/expr/ast" "github.com/expr-lang/expr/parser" @@ -30,7 +31,8 @@ func ValidateAndGetQueryFromExpr(exprStr ExprStr) (string, error) { return sqlQuery, nil } -func (s *QueryExpr) Visit(node *ast.Node) { +// Visit is implementation Visitor interface from expr-lang/expr lib, used by ast.Walk +func (s *QueryExpr) Visit(node *ast.Node) { //nolint:gocritic if n, ok := (*node).(*ast.IdentifierNode); ok { s.Identifiers = append(s.Identifiers, n.Value) } @@ -42,17 +44,17 @@ func GetIdentifiers(queryExpr string) ([]string, error) { return nil, err } queryExprVisitor := &QueryExpr{} - ast.Walk(queryExprParsed, queryExprVisitor) + ast.Walk(&queryExprParsed, queryExprVisitor) return queryExprVisitor.Identifiers, nil } -func GetTreeNodeFromQueryExpr(queryExpr string) (*ast.Node, error) { +func GetTreeNodeFromQueryExpr(queryExpr string) (ast.Node, error) { parsed, err := parser.Parse(queryExpr) if err != nil { return nil, fmt.Errorf("error parsing expression: %w", err) } - return &parsed.Node, nil + return parsed.Node, nil } func GetQueryExprResult(fn string) (any, error) { diff --git a/pkg/query_expr/sql_expr.go b/pkg/query_expr/sql_expr.go index 3f2ac6fa..efad4a7b 100644 --- a/pkg/query_expr/sql_expr.go +++ b/pkg/query_expr/sql_expr.go @@ -2,9 +2,10 @@ package queryexpr import ( "fmt" - "github.com/expr-lang/expr/ast" "strconv" "strings" + + "github.com/expr-lang/expr/ast" ) type SQLExpr struct { @@ -29,20 +30,20 @@ func (*SQLExpr) Validate() error { // ConvertToSQL The idea came from ast.Walk. Currently, the development focus implement for the node type that most likely used in our needs. // TODO: implement translator for node type that still not covered right now. -func (s *SQLExpr) ConvertToSQL(node *ast.Node) { - if *node == nil { +func (s *SQLExpr) ConvertToSQL(node ast.Node) { + if node == nil { return } - switch n := (*node).(type) { + switch n := (node).(type) { case *ast.BinaryNode: s.SQLQuery.WriteString("(") - s.ConvertToSQL(&n.Left) + s.ConvertToSQL(n.Left) // write operator operator := s.operatorToSQL(n) s.SQLQuery.WriteString(fmt.Sprintf(" %s ", strings.ToUpper(operator))) - s.ConvertToSQL(&n.Right) + s.ConvertToSQL(n.Right) s.SQLQuery.WriteString(")") case *ast.NilNode: s.SQLQuery.WriteString("NULL") @@ -60,7 +61,7 @@ func (s *SQLExpr) ConvertToSQL(node *ast.Node) { s.SQLQuery.WriteString(fmt.Sprintf("%s", n.Value)) case *ast.UnaryNode: s.patchUnaryNode(n) - s.ConvertToSQL(&n.Node) + s.ConvertToSQL(n.Node) case *ast.BuiltinNode: result, err := GetQueryExprResult(n.String()) if err != nil { @@ -70,7 +71,7 @@ func (s *SQLExpr) ConvertToSQL(node *ast.Node) { case *ast.ArrayNode: s.SQLQuery.WriteString("(") for i := range n.Nodes { - s.ConvertToSQL(&n.Nodes[i]) + s.ConvertToSQL(n.Nodes[i]) if i != len(n.Nodes)-1 { s.SQLQuery.WriteString(", ") } @@ -82,7 +83,7 @@ func (s *SQLExpr) ConvertToSQL(node *ast.Node) { return } if nodeV, ok := result.(ast.Node); ok { - s.ConvertToSQL(&nodeV) + s.ConvertToSQL(nodeV) } } }