Merge "Adding support for case option in localPart."

2 files changed, 228 insertions, 16 deletions

diff --git a/gerrit-common/src/main/java/com/google/gerrit/common/data/ParameterizedString.java b/gerrit-common/src/main/java/com/google/gerrit/common/data/ParameterizedString.java
index f9b0dade8b..68676cf9b5 100644
--- a/gerrit-common/src/main/java/com/google/gerrit/common/data/ParameterizedString.java
+++ b/gerrit-common/src/main/java/com/google/gerrit/common/data/ParameterizedString.java
@@ -63,20 +63,27 @@ public class ParameterizedString {
       ops.add(new Constant(pattern.substring(i, b)));
 
       String expr = pattern.substring(b + 2, e);
-      Function function;
-      int lastDot = expr.lastIndexOf('.');
-      if (lastDot < 0) {
-        function = NOOP;
+      String parameterName = "";
+      List<Function> functions = new ArrayList<Function>();
+      if (!expr.contains(".")) {
+        parameterName = expr;
       } else {
-        function = FUNCTIONS.get(expr.substring(lastDot + 1));
-        if (function == null) {
-          function = NOOP;
-        } else {
-          expr = expr.substring(0, lastDot);
+        int firstDot = expr.indexOf('.');
+        parameterName = expr.substring(0, firstDot);
+        String actionsStr = expr.substring(firstDot + 1);
+        String[] actions = actionsStr.split("\\.");
+
+        for (String action : actions) {
+          Function function = FUNCTIONS.get(action);
+          if (function == null) {
+            function = NOOP;
+          }
+          functions.add(function);
         }
       }
 
-      final Parameter p = new Parameter(expr, function);
+      final Parameter p =
+          new Parameter(parameterName, Collections.unmodifiableList(functions));
       raw.append("{" + prs.size() + "}");
       prs.add(p);
       ops.add(p);
@@ -175,11 +182,11 @@ public class ParameterizedString {
 
   private static class Parameter extends Format {
     private final String name;
-    private final Function function;
+    private final List<Function> functions;
 
-    Parameter(final String name, final Function function) {
+    Parameter(final String name, final List<Function> functions) {
       this.name = name;
-      this.function = function;
+      this.functions = functions;
     }
 
     @Override
@@ -188,7 +195,10 @@ public class ParameterizedString {
       if (v == null) {
         v = "";
       }
-      b.append(function.apply(v));
+      for (Function function : functions) {
+        v = function.apply(v);
+      }
+      b.append(v);
     }
   }
 
diff --git a/gerrit-common/src/test/java/com/google/gerrit/common/data/ParameterizedStringTest.java b/gerrit-common/src/test/java/com/google/gerrit/common/data/ParameterizedStringTest.java
index 4fe3365dcb..a2d127912a 100644
--- a/gerrit-common/src/test/java/com/google/gerrit/common/data/ParameterizedStringTest.java
+++ b/gerrit-common/src/test/java/com/google/gerrit/common/data/ParameterizedStringTest.java
@@ -165,8 +165,210 @@ public class ParameterizedStringTest extends TestCase {
   }
 
   public void testUndefinedFunctionName() {
-    ParameterizedString p = new ParameterizedString("${a.anUndefinedMethod}");
+    ParameterizedString p =
+        new ParameterizedString(
+            "hi, ${userName.toUpperCase},your eamil address is '${email.toLowerCase.localPart}'.right?");
+    assertEquals(2, p.getParameterNames().size());
+    assertTrue(p.getParameterNames().contains("userName"));
+    assertTrue(p.getParameterNames().contains("email"));
+
+    final Map<String, String> a = new HashMap<String, String>();
+    a.put("userName", "firstName lastName");
+    a.put("email", "FIRSTNAME.LASTNAME@EXAMPLE.COM");
+    assertNotNull(p.bind(a));
+    assertEquals(2, p.bind(a).length);
+
+    assertEquals("FIRSTNAME LASTNAME", p.bind(a)[0]);
+    assertEquals("firstname.lastname", p.bind(a)[1]);
+    assertEquals("hi, FIRSTNAME LASTNAME,your eamil address is 'firstname.lastname'.right?", p.replace(a));
+  }
+
+  public void testReplaceToUpperCaseToLowerCase() {
+    final ParameterizedString p =
+        new ParameterizedString("${a.toUpperCase.toLowerCase}");
+    assertEquals(1, p.getParameterNames().size());
+    assertTrue(p.getParameterNames().contains("a"));
+
+    final Map<String, String> a = new HashMap<String, String>();
+
+    a.put("a", "FOO@EXAMPLE.COM");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("foo@example.com", p.bind(a)[0]);
+    assertEquals("foo@example.com", p.replace(a));
+
+    a.put("a", "foo@example.com");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("foo@example.com", p.bind(a)[0]);
+    assertEquals("foo@example.com", p.replace(a));
+  }
+
+  public void testReplaceToUpperCaseLocalName() {
+    final ParameterizedString p =
+        new ParameterizedString("${a.toUpperCase.localPart}");
+    assertEquals(1, p.getParameterNames().size());
+    assertTrue(p.getParameterNames().contains("a"));
+
+    final Map<String, String> a = new HashMap<String, String>();
+
+    a.put("a", "foo@example.com");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("FOO", p.bind(a)[0]);
+    assertEquals("FOO", p.replace(a));
+
+    a.put("a", "FOO@EXAMPLE.COM");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("FOO", p.bind(a)[0]);
+    assertEquals("FOO", p.replace(a));
+  }
+
+  public void testReplaceToUpperCaseAnUndefinedMethod() {
+    final ParameterizedString p =
+        new ParameterizedString("${a.toUpperCase.anUndefinedMethod}");
+    assertEquals(1, p.getParameterNames().size());
+    assertTrue(p.getParameterNames().contains("a"));
+
+    final Map<String, String> a = new HashMap<String, String>();
+
+    a.put("a", "foo@example.com");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("FOO@EXAMPLE.COM", p.bind(a)[0]);
+    assertEquals("FOO@EXAMPLE.COM", p.replace(a));
+
+    a.put("a", "FOO@EXAMPLE.COM");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("FOO@EXAMPLE.COM", p.bind(a)[0]);
+    assertEquals("FOO@EXAMPLE.COM", p.replace(a));
+  }
+
+  public void testReplaceLocalNameToUpperCase() {
+    final ParameterizedString p =
+        new ParameterizedString("${a.localPart.toUpperCase}");
+    assertEquals(1, p.getParameterNames().size());
+    assertTrue(p.getParameterNames().contains("a"));
+
+    final Map<String, String> a = new HashMap<String, String>();
+
+    a.put("a", "foo@example.com");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("FOO", p.bind(a)[0]);
+    assertEquals("FOO", p.replace(a));
+
+    a.put("a", "FOO@EXAMPLE.COM");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("FOO", p.bind(a)[0]);
+    assertEquals("FOO", p.replace(a));
+  }
+
+  public void testReplaceLocalNameToLowerCase() {
+    final ParameterizedString p =
+        new ParameterizedString("${a.localPart.toLowerCase}");
+    assertEquals(1, p.getParameterNames().size());
+    assertTrue(p.getParameterNames().contains("a"));
+
+    final Map<String, String> a = new HashMap<String, String>();
+
+    a.put("a", "FOO@EXAMPLE.COM");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("foo", p.bind(a)[0]);
+    assertEquals("foo", p.replace(a));
+
+    a.put("a", "foo@example.com");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("foo", p.bind(a)[0]);
+    assertEquals("foo", p.replace(a));
+  }
+
+  public void testReplaceLocalNameAnUndefinedMethod() {
+    final ParameterizedString p =
+        new ParameterizedString("${a.localPart.anUndefinedMethod}");
+    assertEquals(1, p.getParameterNames().size());
+    assertTrue(p.getParameterNames().contains("a"));
+
+    final Map<String, String> a = new HashMap<String, String>();
+
+    a.put("a", "FOO@EXAMPLE.COM");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("FOO", p.bind(a)[0]);
+    assertEquals("FOO", p.replace(a));
+
+    a.put("a", "foo@example.com");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("foo", p.bind(a)[0]);
+    assertEquals("foo", p.replace(a));
+  }
+
+  public void testReplaceToLowerCaseToUpperCase() {
+    final ParameterizedString p =
+        new ParameterizedString("${a.toLowerCase.toUpperCase}");
+    assertEquals(1, p.getParameterNames().size());
+    assertTrue(p.getParameterNames().contains("a"));
+
+    final Map<String, String> a = new HashMap<String, String>();
+
+    a.put("a", "FOO@EXAMPLE.COM");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("FOO@EXAMPLE.COM", p.bind(a)[0]);
+    assertEquals("FOO@EXAMPLE.COM", p.replace(a));
+
+    a.put("a", "foo@example.com");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("FOO@EXAMPLE.COM", p.bind(a)[0]);
+    assertEquals("FOO@EXAMPLE.COM", p.replace(a));
+  }
+
+  public void testReplaceToLowerCaseLocalName() {
+    final ParameterizedString p =
+        new ParameterizedString("${a.toLowerCase.localPart}");
     assertEquals(1, p.getParameterNames().size());
-    assertTrue(p.getParameterNames().contains("a.anUndefinedMethod"));
+    assertTrue(p.getParameterNames().contains("a"));
+
+    final Map<String, String> a = new HashMap<String, String>();
+
+    a.put("a", "FOO@EXAMPLE.COM");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("foo", p.bind(a)[0]);
+    assertEquals("foo", p.replace(a));
+
+    a.put("a", "foo@example.com");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("foo", p.bind(a)[0]);
+    assertEquals("foo", p.replace(a));
+  }
+
+  public void testReplaceToLowerCaseAnUndefinedMethod() {
+    final ParameterizedString p =
+        new ParameterizedString("${a.toLowerCase.anUndefinedMethod}");
+    assertEquals(1, p.getParameterNames().size());
+    assertTrue(p.getParameterNames().contains("a"));
+
+    final Map<String, String> a = new HashMap<String, String>();
+
+    a.put("a", "foo@example.com");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("foo@example.com", p.bind(a)[0]);
+    assertEquals("foo@example.com", p.replace(a));
+
+    a.put("a", "FOO@EXAMPLE.COM");
+    assertNotNull(p.bind(a));
+    assertEquals(1, p.bind(a).length);
+    assertEquals("foo@example.com", p.bind(a)[0]);
+    assertEquals("foo@example.com", p.replace(a));
   }
 }