juplo.de Git - maven-thymeleaf-skin/blob - src/main/java/de/juplo/thymeproxy/RegexPathMatcher.java

   1 package de.juplo.thymeproxy;
   2
   3
   4 import java.util.Comparator;
   5 import java.util.HashMap;
   6 import java.util.Map;
   7 import java.util.regex.Matcher;
   8 import java.util.regex.Pattern;
   9 import java.util.regex.PatternSyntaxException;
  10 import org.slf4j.Logger;
  11 import org.slf4j.LoggerFactory;
  12 import org.springframework.util.PathMatcher;
  13
  14
  15
  16 /**
  17  *
  18  * @author kai
  19  */
  20 public class RegexPathMatcher implements PathMatcher
  21 {
  22   private final static Logger LOG =
  23       LoggerFactory.getLogger(RegexPathMatcher.class);
  24
  25
  26   private int flags = 0;
  27   private Map<String, Pattern> patternCache = new HashMap<>();
  28
  29
  30   public RegexPathMatcher()
  31   {
  32   }
  33
  34   public RegexPathMatcher(int flags)
  35   {
  36     this.flags = flags;
  37   }
  38
  39
  40   protected boolean compilePattern(String string)
  41   {
  42     try
  43     {
  44       Pattern pattern = Pattern.compile(string, flags);
  45       patternCache.put(string, pattern);
  46       return true;
  47     }
  48     catch(PatternSyntaxException e)
  49     {
  50       LOG.debug("\"{}\" is no valid pattern: {}", string, e.getMessage());
  51       return false;
  52     }
  53   }
  54
  55
  56   @Override
  57   public boolean isPattern(String path)
  58   {
  59     if (path.startsWith("^") || path.endsWith("$"))
  60       return false;
  61
  62     if (patternCache.containsKey(path))
  63       return true;
  64
  65     return compilePattern(path);
  66   }
  67
  68   @Override
  69   public boolean match(String pattern, String path)
  70   {
  71     if (!patternCache.containsKey(pattern))
  72       compilePattern(pattern);
  73     Matcher matcher = patternCache.get(pattern).matcher(path);
  74     return matcher.matches();
  75   }
  76
  77   @Override
  78   public boolean matchStart(String pattern, String path)
  79   {
  80     if (!patternCache.containsKey(pattern))
  81       compilePattern(pattern);
  82     Matcher matcher = patternCache.get(pattern).matcher(path);
  83     if (!matcher.find())
  84       return false;
  85     else
  86       return matcher.start() == 0;
  87   }
  88
  89   @Override
  90   public String extractPathWithinPattern(String pattern, String path)
  91   {
  92     return "";
  93   }
  94
  95   @Override
  96   public Map<String, String> extractUriTemplateVariables(String pattern, String path)
  97   {
  98     return new HashMap<>();
  99   }
 100
 101   @Override
 102   public Comparator<String> getPatternComparator(String path)
 103   {
 104     return new Comparator<String>()
 105     {
 106       @Override
 107       public int compare(String a, String b)
 108       {
 109         return b.length() - a.length();
 110       }
 111     };
 112   }
 113
 114   @Override
 115   public String combine(String a, String b)
 116   {
 117     boolean literal = (flags & Pattern.LITERAL) == Pattern.LITERAL;
 118     String pattern = a + (literal ? "" : ".*") + b;
 119     if (!isPattern(pattern))
 120       throw new IllegalArgumentException("Cannot combine pattern " + a + " with pattern " + b);
 121     return pattern;
 122   }
 123
 124 }