Compile regular expressions only once

For performance reasons regexes should be compiled only once, because it
takes considerable time to compile them.

The simplest solution is to compile these regexes in a static context,
so that they are only compiled when the class is loaded. A further
optimisation might be to compile them lazily (only compile regexes when
they are actually needed) to prevent slow startup times.

Because regexes are mostly implementation details they are made private
unless they clearly belong to a public API (e.g. `LINEBREAK_REGEX`).

Author: ibbem

src/main/java/org/variantsync/diffdetective/datasets/predefined/MarlinCPPDiffLineFormulaExtractor.java

@@ -2,16 +2,26 @@
 
 import org.variantsync.diffdetective.feature.CPPDiffLineFormulaExtractor;
 
+import java.util.regex.Pattern;
+
 /**
  * Extracts formulas from preprocessor annotations in the marlin firmware.
  * In particular, it resolves the 'ENABLED' and 'DISABLED' macros that are used in Marlin
  * to check for features being (de-)selected.
  */
 public class MarlinCPPDiffLineFormulaExtractor extends CPPDiffLineFormulaExtractor {
+    private static Pattern ENABLED_PATTERN = Pattern.compile("ENABLED\\s*\\(([^)]*)\\)");
+    private static Pattern DISABLED_PATTERN = Pattern.compile("DISABLED\\s*\\(([^)]*)\\)");
+
     @Override
     protected String resolveFeatureMacroFunctions(String formula) {
-        return super.resolveFeatureMacroFunctions(formula)
-                .replaceAll("ENABLED\\s*\\(([^)]*)\\)", "$1")
-                .replaceAll("DISABLED\\s*\\(([^)]*)\\)", "!($1)");
+        return
+            replaceAll(ENABLED_PATTERN, "$1",
+                replaceAll(DISABLED_PATTERN, "!($1)",
+                    super.resolveFeatureMacroFunctions(formula)));
+    }
+
+    private String replaceAll(Pattern pattern, String replacement, String string) {
+        return pattern.matcher(string).replaceAll(replacement);
     }
 }

src/main/java/org/variantsync/diffdetective/diff/GitDiffer.java

