adjuat-iten-walkier

Signed-off-by: yaacov <kobi.zamir@gmail.com>

Author: yaacov

v6/Makefile

@@ -2,11 +2,11 @@
 # Compiler and tools
 #------------------------------------------------------------------------------
 GO = go
+GOLINT = $(shell which golangci-lint 2>/dev/null || echo $(HOME)/go/bin/golangci-lint)
 
 #------------------------------------------------------------------------------
 # Tools and flags
 #------------------------------------------------------------------------------
-GOLINT = golangci-lint
 GO_TEST_FLAGS = -v -race
 GO_TEST_COVERAGE_FLAGS = -coverprofile=coverage.out
 
@@ -47,6 +47,7 @@ help:
 	@echo "  format        - Format the code using go fmt"
 	@echo "  clean         - Remove built binary files and coverage output"
 	@echo "  clean-all     - Remove all built and generated files including parser files"
+	@echo "  install-tools - Install development tools (golangci-lint)"
 
 parser-gen:
 	cd pkg/parser && ./build.sh
@@ -87,3 +88,6 @@ clean:
 
 clean-all:
 	rm -rf pkg/tsl/tsl_parser.tab.* pkg/tsl/lex.yy.c $(GO_BIN) $(GO_PARSER_BIN) $(GO_MEM_BIN) coverage.out
+
+install-tools:
+	go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

v6/cmd/tsl_mem/main.go

