refactor: extract logic for custom field name syntax

Author: codescape

docs/changelog.md

@@ -16,6 +16,7 @@ category: Administration
 * refactor: improve structure of subtask creation service
 * feat: ensure compatibility with Jira 10.4.0
 * refactor: use Java 16 syntax for lists
+* refactor: extract logic for custom field name syntax
 
 ### [24.11.0] - 2024-11-11
 

src/main/java/de/codescape/jira/plugins/multiplesubtasks/model/CustomFields.java

@@ -0,0 +1,33 @@
+package de.codescape.jira.plugins.multiplesubtasks.model;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Utility class to deal with custom fields.
+ */
+public class CustomFields {
+
+    // custom fields can be referenced by id: customfield_12345
+    public static final Pattern CUSTOM_FIELD_ID_PATTERN = Pattern.compile("customfield_\\d{5}");
+
+    // custom fields can be reference by name: customfield(fieldname)
+    public static final Pattern CUSTOM_FIELD_NAME_PATTERN = Pattern.compile("customfield\\((?<name>(?:\\\\\\\\|\\\\\\)|[^)])++)\\)");
+
+    /**
+     * Retrieve the name of the customfield from an expression like <code>customfield(fieldName)</code>.
+     */
+    public static String extractCustomFieldName(String customFieldString) {
+        Matcher matcher = CUSTOM_FIELD_NAME_PATTERN.matcher(customFieldString);
+        if (matcher.matches()) {
+            return matcher.group("name")
+                .replaceAll("\\\\\\)", ")")
+                .replaceAll("\\\\\\(", "(")
+                .replaceAll("\\\\:", ":")
+                .trim();
+        } else {
+            throw new SyntaxFormatException("Illegal custom field name: " + customFieldString);
+        }
+    }
+
+}

src/main/java/de/codescape/jira/plugins/multiplesubtasks/model/Subtask.java

@@ -6,8 +6,6 @@
 
 import java.util.*;
 import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
 
 /**
  * This class represents the request to create a new subtask with the given attributes.
@@ -40,12 +38,6 @@ public static class Attributes {
 
     }
 
-    // custom fields can be referenced by id: customfield_12345:
-    private static final Pattern CUSTOM_FIELD_ID_PATTERN = Pattern.compile("customfield_\\d{5}");
-
-    // custom fields can be reference by name: customfield(fieldname):
-    private static final Pattern CUSTOM_FIELD_NAME_PATTERN = Pattern.compile("customfield\\((?<name>(?:\\\\\\\\|\\\\\\)|[^)])++)\\)");
-
     private final String summary;
     private final String description;
     private final String assignee;
@@ -226,8 +218,8 @@ private String ensureValidEstimate(ArrayListMultimap<String, String> attributes)
 
     private void verifyOnlyKnownAttributes(ArrayListMultimap<String, String> attributes) {
         attributes.forEach((key, value) -> {
-            if (!Attributes.ALL.contains(key) && !CUSTOM_FIELD_ID_PATTERN.matcher(key).matches()
-                && !CUSTOM_FIELD_NAME_PATTERN.matcher(key).matches())
+            if (!Attributes.ALL.contains(key) && !CustomFields.CUSTOM_FIELD_ID_PATTERN.matcher(key).matches()
+                && !CustomFields.CUSTOM_FIELD_NAME_PATTERN.matcher(key).matches())
                 throw new SyntaxFormatException("Unknown attribute " + key + " found.");
         });
     }
@@ -261,7 +253,7 @@ private String ensureValidDueDate(ArrayListMultimap<String, String> attributes)
     private Map<String, List<String>> extractCustomFieldsById(ArrayListMultimap<String, String> attributes) {
         // get all custom field keys
         List<String> customFieldKeys = attributes.keySet().stream()
-            .filter(s -> CUSTOM_FIELD_ID_PATTERN.matcher(s).matches())
+            .filter(s -> CustomFields.CUSTOM_FIELD_ID_PATTERN.matcher(s).matches())
             .toList();
         // collect all keys and values into a map
         Map<String, List<String>> customFields = new HashMap<>();
@@ -272,25 +264,12 @@ private Map<String, List<String>> extractCustomFieldsById(ArrayListMultimap<Stri
     private Map<String, List<String>> extractCustomFieldsByName(ArrayListMultimap<String, String> attributes) {
         // get all custom field keys
         List<String> customFieldKeys = attributes.keySet().stream()
-            .filter(s -> CUSTOM_FIELD_NAME_PATTERN.matcher(s).matches())
+            .filter(s -> CustomFields.CUSTOM_FIELD_NAME_PATTERN.matcher(s).matches())
             .toList();
         // collect all keys and values into a map
         Map<String, List<String>> customFields = new HashMap<>();
-        customFieldKeys.forEach(key -> customFields.put(extractCustomFieldName(key), new ArrayList<>(attributes.get(key))));
+        customFieldKeys.forEach(key -> customFields.put(CustomFields.extractCustomFieldName(key), new ArrayList<>(attributes.get(key))));
         return customFields;
     }
 
-    private String extractCustomFieldName(String customFieldString) {
-        Matcher matcher = CUSTOM_FIELD_NAME_PATTERN.matcher(customFieldString);
-        if (matcher.matches()) {
-            return matcher.group("name")
-                .replaceAll("\\\\\\)", ")")
-                .replaceAll("\\\\\\(", "(")
-                .replaceAll("\\\\:", ":")
-                .trim();
-        } else {
-            throw new SyntaxFormatException("Illegal custom field name: " + customFieldString);
-        }
-    }
-
 }

src/test/java/de/codescape/jira/plugins/multiplesubtasks/model/CustomFieldsTest.java

@@ -0,0 +1,29 @@
+package de.codescape.jira.plugins.multiplesubtasks.model;
+
+import org.junit.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+
+public class CustomFieldsTest {
+
+    @Test
+    public void extractCustomFieldNameForSimpleStringValue() {
+        String result = CustomFields.extractCustomFieldName("customfield(Simple)");
+        assertThat(result, is(equalTo("Simple")));
+    }
+
+    @Test
+    public void extractCustomFieldNameForAlphanumericValue() {
+        String result = CustomFields.extractCustomFieldName("customfield(Test123)");
+        assertThat(result, is(equalTo("Test123")));
+    }
+
+    @Test
+    public void extractCustomFieldNameForStringWithEscapedBracketsValue() {
+        String result = CustomFields.extractCustomFieldName("customfield(Field(123\\))");
+        assertThat(result, is(equalTo("Field(123)")));
+    }
+
+}