Added support for Java methods in lambdas.

Author: CollinAlpert

README.MD

@@ -45,6 +45,12 @@ Features
 ---------
 
 Current version works with predicates, functions and supports the following operators: >, >=, <, <=, =, !=, &&, ||, !
+
+It is also possible to achieve ``LIKE`` operations using the String ``startsWith``, ``endsWith`` and ``contains`` methods.
+For example, the lambda expression\
+``person -> person.getAge() > 18 && person.getName().startsWith("Steve")``\
+would translate to:\
+``person.age > 18 AND person.name LIKE 'Steve%'``
 
 Feel free to open an issue with any requests you might have.
 
@@ -56,7 +62,7 @@ You can include the Maven dependency:
 <dependency>
     <groupId>com.github.collinalpert</groupId>
     <artifactId>lambda2sql</artifactId>
-    <version>1.8.5</version>
+    <version>2.0</version>
 </dependency>
 ```
 

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.github.collinalpert</groupId>
     <artifactId>lambda2sql</artifactId>
-    <version>1.8.5</version>
+    <version>2.0</version>
     <packaging>jar</packaging>
 
     <name>lambda2sql</name>

src/main/java/com/github/collinalpert/lambda2sql/ToSqlVisitor.java

@@ -13,6 +13,7 @@
 import com.trigersoft.jaque.expression.UnaryExpression;
 
 import java.util.List;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 /**
@@ -24,11 +25,15 @@ public class ToSqlVisitor implements ExpressionVisitor<StringBuilder> {
 	private LinkedListStack<List<ConstantExpression>> arguments;
 	private StringBuilder sb;
 	private Expression body;
+	private StringComparisonTypes comparisonType;
+	private boolean stringComparisonNegation;
+	private Expression javaMethodParameter;
 
 	ToSqlVisitor(String prefix) {
 		this.prefix = prefix;
 		this.sb = new StringBuilder();
 		this.arguments = new LinkedListStack<>();
+		this.comparisonType = StringComparisonTypes.NONE;
 	}
 
 	/**
@@ -51,8 +56,9 @@ private static String toSqlOp(int expressionType) {
 				return " IS NOT NULL";
 			case ExpressionType.Convert:
 				return "";
+			default:
+				return ExpressionType.toString(expressionType);
 		}
-		return ExpressionType.toString(expressionType);
 	}
 
 	/**
@@ -81,7 +87,16 @@ public StringBuilder visit(BinaryExpression e) {
 		if (quote) sb.append('(');
 
 		e.getFirst().accept(this);
-		sb.append(' ').append(toSqlOp(e.getExpressionType())).append(' ');
+		if (comparisonType == StringComparisonTypes.NONE) {
+			sb.append(' ').append(toSqlOp(e.getExpressionType())).append(' ');
+		} else {
+			if (stringComparisonNegation) {
+				sb.append(" NOT LIKE ");
+				stringComparisonNegation = false;
+			} else {
+				sb.append(" LIKE ");
+			}
+		}
 		e.getSecond().accept(this);
 
 		if (quote) sb.append(')');
@@ -106,7 +121,25 @@ public StringBuilder visit(ConstantExpression e) {
 			return sb;
 		}
 		if (e.getValue() instanceof String) {
-			return sb.append("'").append(e.getValue().toString()).append("'");
+			sb.append("'");
+			switch (comparisonType) {
+				case STARTS_WITH:
+					sb.append(e.getValue()).append('%');
+					comparisonType = StringComparisonTypes.NONE;
+					break;
+				case ENDS_WITH:
+					sb.append('%').append(e.getValue());
+					comparisonType = StringComparisonTypes.NONE;
+					break;
+				case CONTAINS:
+					sb.append('%').append(e.getValue()).append('%');
+					comparisonType = StringComparisonTypes.NONE;
+					break;
+				case NONE:
+				default:
+					sb.append(e.getValue());
+			}
+			return sb.append("'");
 		}
 		return sb.append(e.getValue().toString());
 	}
@@ -129,6 +162,10 @@ public StringBuilder visit(InvocationExpression e) {
 		if (!list.isEmpty()) {
 			arguments.push(list);
 		}
+		Predicate<String> testForJavaMethod = s -> s.endsWith("startsWith") || s.endsWith("endsWith") || s.endsWith("contains");
+		if (testForJavaMethod.test(e.getTarget().toString())) {
+			javaMethodParameter = e.getArguments().get(0);
+		}
 		return e.getTarget().accept(this);
 	}
 
@@ -163,6 +200,19 @@ public StringBuilder visit(DelegateExpression e) {
 	@Override
 	public StringBuilder visit(MemberExpression e) {
 		String name = e.getMember().getName();
+		//for support for Java methods
+		if (name.equals("startsWith")) {
+			comparisonType = StringComparisonTypes.STARTS_WITH;
+			return Expression.binary(ExpressionType.Equal, e.getInstance(), javaMethodParameter).accept(this);
+		}
+		if (name.equals("endsWith")) {
+			comparisonType = StringComparisonTypes.ENDS_WITH;
+			return Expression.binary(ExpressionType.Equal, e.getInstance(), javaMethodParameter).accept(this);
+		}
+		if (name.equals("contains")) {
+			comparisonType = StringComparisonTypes.CONTAINS;
+			return Expression.binary(ExpressionType.Equal, e.getInstance(), javaMethodParameter).accept(this);
+		}
 		name = name.replaceAll("^(get)", "");
 		name = name.substring(0, 1).toLowerCase() + name.substring(1);
 		if (prefix == null) {
@@ -198,11 +248,21 @@ public StringBuilder visit(ParameterExpression e) {
 	@Override
 	public StringBuilder visit(UnaryExpression e) {
 		if (e.getExpressionType() == ExpressionType.LogicalNot) {
-			sb.append("!");
+			//for support for negated Java methods
+			var name = ((MemberExpression) ((InvocationExpression) e.getFirst()).getTarget()).getMember().getName();
+			if (name.equals("startsWith") || name.equals("endsWith") || name.equals("contains")) {
+				stringComparisonNegation = true;
+			} else {
+				sb.append("!");
+			}
 			return e.getFirst().accept(this);
 		}
 		e.getFirst().accept(this);
 		return sb.append(toSqlOp(e.getExpressionType()));
 	}
 
+	private enum StringComparisonTypes {
+		NONE, STARTS_WITH, ENDS_WITH, CONTAINS
+	}
+
 }

src/test/java/com/github/collinalpert/lambda2sql/test/Lambda2SqlTest.java

@@ -116,8 +116,7 @@ void testParentheses() {
 		assertPredicateEqual("person.age = 18 AND (person.isAdult OR person.name = 'Steve')", p2);
 	}
 
-	//@Test
-	//This section does not work yet!
+	@Test
 	void testJavaFunctions() {
 		var name = "Steve";
 		var age = 18;
@@ -127,6 +126,7 @@ void testJavaFunctions() {
 		assertPredicateEqual("person.name LIKE 'Steve%'", person -> person.getName().startsWith(name));
 		assertPredicateEqual("person.age >= 18 OR person.name NOT LIKE 'Steve%'", person -> person.getAge() >= age || !person.getName().startsWith(name));
 		assertPredicateEqual("person.name NOT LIKE 'Steve%'", person -> !person.getName().startsWith(name));
+		assertPredicateEqual("person.name NOT LIKE 'Steve%' AND !person.isActive", person -> !person.getName().startsWith(name) && !person.isActive());
 
 		assertPredicateEqual("person.age >= 18 OR person.name LIKE '%Steve'", person -> person.getAge() >= age || person.getName().endsWith("Steve"));
 		assertPredicateEqual("person.name LIKE '%Steve'", person -> person.getName().endsWith("Steve"));
@@ -143,6 +143,10 @@ void testJavaFunctions() {
 		assertPredicateEqual("person.name NOT LIKE '%Steve%'", person -> !person.getName().contains(name));
 	}
 
+	@Test
+	void testSingle() {
+	}
+
 	private void assertPredicateEqual(String expectedSql, SqlPredicate<IPerson> p) {
 		var sql = Lambda2Sql.toSql(p, "person");
 		Assertions.assertEquals(expectedSql, sql);