Re: Parser for a simple expression

Ivo wrote:


If strict validation of your expressions is not required (what I think
is your situation), then the above seems not to be very difficult to
implement without any third-party tools. See the code below (not tested
intensively!).

Regardless of what expression parsing/compiling/processing technique
you'll choose, there is also presented the way I think you could use it
in your code (in this scenario your granted Authorities must simply
implement RoleSet interface).

HTH,
piotr

import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

public class Roles {

   public interface RoleSet {
     boolean contains(String role);
   }

   public interface CompiledExpression {
     boolean matches(RoleSet roles);
   }

   public static CompiledExpression compile(String expression) {
     return new Compiler(new Tokenizer(expression)).compile();
   }

   static class Tokenizer {
     StringTokenizer st;

     Tokenizer(String expression) {
       st = new StringTokenizer(expression, " ()", true);
     }

     String nextToken() {
       while (st.hasMoreTokens()) {
         String token = st.nextToken().trim();
         if (token.length() > 0) {
           return token;
         }
       }
       return null;
     }
   }

   static class Compiler {
     Tokenizer tokenizer;

     public Compiler(Tokenizer tokenizer) {
       this.tokenizer = tokenizer;
     }

     public CompiledExpression compile() {
       return compile(compile(null));
     }

     CompiledExpression compile(final CompiledExpression left) {
       final String token = tokenizer.nextToken();
       if(token == null) {
         return left;
       }

       abstract class NextExpression implements CompiledExpression {
         CompiledExpression right;
         NextExpression(CompiledExpression right) {
           this.right = right;
         }
       }

       if(token.equalsIgnoreCase("not")) {
         return compile(new NextExpression(compile(null)) {

           public boolean matches(RoleSet roles) {
             return ! right.matches(roles);
           }
         });
       }
       if(token.equalsIgnoreCase("or")) {
         return new NextExpression(compile(compile(null))) {

           public boolean matches(RoleSet roles) {
             return left.matches(roles) || right.matches(roles);
           }
         };
       }
       if(token.equalsIgnoreCase("and")) {
         return compile(new NextExpression(compile(null)) {

           public boolean matches(RoleSet roles) {
             return left.matches(roles) && right.matches(roles);
           }
         });
       }
       if(token.equals("(")) {
         return compile(new NextExpression(compile(null)) {

           public boolean matches(RoleSet roles) {
             return right.matches(roles);
           }
         });
       }
       if(token.equals(")")) {
         return left;
       }

       return new CompiledExpression() {

         public boolean matches(RoleSet roles) {
           return roles.contains(token);
         }
       };
     }
   }

   public static void main(String[] args) throws Exception {
     final String expression = "a or b and not c";
     final Roles.CompiledExpression ce = Roles.compile(expression);
     System.out.println("expression: " + expression);

     new RoleSet() {
       Set<String> roles = new HashSet<String>();

       public boolean contains(String role) {
         boolean enabled = roles.contains(role);
         System.out.println(
             "role " + role + " " + (enabled ? "set" : "not set"));
         return enabled;
       }

       void check() {
         System.out.println(roles + " " +
             (ce.matches(this) ? "matches" : "don't match"));
       }

       { // test...
         check();

         roles.add("b");
         check();

         roles.add("c");
         check();

         roles.add("a");
         check();
       }
     };
   }
}