Add some const addable parsing

Author: ffenix113

README.md

@@ -77,12 +77,19 @@ which contains necessary definitions for resulting SQL queries.
 ### What this project can currently do
 Please see `examples` package to see more uses and available functionality.
 
-* Basic comparisons to constants and most of binary expressions.
+* Basic comparisons to values and most of binary expressions.
 ```go
 queryable.Where(func(user User) bool {
     return (user.Name == "John" && user.ID == 1) || user.ID >= 4
 })
 ```
+* Compare to constants.
+```go
+const name = "John"
+queryable.Where(func(user User) bool {
+    return user.Name == name
+})
+```
 * Compare to true/false
 ```go
 queryable.Where(func(book *Book) bool {

internal/addables.go

@@ -27,6 +27,8 @@ func init() {
 	addBinaryGenerators()
 	addPackageIdentGenerators()
 
+	addConstGenerators()
+
 	// Basic generators, they are not specific
 	// to some type, package or variable/const.
 	addGenerator(func(p *whereBodyParser, s *ast.BasicLit, args map[string]int) Addable {
@@ -64,6 +66,17 @@ func init() {
 			return NewSimple(param, raw(s.Name))
 		}
 
+		if s.Obj != nil && s.Obj.Kind == ast.Con {
+			defObj := p.c.TypeInfo.ObjectOf(s.Obj.Decl.(*ast.ValueSpec).Values[0].(*ast.SelectorExpr).Sel)
+			_ = defObj
+
+			if valSpec, ok := s.Obj.Decl.(*ast.ValueSpec); ok {
+				if basicLit, ok := valSpec.Values[0].(*ast.BasicLit); ok {
+					return NewSimple(param, getArg(basicLit))
+				}
+			}
+		}
+
 		argPos, ok := args[s.Name]
 		if !ok {
 			p.c.panicWithPosf(s, "argument is not provided: "+s.Name)

internal/addables_test.go

@@ -1,10 +1,11 @@
 //go:generate go run ../cmd/goquery/main.go
 
-package internal
+package internal_test
 
 import (
 	"context"
 	"database/sql"
+	"math"
 	"os"
 	"testing"
 	"time"
@@ -25,6 +26,8 @@ type Extensive struct {
 	TimeCol    time.Time
 }
 
+const packageConst = 1
+
 func TestSimpleAddables(t *testing.T) {
 	tests := []struct {
 		name   string
@@ -98,6 +101,43 @@ func TestSimpleAddables(t *testing.T) {
 			},
 			result: `("time_col" + -3 * INTERVAL '1 second' = NOW())`,
 		},
+		{
+			name: "with const simple",
+			f: func(q goquery.Queryable[*Extensive]) {
+				const val = 0
+				q.Where(func(e *Extensive) bool {
+					return e.IntCol == val
+				})
+			},
+			result: `("int_col" = 0)`,
+		},
+		{
+			name: "with const from package-level same file",
+			f: func(q goquery.Queryable[*Extensive]) {
+				q.Where(func(e *Extensive) bool {
+					return e.IntCol == packageConst
+				})
+			},
+			result: `("int_col" = 1)`,
+		},
+		{
+			name: "with const from package-level different file",
+			f: func(q goquery.Queryable[*Extensive]) {
+				q.Where(func(e *Extensive) bool {
+					return e.IntCol == anotherFileConst
+				})
+			},
+			result: `("int_col" = 3)`,
+		},
+		{
+			name: "with const from another package",
+			f: func(q goquery.Queryable[*Extensive]) {
+				q.Where(func(e *Extensive) bool {
+					return e.IntCol == math.MaxInt8
+				})
+			},
+			result: `("int_col" = 127)`,
+		},
 	}
 
 	for _, test := range tests {

internal/const_generators.go

@@ -0,0 +1,60 @@
+package internal
+
+import (
+	"go/ast"
+	"go/types"
+)
+
+func addConstGenerators() {
+	// consts in the form of
+	//	const <name> = <value>
+	//	const <name> = <package>.<name>
+	// for example
+	//	const val = 55
+	//	const val = math.MaxInt
+	addGenerator(func(p *whereBodyParser, s *ast.Ident, args map[string]int) Addable {
+		if s.Obj == nil || s.Obj.Kind != ast.Con {
+			objVal := p.c.TypeInfo.ObjectOf(s)
+			if _, ok := objVal.(*types.Const); ok {
+				// If constant is just an Ident - it means that
+				// it is defined in the same package
+				return NewSimple(param, raw(p.c.exprName(s)))
+			}
+
+			return nil
+		}
+
+		switch constVal := s.Obj.Decl.(*ast.ValueSpec).Values[0].(type) {
+		case *ast.BasicLit:
+			// Just use a direct value for now.
+			// TODO: support package constants by name, not value.
+			return NewSimple(param, getArg(constVal))
+		case *ast.SelectorExpr:
+			// If it is a selector - use its name.
+			// Import for it will be added on template execution.
+			return NewSimple(param, raw(p.c.exprName(constVal)))
+		}
+
+		return nil
+	})
+
+	// consts in the form of
+	//	<package>.<name>
+	// for example
+	//	math.MaxInt
+	addGenerator(func(p *whereBodyParser, s *ast.SelectorExpr, args map[string]int) Addable {
+		obj := p.c.TypeInfo.ObjectOf(s.Sel)
+		if obj == nil {
+			return nil
+		}
+
+		if _, ok := obj.(*types.Const); ok {
+			// Same as in the above const evaluation - if it is a const
+			// from another package - it will be imported on the
+			// template execution.
+			return NewSimple(param, raw(p.c.exprName(s)))
+		}
+
+		return nil
+	})
+}

internal/const_test.go

@@ -0,0 +1,3 @@
+package internal_test
+
+const anotherFileConst = 3

internal/context.go

@@ -16,7 +16,7 @@ const InterfaceName = "Queryable"
 
 type Context struct {
 	FileSet *token.FileSet
-	AstFile ast.Node
+	AstFile *ast.File
 
 	PackageName string