@@ -57,7 +57,7 @@ func main() {
 	defer tree.Free()
 
 	// Walk the TSL tree and replace identifiers.
-	newTree, _, err := ident.Walk(tree, checkColumnName)
+	newTree, err := ident.Walk(tree, checkColumnName)
 	check(err)
 	defer newTree.Free()
 

v6/cmd/tsl_parser/main.go

@@ -41,7 +41,7 @@ func main() {
 
 	// Setup the input.
 	inputPtr := flag.String("i", "", "the tsl string to parse (e.g. \"title = 'kitty'\")")
-	outputPtr := flag.String("o", "json", "output format [json/yaml/prettyjson/sql/dot]")
+	outputPtr := flag.String("o", "json", "output format [json/yaml/sql/dot]")
 	tablePtr := flag.String("t", "table_name", "table name for SQL output")
 	flag.Parse()
 

v6/pkg/parser/README.md

@@ -18,6 +18,10 @@ The parser code is automatically generated using the `go generate` command. The
 
 To stop autogeneration, remove or comment this line from `pkg/tsl/tsl.go`.
 
+```go
+// //go:generate bash ../parser/build.sh
+```
+
 ## Requirements
 
 To generate the parser code, you need:

v6/pkg/tsl/tsl.go

@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-////go:generate bash ../parser/build.sh
+// //go:generate bash ../parser/build.sh
 
 package tsl
 

v6/pkg/walkers/ident/walk.go

@@ -44,49 +44,39 @@ import (
 //		}
 //
 //		// If not found return string as is, and an error.
-//		return s, fmt.Errorf("column not found")
+//		return nil, fmt.Errorf("column not found")
 //	}
 //
 //	// Check and replace user identifiers with the SQL table column names,
-//	// and get a list of all identifiers used in the tree.
+//	// and return the new tree.
 //	//
 //	// If the input tree contains: `spec.pages > 100 AND author = "Joe"`,
-//	// the identifiers list will contain: ["spec.pages", "author"]
-//	//
 //	// the new tree will contain: `pages > 100 AND author = "Joe"`
-//	newTree, identifiers, err = ident.Walk(tree, check)
+//	newTree, err = ident.Walk(tree, check)
 //	defer newTree.Free()
-func Walk(n *tsl.TSLNode, check func(s string) (string, error)) (*tsl.TSLNode, []string, error) {
+func Walk(n *tsl.TSLNode, check func(s string) (string, error)) (*tsl.TSLNode, error) {
 	if n == nil {
-		return nil, nil, nil
+		return nil, nil
 	}
 
 	// Create a deep copy of the input tree to avoid mutations
 	treeCopy := n.Clone()
 	if treeCopy == nil {
-		return nil, nil, fmt.Errorf("failed to clone input tree")
+		return nil, fmt.Errorf("failed to clone input tree")
 	}
 
-	identifiers := make(map[string]bool)
-	newTree, err := walkAndReplace(treeCopy, check, identifiers)
+	newTree, err := walkAndReplace(treeCopy, check)
 	if err != nil {
 		treeCopy.Free() // Clean up the copy if there's an error
-		return nil, nil, err
-	}
-
-	// Convert map to slice
-	identList := make([]string, 0, len(identifiers))
-	for ident := range identifiers {
-		identList = append(identList, ident)
+		return nil, err
 	}
 
-	return newTree, identList, nil
+	return newTree, nil
 }
 
 // processIdentifier handles the common logic for processing identifier nodes
-func processIdentifier(n *tsl.TSLNode, identifiers map[string]bool, check func(s string) (string, error)) (*tsl.TSLNode, error) {
+func processIdentifier(n *tsl.TSLNode, check func(s string) (string, error)) (*tsl.TSLNode, error) {
 	ident := n.Value().(string)
-	identifiers[ident] = true
 
 	newIdent, err := check(ident)
 	if err != nil {
@@ -96,7 +86,7 @@ func processIdentifier(n *tsl.TSLNode, identifiers map[string]bool, check func(s
 	return tsl.ParseTSL(newIdent)
 }
 
-func walkAndReplace(n *tsl.TSLNode, check func(s string) (string, error), identifiers map[string]bool) (*tsl.TSLNode, error) {
+func walkAndReplace(n *tsl.TSLNode, check func(s string) (string, error)) (*tsl.TSLNode, error) {
 	if n == nil {
 		return nil, nil
 	}
@@ -108,27 +98,27 @@ func walkAndReplace(n *tsl.TSLNode, check func(s string) (string, error), identi
 		// Process both sides of the binary expression
 		left := op.Left
 		if left.Type() == tsl.KindIdentifier {
-			newNode, err := processIdentifier(left, identifiers, check)
+			newNode, err := processIdentifier(left, check)
 			if err != nil {
 				return nil, err
 			}
 			n.AttachLeft(newNode)
 		} else {
-			_, err := walkAndReplace(left, check, identifiers)
+			_, err := walkAndReplace(left, check)
 			if err != nil {
 				return nil, err
 			}
 		}
 
 		right := op.Right
 		if right.Type() == tsl.KindIdentifier {
-			newNode, err := processIdentifier(right, identifiers, check)
+			newNode, err := processIdentifier(right, check)
 			if err != nil {
 				return nil, err
 			}
 			n.AttachRight(newNode)
 		} else {
-			_, err := walkAndReplace(right, check, identifiers)
+			_, err := walkAndReplace(right, check)
 			if err != nil {
 				return nil, err
 			}
@@ -142,13 +132,13 @@ func walkAndReplace(n *tsl.TSLNode, check func(s string) (string, error), identi
 		// Process the operand
 		right := op.Right
 		if right.Type() == tsl.KindIdentifier {
-			newNode, err := processIdentifier(right, identifiers, check)
+			newNode, err := processIdentifier(right, check)
 			if err != nil {
 				return nil, err
 			}
 			n.AttachChild(newNode)
 		} else {
-			_, err := walkAndReplace(right, check, identifiers)
+			_, err := walkAndReplace(right, check)
 			if err != nil {
 				return nil, err
 			}
@@ -157,7 +147,7 @@ func walkAndReplace(n *tsl.TSLNode, check func(s string) (string, error), identi
 		return n, nil
 
 	case tsl.KindIdentifier:
-		return processIdentifier(n, identifiers, check)
+		return processIdentifier(n, check)
 
 	default:
 		return n, nil

v6/pkg/walkers/ident/walk_test.go

@@ -17,7 +17,6 @@ package ident
 
 import (
 	"fmt"
-	"sort"
 	"testing"
 
 	. "github.com/onsi/ginkgo"
@@ -59,11 +58,9 @@ var _ = Describe("Walk", func() {
 		Expect(err).ToNot(HaveOccurred())
 		defer tree.Free()
 
-		newTree, idents, err := Walk(tree, check)
+		newTree, err := Walk(tree, check)
 		Expect(err).ToNot(HaveOccurred())
 		defer newTree.Free()
-		Expect(idents).To(HaveLen(1))
-		Expect(idents).To(ContainElement("name"))
 
 		// Verify the replacement
 		Expect(newTree.Type()).To(Equal(tsl.KindBinaryExpr))
@@ -76,11 +73,9 @@ var _ = Describe("Walk", func() {
 		Expect(err).ToNot(HaveOccurred())
 		defer tree.Free()
 
-		newTree, idents, err := Walk(tree, check)
+		newTree, err := Walk(tree, check)
 		Expect(err).ToNot(HaveOccurred())
 		defer newTree.Free()
-		sort.Strings(idents)
-		Expect(idents).To(Equal([]string{"age", "city"}))
 
 		// Verify the replacement in the new tree
 		op := newTree.Value().(tsl.TSLExpressionOp)
@@ -95,12 +90,9 @@ var _ = Describe("Walk", func() {
 		Expect(err).ToNot(HaveOccurred())
 		defer tree.Free()
 
-		newTree, idents, err := Walk(tree, check)
+		newTree, err := Walk(tree, check)
 		Expect(err).ToNot(HaveOccurred())
 		defer newTree.Free()
-		sort.Strings(idents)
-		Expect(idents).To(Equal([]string{"age", "city", "country", "name"}))
-
 		// Tree structure should be preserved, just identifiers replaced
 		Expect(newTree.Type()).To(Equal(tsl.KindBinaryExpr))
 	})
@@ -110,7 +102,7 @@ var _ = Describe("Walk", func() {
 		Expect(err).ToNot(HaveOccurred())
 		defer tree.Free()
 
-		newTree, _, err := Walk(tree, check)
+		newTree, err := Walk(tree, check)
 		if err == nil {
 			defer newTree.Free()
 		}
@@ -123,11 +115,9 @@ var _ = Describe("Walk", func() {
 		Expect(err).ToNot(HaveOccurred())
 		defer tree.Free()
 
-		newTree, idents, err := Walk(tree, check)
+		newTree, err := Walk(tree, check)
 		Expect(err).ToNot(HaveOccurred())
 		defer newTree.Free()
-		sort.Strings(idents)
-		Expect(idents).To(Equal([]string{"spec.pages", "spec.rating"}))
 
 		// Verify the replacements
 		op := newTree.Value().(tsl.TSLExpressionOp)