@@ -53,10 +53,10 @@
  * @author Soeren Viegener, Paul Maximilian Bittner
  */
 public class GitDiffer {
-    public static final String BOM_REGEX = "\\x{FEFF}";
-    public static final String DIFF_HUNK_REGEX = "^@@\\s-(\\d+).*\\+(\\d+).*@@$";
-    public static final String DIFF_HEADER_REGEX = "^\\+\\+\\+.*$";
-    public static final String NO_NEW_LINE = "\\ No newline at end of file";
+    private static final Pattern BOM_PATTERN = Pattern.compile("\\x{FEFF}");
+    private static final Pattern DIFF_HUNK_PATTERN = Pattern.compile( "^@@\\s-(\\d+).*\\+(\\d+).*@@$");
+    private static final Pattern DIFF_HEADER_PATTERN = Pattern.compile( "^\\+\\+\\+.*$", Pattern.MULTILINE);
+    private static final String NO_NEW_LINE = "\\ No newline at end of file";
 
     private final Git git;
     private final DiffFilter diffFilter;
@@ -339,8 +339,7 @@ private static DiffResult<PatchDiff> createPatchDiff(
             final String gitDiff,
             String beforeFullFile,
             final ParseOptions parseOptions) {
-        final Pattern headerPattern = Pattern.compile(DIFF_HEADER_REGEX, Pattern.MULTILINE);
-        final Matcher matcher = headerPattern.matcher(gitDiff);
+        final Matcher matcher = DIFF_HEADER_PATTERN.matcher(gitDiff);
         final String strippedDiff;
         if (matcher.find()) {
             strippedDiff = gitDiff.substring(matcher.end() + 1);
@@ -378,16 +377,15 @@ private static DiffResult<PatchDiff> createPatchDiff(
      * @return A full git diff containing the complete file and all changes
      */
     public static String getFullDiff(String beforeFile, String gitDiff) {
-        String[] beforeLines = beforeFile.split(LINEBREAK_REGEX, -1);
-        String[] diffLines = gitDiff.split(LINEBREAK_REGEX);
+        String[] beforeLines = LINEBREAK_REGEX.split(beforeFile, -1);
+        String[] diffLines = LINEBREAK_REGEX.split(gitDiff);
 
         int beforeIndex = 0;
 
         List<String> fullDiffLines = new ArrayList<>();
 
         for (String diffLine : diffLines) {
-            Pattern diffHunkPattern = Pattern.compile(DIFF_HUNK_REGEX);
-            Matcher matcher = diffHunkPattern.matcher(diffLine);
+            Matcher matcher = DIFF_HUNK_PATTERN.matcher(diffLine);
 
             if (matcher.find()) {
                 // found diffHunkRegex
@@ -416,7 +414,7 @@ public static String getFullDiff(String beforeFile, String gitDiff) {
 
         // JGit seems to put BOMs in weird locations somewhere in the files
         // We need to remove those or the regex matching for the lines fails
-        fullDiff = fullDiff.replaceAll(BOM_REGEX, "");
+        fullDiff = BOM_PATTERN.matcher(fullDiff).replaceAll("");
 
         return fullDiff;
     }

src/main/java/org/variantsync/diffdetective/diff/difftree/DiffNode.java

@@ -738,7 +738,7 @@ public void assertSemanticConsistency() {
     }
 
     public static String toTextDiffLine(final DiffType diffType, final String text) {
-        return diffType.symbol + text.replaceAll(StringUtils.LINEBREAK_REGEX, StringUtils.LINEBREAK + diffType.symbol);
+        return diffType.symbol + StringUtils.LINEBREAK_REGEX.matcher(text).replaceAll(StringUtils.LINEBREAK + diffType.symbol);
     }
 
     public String toTextDiffLine() {

src/main/java/org/variantsync/diffdetective/diff/difftree/parse/DiffTreeParser.java

@@ -26,8 +26,6 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.BiConsumer;
 
-import static org.variantsync.diffdetective.util.StringUtils.LINEBREAK_REGEX;
-
 public class DiffTreeParser {
     /**
      * Implementation of the diff tree algorithm.

src/main/java/org/variantsync/diffdetective/feature/CPPDiffLineFormulaExtractor.java

@@ -14,8 +14,10 @@
  */
 public class CPPDiffLineFormulaExtractor {
     // ^[+-]?\s*#\s*(if|ifdef|ifndef|elif)(\s+(.*)|\((.*)\))$
-    public static final String CPP_ANNOTATION_REGEX = "^[+-]?\\s*#\\s*(if|ifdef|ifndef|elif)(\\s+(.*)|\\((.*)\\))$";
-    public static final Pattern CPP_ANNOTATION_REGEX_PATTERN = Pattern.compile(CPP_ANNOTATION_REGEX);
+    private static final String CPP_ANNOTATION_REGEX = "^[+-]?\\s*#\\s*(if|ifdef|ifndef|elif)(\\s+(.*)|\\((.*)\\))$";
+    private static final Pattern CPP_ANNOTATION_REGEX_PATTERN = Pattern.compile(CPP_ANNOTATION_REGEX);
+    private static final Pattern COMMENT_PATTERN = Pattern.compile("/\\*.*\\*/");
+    private static final Pattern DEFINED_PATTERN = Pattern.compile("defined\\(([^)]*)\\)");
 
     protected String resolveFeatureMacroFunctions(String formula) {
         return formula;
@@ -27,7 +29,7 @@ protected String resolveFeatureMacroFunctions(String formula) {
      * @return The feature mapping as a String of the given line
      */
     public String extractFormula(final String line) throws IllFormedAnnotationException {
-        // TODO: There are so many regexes here in replaceAll that could be optimized by precompiling the regexes once.
+        // TODO: There still regexes here in replaceAll that could be optimized by precompiling the regexes once.
         final Matcher matcher = CPP_ANNOTATION_REGEX_PATTERN.matcher(line);
 
         String fm;
@@ -43,14 +45,14 @@ public String extractFormula(final String line) throws IllFormedAnnotationExcept
 
         // remove comments
         fm = fm.split("//")[0];
-        fm = fm.replaceAll("/\\*.*\\*/", "");
+        fm = COMMENT_PATTERN.matcher(fm).replaceAll("");
 
         // remove whitespace
         fm = fm.trim();
         fm = fm.replaceAll("\\s", "");
 
         // remove defined()
-        fm = fm.replaceAll("defined\\(([^)]*)\\)", "$1");
+        fm = DEFINED_PATTERN.matcher(fm).replaceAll("$1");
         fm = fm.replaceAll("defined ", " ");
         fm = resolveFeatureMacroFunctions(fm);
 

src/main/java/org/variantsync/diffdetective/util/StringUtils.java

@@ -1,10 +1,11 @@
 package org.variantsync.diffdetective.util;
 
 import java.util.Collection;
+import java.util.regex.Pattern;
 
 public class StringUtils {
     public final static String LINEBREAK = "\r\n";
-    public final static String LINEBREAK_REGEX = "\\r\\n|\\r|\\n";
+    public final static Pattern LINEBREAK_REGEX = Pattern.compile("\\r\\n|\\r|\\n");
 
 
     public static void clear(final StringBuilder builder) {