feat: Allow =in= and =out= operators to have no arguments.

Closes: gh-9

Author: nstdio

src/main/java/cz/jirutka/rsql/parser/ast/RSQLOperators.java

@@ -38,8 +38,8 @@ public abstract class RSQLOperators {
             GREATER_THAN_OR_EQUAL = new ComparisonOperator("=ge=", ">=", Arity.nary(1)),
             LESS_THAN = new ComparisonOperator("=lt=", "<", Arity.nary(1)),
             LESS_THAN_OR_EQUAL = new ComparisonOperator("=le=", "<=", Arity.nary(1)),
-            IN = new ComparisonOperator("=in=", Arity.of(1, Integer.MAX_VALUE)),
-            NOT_IN = new ComparisonOperator("=out=", Arity.of(1, Integer.MAX_VALUE)),
+            IN = new ComparisonOperator("=in=", Arity.of(0, Integer.MAX_VALUE)),
+            NOT_IN = new ComparisonOperator("=out=", Arity.of(0, Integer.MAX_VALUE)),
             IS_NULL = new ComparisonOperator("=null=", Arity.nary(0)),
             NOT_NULL = new ComparisonOperator("=notnull=", Arity.nary(0));
 

src/main/javacc/RSQLParser.jj

@@ -206,14 +206,25 @@ List<String> Arguments():
     final Object value;
 }
 {
-    ( <LPAREN> value = CommaSepArguments() <RPAREN> ) { return (List) value; }
+    ( <LPAREN> value = OptionalCommaSepArguments() <RPAREN> ) { return (List) value; }
     |
     (value = Argument() { return Collections.singletonList((String) value); })?
     {
       return Collections.emptyList();
     }
 }
 
+List<String> OptionalCommaSepArguments():
+{
+    List<String> list = null;
+}
+{
+    [ list = CommaSepArguments() ]
+    {
+      return list == null ? Collections.emptyList() : list;
+    }
+}
+
 List<String> CommaSepArguments():
 {
     final List<String> list = new ArrayList<String>(3);

src/test/groovy/cz/jirutka/rsql/parser/RSQLParserTest.groovy

@@ -269,6 +269,46 @@ class RSQLParserTest extends Specification {
             ex.cause instanceof UnknownOperatorException
     }
 
+    def 'Should parse empty multi-argument operators'() {
+        expect:
+        parse(input) == expected
+
+        where:
+        input         | expected
+        's0=in=()'    | 'in'('s0')
+        's0=in=(   )' | 'in'('s0')
+        's0=out=()'   | out('s0')
+        's0=out=(  )' | out('s0')
+    }
+
+
+    def 'Should parse multi-argument operators with whitespaces values'() {
+        expect:
+        parse(input) == expected
+
+        where:
+        input                   | expected
+        "s0=in=(' ')"           | 'in'('s0', ' ')
+        "s0=in=('  ')"          | 'in'('s0', '  ')
+        "s0=in=('  ',' ')"      | 'in'('s0', '  ', ' ')
+        "s0=in=('  ' or ' ')"   | 'in'('s0', '  ', ' ')
+        "s0=in=('  ',' ',' ')"  | 'in'('s0', '  ', ' ', ' ')
+        "s0=out=(' ')"          | 'out'('s0', ' ')
+        "s0=out=('  ')"         | 'out'('s0', '  ')
+        "s0=out=('  ' or ' ')"  | 'out'('s0', '  ', ' ')
+        "s0=out=('  ',' ',' ')" | 'out'('s0', '  ', ' ', ' ')
+    }
+
+    def 'Should throw when coma separated args contains only coma'() {
+        when:
+        parse(input)
+
+        then:
+        thrown RSQLParserException
+
+        where:
+        input << [ 's0=in=( , )', 's0=in=( or )']
+    }
 
     //////// Helpers ////////
 
@@ -277,6 +317,7 @@ class RSQLParserTest extends Specification {
     def and(Node... nodes) { new AndNode(nodes as List) }
     def or(Node... nodes) { new OrNode(nodes as List) }
     def eq(sel, arg) { new ComparisonNode(EQUAL, sel, [arg as String]) }
+    def 'in'(sel, ...args) { new ComparisonNode(IN, sel, args as List) }
     def out(sel, ...args) { new ComparisonNode(NOT_IN, sel, args as List) }
     def isNull(sel) { new ComparisonNode(IS_NULL, sel, []) }
     def notNull(sel) { new ComparisonNode(NOT_NULL, sel, []) }

src/test/groovy/cz/jirutka/rsql/parser/ast/RSQLOperatorsSpec.groovy

@@ -19,8 +19,8 @@ class RSQLOperatorsSpec extends Specification {
         GREATER_THAN_OR_EQUAL | new String[]{'=ge=', '>='} | 1   | 1
         LESS_THAN             | new String[]{'=lt=', '<'}  | 1   | 1
         LESS_THAN_OR_EQUAL    | new String[]{'=le=', '<='} | 1   | 1
-        IN                    | new String[]{'=in='}       | 1   | Integer.MAX_VALUE
-        NOT_IN                | new String[]{'=out='}      | 1   | Integer.MAX_VALUE
+        IN                    | new String[]{'=in='}       | 0   | Integer.MAX_VALUE
+        NOT_IN                | new String[]{'=out='}      | 0   | Integer.MAX_VALUE
         IS_NULL               | new String[]{'=null='}     | 0   | 0
         NOT_NULL              | new String[]{'=notnull='}  | 0   | 0
     }