Issue #50: Register the Header in recipe registry

Author: Anmol202005

config/checkstyle.properties

@@ -5,3 +5,4 @@ checkstyle.regexp.header.file=config/regexp-header.txt
 checkstyle.importcontrol.file=config/import-control.xml
 checkstyle.importcontroltest.file=config/import-control-test.xml
 checkstyle.java.version=17
+checkstyle.cache.file=.cache/checkstyle-cachefile

src/main/java/org/checkstyle/autofix/CheckstyleAutoFix.java

@@ -74,8 +74,9 @@ public String getPropertiesPath() {
     public List<Recipe> getRecipeList() {
         final List<CheckstyleViolation> violations = CheckstyleReportParser
                 .parse(Path.of(getViolationReportPath()));
+        final CheckConfiguration configuration = loadCheckstyleConfiguration();
 
-        return CheckstyleRecipeRegistry.getRecipes(violations);
+        return CheckstyleRecipeRegistry.getRecipes(violations, configuration);
     }
 
     private CheckConfiguration loadCheckstyleConfiguration() {

src/main/java/org/checkstyle/autofix/CheckstyleRecipeRegistry.java

@@ -17,24 +17,33 @@
 
 package org.checkstyle.autofix;
 
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import org.checkstyle.autofix.parser.CheckConfiguration;
 import org.checkstyle.autofix.parser.CheckstyleViolation;
+import org.checkstyle.autofix.recipe.Header;
 import org.checkstyle.autofix.recipe.UpperEll;
 import org.openrewrite.Recipe;
 
 public final class CheckstyleRecipeRegistry {
 
     private static final Map<String, Function<List<CheckstyleViolation>, Recipe>> RECIPE_MAP =
             new HashMap<>();
+    private static final Map<String, BiFunction<List<CheckstyleViolation>, CheckConfiguration,
+                    Recipe>> RECIPE_MAP_WITH_CONFIG =
+            new HashMap<>();
 
     static {
-        RECIPE_MAP.put("UpperEllCheck", UpperEll::new);
+        RECIPE_MAP.put("UPPERELL", UpperEll::new);
+        RECIPE_MAP_WITH_CONFIG.put("HEADER", Header::new);
     }
 
     private CheckstyleRecipeRegistry() {
@@ -47,28 +56,49 @@ private CheckstyleRecipeRegistry() {
      * using the simple name of the check, and applies the factory to generate Recipe instances.
      *
      * @param violations the list of Checkstyle violations
+     * @param config the checkstyle configuration
      * @return a list of generated Recipe objects
      */
-    public static List<Recipe> getRecipes(List<CheckstyleViolation> violations) {
+    public static List<Recipe> getRecipes(List<CheckstyleViolation> violations,
+                                          CheckConfiguration config) {
+        return violations.stream()
+                .collect(Collectors.groupingBy(CheckstyleViolation::getSource))
+                .entrySet()
+                .stream()
+                .map(entry -> createRecipe(entry, config))
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+    }
+
+    private static Recipe createRecipe(Map.Entry<String, List<CheckstyleViolation>> entry,
+                                       CheckConfiguration config) {
 
-        final Map<String, List<CheckstyleViolation>> violationsByCheck = violations.stream()
-                .collect(Collectors.groupingBy(CheckstyleViolation::getSource));
+        final String simpleCheckName = normalizeCheckName(entry.getKey());
+        final List<CheckstyleViolation> violations = entry.getValue();
 
-        final List<Recipe> recipes = new ArrayList<>();
+        return Optional.ofNullable(RECIPE_MAP_WITH_CONFIG.get(simpleCheckName))
+                .map(factory -> {
+                    return factory.apply(violations,
+                            extractCheckConfiguration(config, simpleCheckName));
+                }).orElseGet(() -> {
+                    return Optional.ofNullable(RECIPE_MAP.get(simpleCheckName))
+                            .map(factory -> factory.apply(violations))
+                            .orElse(null);
+                });
+    }
 
-        for (Map.Entry<String, List<CheckstyleViolation>> entry : violationsByCheck.entrySet()) {
-            final String checkName = entry.getKey();
-            final String simpleCheckName = checkName
-                    .substring(checkName.lastIndexOf('.') + 1);
-            final List<CheckstyleViolation> checkViolations = entry.getValue();
+    private static CheckConfiguration extractCheckConfiguration(CheckConfiguration config,
+                                                                String checkName) {
+        return config.getChildConfig(checkName);
+    }
 
-            final Function<List<CheckstyleViolation>, Recipe> recipeFactory =
-                    RECIPE_MAP.get(simpleCheckName);
-            if (recipeFactory != null) {
-                recipes.add(recipeFactory.apply(checkViolations));
-            }
+    private static String normalizeCheckName(String checkName) {
+        String normalizedCheckName = checkName.substring(checkName.lastIndexOf('.') + 1);
+        final int checkLength = 5;
+        if (normalizedCheckName.toLowerCase().endsWith("check")) {
+            normalizedCheckName = normalizedCheckName
+                    .substring(0, normalizedCheckName.length() - checkLength);
         }
-
-        return recipes;
+        return normalizedCheckName.toUpperCase(Locale.ROOT);
     }
 }

src/main/java/org/checkstyle/autofix/parser/CheckConfiguration.java

@@ -45,6 +45,10 @@ private CheckConfiguration getParent() {
         return parent;
     }
 
+    private List<CheckConfiguration> getChildren() {
+        return children;
+    }
+
     public String getProperty(String key) {
         String value = null;
 
@@ -95,12 +99,19 @@ public int[] getIntArray(String propertyName) {
     }
 
     public CheckConfiguration getChildConfig(String childName) {
+        final List<CheckConfiguration> childrenList = getChildren();
         CheckConfiguration result = null;
-        for (CheckConfiguration child : children) {
-            if (childName.equals(child.getName())) {
-                result = child;
+
+        int index = 0;
+        while (index < childrenList.size()) {
+            final CheckConfiguration current = childrenList.get(index);
+
+            if (childName.equals(current.getName())) {
+                result = current;
                 break;
             }
+            childrenList.addAll(current.getChildren());
+            index++;
         }
         return result;
     }

src/main/java/org/checkstyle/autofix/parser/ConfigurationLoader.java

@@ -21,6 +21,7 @@
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Properties;
 
@@ -56,7 +57,8 @@ public static CheckConfiguration mapConfiguration(Configuration config) {
             simpleChildren[index] = mapConfiguration(checkstyleChildren[index]);
         }
 
-        return new CheckConfiguration(config.getName(), properties, List.of(simpleChildren));
+        return new CheckConfiguration(config.getName().toUpperCase(Locale.ROOT),
+                properties, List.of(simpleChildren));
     }
 
     public static CheckConfiguration loadConfiguration(String checkstyleConfigurationPath,