- Revert cleaning trailing white spaces from markdown file

- Make the changes backward compatible with custom filters
- Iterate over nested callbacks in path items

Author: limentas

docs/customization.md

@@ -75,7 +75,7 @@ Excluding `SupportingFiles`, each of the above options may result in multiple fi
 Note that user-defined templates will merge with built-in template definitions. If a supporting file with the sample template file path exists, it will be replaced with the user-defined template, otherwise the user-defined template will be added to the list of template files to compile. If the generator's built-in template is `model_docs.mustache` and you define `model-docs.mustache`, this will result in duplicated model docs (if `destinationFilename` differs) or undefined behavior as whichever template compiles last will overwrite the previous model docs (if `destinationFilename` matches the extension or suffix in the generator's code).
 
 ## Custom Generator (and Template)
-
+ 
 <a id="creating-a-new-template"></a> If none of the built-in generators suit your needs and you need to do more than just modify the mustache templates to tweak generated code, you can create a brand new generator and its associated templates. OpenAPI Generator can help with this, using the `meta` command:
 
 ```sh
@@ -95,7 +95,7 @@ To compile your library, enter the `out/generators/my-codegen` directory, run `m
 
 **NOTE** Running your custom generator requires adding it to the classpath. This differs on [Windows](https://docs.oracle.com/javase/8/docs/technotes/tools/windows/classpath.html) slightly from [unix](https://docs.oracle.com/javase/8/docs/technotes/tools/unix/classpath.html).
 If you are running a Windows Subsystem for Linux or a shell such as gitbash, and have issues with the unix variant, try the Windows syntax below.
-
+ 
 Now, execute the generator:
 
 ```sh
@@ -536,7 +536,7 @@ Another useful option is `inlineSchemaOptions`, which allows you to customize ho
 
 OpenAPI Normalizer transforms the input OpenAPI doc/spec (which may not perfectly conform to the specification) to make it workable with OpenAPI Generator. A few rules are switched on by default since 7.0.0 release:
 
-- SIMPLIFY_ONEOF_ANYOF
+- SIMPLIFY_ONEOF_ANYOF 
 - SIMPLIFY_BOOLEAN_ENUM
 - SIMPLIFY_ONEOF_ANYOF_ENUM
 - REFACTOR_ALLOF_WITH_PROPERTIES_ONLY
@@ -637,7 +637,7 @@ Example:
 java -jar modules/openapi-generator-cli/target/openapi-generator-cli.jar generate -g java -i modules/openapi-generator/src/test/resources/3_0/enableKeepOnlyFirstTagInOperation_test.yaml -o /tmp/java-okhttp/ --openapi-normalizer REMOVE_X_INTERNAL=true
 ```
 
-- `NORMALIZER_CLASS`: Set to full classname of a class extending the default org.openapitools.codegen.OpenAPINormalizer. It allows customization of the default normalizer.
+- `NORMALIZER_CLASS`: Set to full classname of a class extending the default org.openapitools.codegen.OpenAPINormalizer. It allows customization of the default normalizer. 
 
 Example:
 ```
@@ -687,16 +687,16 @@ The `FILTER` parameter allows selective inclusion of API operations based on spe
 
 ### Available Filters
 
-- **`operationId`**
+- **`operationId`**  
   When set to `operationId:addPet|getPetById`, operations **not** matching `addPet` or `getPetById` will be marked as internal (`x-internal: true`), and excluded from generation. Matching operations will have `x-internal: false`.
 
-- **`method`**
+- **`method`**  
   When set to `method:get|post`, operations **not** using `GET` or `POST` methods will be marked as internal (`x-internal: true`), preventing their generation.
 
-- **`tag`**
+- **`tag`**  
   When set to `tag:person|basic`, operations **not** tagged with `person` or `basic` will be marked as internal (`x-internal: true`), and will not be generated.
 
-- **`path`**
+- **`path`**  
   When set to `path:/v1|/v2`, operations on paths **not** starting with `/v1` or with `/v2` will be marked as internal (`x-internal: true`), and will not be generated.
 
 ### Example Usage

modules/openapi-generator/src/main/java/org/openapitools/codegen/OpenAPINormalizer.java

@@ -349,10 +349,10 @@ public void processRules(Map<String, String> inputRules) {
      * @param openApi Contract used in the filtering (could be used for customization).
      * @param input full input value
      *
-     * @return an OperationsFilter containing the parsed filters.
+     * @return an Filter containing the parsed filters.
      */
-    protected OperationsFilter createOperationsFilter(OpenAPI openApi, String input) {
-        return new OperationsFilter(input);
+    protected Filter createFilter(OpenAPI openApi, String input) {
+        return new Filter(input);
     }
 
     /**
@@ -415,10 +415,10 @@ protected void normalizePaths() {
             return;
         }
 
-        OperationsFilter filter = null;
+        Filter filter = null;
         if (Boolean.TRUE.equals(getRule(FILTER))) {
             String filters = inputRules.get(FILTER);
-            filter = createOperationsFilter(this.openAPI, filters);
+            filter = createFilter(this.openAPI, filters);
             if (!filter.parse()) {
                 filter = null;
             }
@@ -702,7 +702,7 @@ private void cleanupSecuritySchemeReferences(Iterable<String> schemesToClean) {
             }
         }
 
-        // Callbacks
+        // Callbacks from Components
         if (openAPI.getComponents() != null && openAPI.getComponents().getCallbacks() != null) {
             Map<String, Callback> callbacks = openAPI.getComponents().getCallbacks();
             for (Callback callback : callbacks.values()) {
@@ -714,20 +714,42 @@ private void cleanupSecuritySchemeReferences(Iterable<String> schemesToClean) {
                 }
             }
         }
+
+        // Path items from Components
+        if (openAPI.getComponents() != null && openAPI.getComponents().getPathItems() != null) {
+            Map<String, PathItem> pathItems = openAPI.getComponents().getPathItems();
+            for (PathItem path : pathItems.values()) {
+                cleanupPathItemSecuritySchemes(path, schemesToClean);
+            }
+        }
     }
 
     /**
-     * Cleans up the references to the security schemes that are removed by the filter in a given PathItem.
-     * @param path the PathItem to clean up
+     * Cleans up the references to the security schemes that are removed by the
+     * filter in a given PathItem.
+     *
+     * @param path           the PathItem to clean up
      * @param schemesToClean the security schemes keys to remove
      */
     private void cleanupPathItemSecuritySchemes(PathItem path, Iterable<String> schemesToClean) {
         if (path == null || schemesToClean == null) {
             return;
         }
 
-        List<Operation> operations = new ArrayList<>(path.readOperations());
-        for (Operation operation : operations) {
+        List<Operation> operations = new LinkedList<>(path.readOperations());
+        // An infinite loop is impossible here because it is impossible without using
+        // references from components and we clean up components separately
+        while (!operations.isEmpty()) {
+            Operation operation = operations.remove(0);
+            Map<String, Callback> callbacks = operation.getCallbacks();
+            if (callbacks != null) {
+                for (Callback callback : callbacks.values()) {
+                    for (PathItem callbackPath : callback.values()) {
+                        operations.addAll(callbackPath.readOperations());
+                    }
+                }
+            }
+
             if (operation.getSecurity() == null) {
                 continue;
             }
@@ -2453,13 +2475,19 @@ protected Logger getLogger() {
         }
     }
 
-    protected static class OperationsFilter extends BaseFilter {
+    // Filter for API operations
+    protected static class Filter extends BaseFilter {
         public static final String OPERATION_ID = "operationId";
         public static final String METHOD = "method";
         public static final String TAG = "tag";
         public static final String PATH = "path";
+        // Keep next four fields for backward compatibility of custom made filters. New filters should use filteringMethodsMap directly.
+        protected Set<String> operationIdFilters = Collections.emptySet();
+        protected Set<String> methodFilters = Collections.emptySet();
+        protected Set<String> tagFilters = Collections.emptySet();
+        protected Set<String> pathStartingWithFilters = Collections.emptySet();
 
-        protected OperationsFilter(String filters) {
+        protected Filter(String filters) {
             super(filters);
         }
 
@@ -2472,14 +2500,37 @@ public Set<String> filteringMethods() {
         public String usageMessage() {
             return String.format(Locale.ROOT,
                         "FILTER rule must be in the form of `%s:name1|name2|name3` or `%s:get|post|put` or `%s:tag1|tag2|tag3` or `%s:/v1|/v2`.",
-                        OperationsFilter.OPERATION_ID, OperationsFilter.METHOD, OperationsFilter.TAG, OperationsFilter.PATH);
+                        Filter.OPERATION_ID, Filter.METHOD, Filter.TAG, Filter.PATH);
         }
 
         @Override
         protected void logMatch(String filterName, String subjectId) {
             getLogger().info("Operation `{}` matches the {} filter and remains", subjectId, filterName);
         }
 
+        // Having that just to fill the fields for backward compatibility of custom made filters
+        @Override
+        public boolean parse() {
+            boolean result = super.parse();
+            operationIdFilters = filteringMethodsMap.getOrDefault(OPERATION_ID, Collections.emptySet());
+            methodFilters = filteringMethodsMap.getOrDefault(METHOD, Collections.emptySet());
+            tagFilters = filteringMethodsMap.getOrDefault(TAG, Collections.emptySet());
+            pathStartingWithFilters = filteringMethodsMap.getOrDefault(PATH, Collections.emptySet());
+            return result;
+        }
+
+        // Keep next two methods for backward compatibility of custom made filters.
+        protected boolean logIfMatch(String filterName, Operation operation, boolean filterMatched) {
+            if (filterMatched) {
+                logMatch(filterName, operation);
+            }
+            return filterMatched;
+        }
+
+        protected void logMatch(String filterName, Operation operation) {
+            getLogger().info("operation `{}` marked as internal only (x-internal: true) by the {} FILTER", operation.getOperationId(), filterName);
+        }
+
         /**
          * Test if the OpenAPI contract match an extra filter.
          *