commit 480d09eec993ff05a8df516269c59afa352763d7 Author: Zhongwei Li Date: Sun Nov 30 08:45:33 2025 +0800 Initial commit diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json new file mode 100644 index 0000000..5dd2268 --- /dev/null +++ b/.claude-plugin/plugin.json @@ -0,0 +1,15 @@ +{ + "name": "openrewrite-recipe", + "description": "Expert guidance for writing OpenRewrite recipes - automated refactoring operations for source code. Includes templates, examples, and comprehensive best practices.", + "version": "1.0.0", + "author": { + "name": "Moderne, Inc.", + "url": "https://github.com/openrewrite" + }, + "skills": [ + "./skills/writing-openrewrite-recipes" + ], + "commands": [ + "./commands/create-recipe.md" + ] +} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..b046ca3 --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# openrewrite-recipe + +Expert guidance for writing OpenRewrite recipes - automated refactoring operations for source code. Includes templates, examples, and comprehensive best practices. diff --git a/commands/create-recipe.md b/commands/create-recipe.md new file mode 100644 index 0000000..257f0ee --- /dev/null +++ b/commands/create-recipe.md @@ -0,0 +1,7 @@ +--- +name: create-recipe +description: Create an OpenRewrite recipe for a specific problem +args: Problem description +--- + +Use the writing-openrewrite-recipes skill to create a recipe for: {{args}} diff --git a/plugin.lock.json b/plugin.lock.json new file mode 100644 index 0000000..47f23dc --- /dev/null +++ b/plugin.lock.json @@ -0,0 +1,137 @@ +{ + "$schema": "internal://schemas/plugin.lock.v1.json", + "pluginId": "gh:openrewrite/rewrite-docs:openrewrite-recipe-writer", + "normalized": { + "repo": null, + "ref": "refs/tags/v20251128.0", + "commit": "97f83cd2197f9345566220cb3c613a4eb5386558", + "treeHash": "049fc4cdd92369bce2da02fd52742233dd73d5cedbe66ac17a777f45a869e4bb", + "generatedAt": "2025-11-28T10:27:27.303609Z", + "toolVersion": "publish_plugins.py@0.2.0" + }, + "origin": { + "remote": "git@github.com:zhongweili/42plugin-data.git", + "branch": "master", + "commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390", + "repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data" + }, + "manifest": { + "name": "openrewrite-recipe", + "description": "Expert guidance for writing OpenRewrite recipes - automated refactoring operations for source code. Includes templates, examples, and comprehensive best practices.", + "version": "1.0.0" + }, + "content": { + "files": [ + { + "path": "README.md", + "sha256": "36bd9aab221816b97156d93d47dbfce43f6bfb154d371809278459928970a2d9" + }, + { + "path": ".claude-plugin/plugin.json", + "sha256": "9026c3316790657e578487f7dea78c3a8d1747cbe7df1e88719e2967255a0493" + }, + { + "path": "commands/create-recipe.md", + "sha256": "df47437b157326d517df39b0f516dffbe8463b6f2371063e32c32ce7b7753d83" + }, + { + "path": "skills/writing-openrewrite-recipes/SKILL.md", + "sha256": "328234d8905fdc27cf6d9567db04635b74ac395a36b170d42fd4bf9773667e98" + }, + { + "path": "skills/writing-openrewrite-recipes/references/example-say-hello-recipe.java", + "sha256": "12b384c30934e1ff2d874cc6f65a10d0cbd699453cb079ebc379ec9d7949f120" + }, + { + "path": "skills/writing-openrewrite-recipes/references/recipes-all.csv", + "sha256": "5e08c9b8456f4b71bfdada2bad28b5f968a2849903f522ddfd57e5922c1ab30e" + }, + { + "path": "skills/writing-openrewrite-recipes/references/checklist-recipe-development.md", + "sha256": "8750d9a048a22fd7c0da51d9f8e5eabeecab9c84b17ee4ba139ebac21f64dfd2" + }, + { + "path": "skills/writing-openrewrite-recipes/references/recipes-xml-yaml-json-common.csv", + "sha256": "bf5097aec80a573b23bbdb5943cc23d4b784b27429a9c8057a15c3a62949153b" + }, + { + "path": "skills/writing-openrewrite-recipes/references/example-scanning-recipe.java", + "sha256": "c87fe6c1dc09ceda8ba75e4099504eddd89da1db52cc17ee2bb79de96dc48809" + }, + { + "path": "skills/writing-openrewrite-recipes/references/recipes-framework-migrations-common.csv", + "sha256": "043315a667d6eb733d8428c6179ae9f17e4c492d39c9e11e24b9274efdc8801f" + }, + { + "path": "skills/writing-openrewrite-recipes/references/example-declarative-migration.yml", + "sha256": "ec94034dea27e0e647fe66f4dd6420c57fb1b64d926abe187232d81b69bdb388" + }, + { + "path": "skills/writing-openrewrite-recipes/references/recipes-spring-boot-common.csv", + "sha256": "7fbec3a2b8397bd8e755ef9976f50b23f9433eeaa33069e09f774f0acb63cec0" + }, + { + "path": "skills/writing-openrewrite-recipes/references/recipes-java-basic.csv", + "sha256": "34fe896e82bb342f2662a4008dd13464fe8ad3d17aae27e237587d30d4c3a94f" + }, + { + "path": "skills/writing-openrewrite-recipes/references/recipes-dependencies-common.csv", + "sha256": "b881a20a8589613a6412d75cbf099968d6dcb2fafb2d081470c49f8d69f5401f" + }, + { + "path": "skills/writing-openrewrite-recipes/references/recipes-file-operations.csv", + "sha256": "9453041510ce0d33080248009b2891e710fada212826b3799c3919b460e91c10" + }, + { + "path": "skills/writing-openrewrite-recipes/references/recipes-static-analysis-common.csv", + "sha256": "27f044c2a1bf82e90175fb9c9253682f48cd957e43a390b40ba4f43d0f47f9e1" + }, + { + "path": "skills/writing-openrewrite-recipes/references/recipes-testing-common.csv", + "sha256": "a9fef84a7bbcb7d597b9263cbc6fb37b0f3956785f85d405d8c76442c8cb4d14" + }, + { + "path": "skills/writing-openrewrite-recipes/references/recipes-security-common.csv", + "sha256": "028df3f99e4033df3939c44a968e85f31f10f02bab3a08671d646fb65026d583" + }, + { + "path": "skills/writing-openrewrite-recipes/references/recipes-top.csv", + "sha256": "2749b9d1e43bac9fe50d732526bedb19ba876180c4e1a6c96ac38a244981faaf" + }, + { + "path": "skills/writing-openrewrite-recipes/references/recipes-logging-common.csv", + "sha256": "b0d975a8f0f7a15074b1a29c9eb9604e247add040a9c98465247c54d8ac5b424" + }, + { + "path": "skills/writing-openrewrite-recipes/scripts/categorize_recipes.py", + "sha256": "b54ef626427183d6f03e02fb49a3ecd1cd44d72e12d2858e6399d57813fce357" + }, + { + "path": "skills/writing-openrewrite-recipes/scripts/upload-skill.sh", + "sha256": "a8376ca001978a958fa456d03bf978998e31eb18424ffac9b4dd8fa8c3ee7585" + }, + { + "path": "skills/writing-openrewrite-recipes/scripts/create_curated_lists.py", + "sha256": "7cd4840479afeaffbc0555aaf737180881fd7baa8a3a40412f16cdfe5015257c" + }, + { + "path": "skills/writing-openrewrite-recipes/assets/template-declarative-recipe.yml", + "sha256": "a149b6067cf18e294b97491acc3ff69ef4583adf345e933743f64409185f67c2" + }, + { + "path": "skills/writing-openrewrite-recipes/assets/template-recipe-test.java", + "sha256": "77761644a60fd635e9b9ea46f267fbd77cd3c1c538803be4e666889a192a7de7" + }, + { + "path": "skills/writing-openrewrite-recipes/assets/template-imperative-recipe.java", + "sha256": "b8f6253d746ffd5375649b3ff1b5f44e8182702739c43702152186be05e9d0a2" + } + ], + "dirSha256": "049fc4cdd92369bce2da02fd52742233dd73d5cedbe66ac17a777f45a869e4bb" + }, + "security": { + "scannedAt": null, + "scannerVersion": null, + "flags": [] + } +} \ No newline at end of file diff --git a/skills/writing-openrewrite-recipes/SKILL.md b/skills/writing-openrewrite-recipes/SKILL.md new file mode 100644 index 0000000..39f462b --- /dev/null +++ b/skills/writing-openrewrite-recipes/SKILL.md @@ -0,0 +1,462 @@ +--- +name: writing-openrewrite-recipes +description: Use when creating/writing/building OpenRewrite recipes, working with .java recipe files, RewriteTest files, recipe YAML files, LST visitors, JavaTemplate, visitor patterns, or when discussing recipe types (declarative YAML, Refaster templates, imperative Java recipes) - guides creation of OpenRewrite recipes for automated code transformations, AST manipulation, custom refactoring rules, and code migration. +allowed-tools: Read, Write, Edit, Bash, Grep, Glob +--- + +# OpenRewrite Recipe Writing Skill + +## Overview + +OpenRewrite recipes are automated refactoring operations that modify Lossless Semantic Trees (LSTs) representing source code. This skill guides through creating recipes efficiently and correctly. + +## When NOT to Use This Skill + +Do NOT use this skill for: +- General Java programming questions unrelated to OpenRewrite +- Questions about running existing OpenRewrite recipes (use OpenRewrite documentation) +- Build tool configuration unrelated to recipe development +- General refactoring advice without OpenRewrite context + +## Quick Start Decision Tree + +To determine the best approach quickly: + +1. Can the transformation be expressed by composing existing recipes? + → **Use Declarative YAML** (see Declarative YAML Recipes section below) + +2. Is it a simple expression/statement replacement pattern? + → **Use Refaster Template** (see Refaster Template Recipes section below) + +3. Requires complex logic, conditional transformations, or custom analysis? + → **Use Imperative Java Recipe** (see Imperative Recipe Development Workflow below) + +For imperative recipes, proceed to "Imperative Recipe Development Workflow" below. + +## Recipe Type Selection + +Choose the appropriate recipe type based on your needs: + +### Declarative YAML Recipes (Preferred) + +**Use when:** Composing existing recipes with configuration + +**Advantages:** No code, simple, maintainable + +**Example use case:** Combining framework migration steps + +```yaml +type: specs.openrewrite.org/v1beta/recipe +name: com.yourorg.MyMigration +displayName: Migrate to Framework X +recipeList: + - org.openrewrite.java.ChangeType: + oldFullyQualifiedTypeName: old.Type + newFullyQualifiedTypeName: new.Type + - com.yourorg.OtherRecipe +``` + +**Finding Recipes to Use:** +When building declarative YAML recipes, consult the recipe catalog CSV files in the `references/` directory: + +- `references/recipes-top.csv` - 50 commonly used recipes across all categories (best starting point) +- `references/recipes-java-basic.csv` - 32 basic Java refactoring operations +- `references/recipes-spring-boot-common.csv` - 60 Spring Boot migrations and best practices +- `references/recipes-framework-migrations-common.csv` - 16 major framework migrations (diverse frameworks) +- `references/recipes-testing-common.csv` - 60 most useful testing recipes (JUnit, Mockito, AssertJ) +- `references/recipes-dependencies-common.csv` - 49 dependency operations (Maven+Gradle when possible) +- `references/recipes-security-common.csv` - 30 security vulnerability detection and fixes +- `references/recipes-xml-yaml-json-common.csv` - 50 configuration file operations +- `references/recipes-static-analysis-common.csv` - 50 code analysis and search recipes +- `references/recipes-logging-common.csv` - 50 logging framework operations +- `references/recipes-file-operations.csv` - 14 file and text manipulation operations + +**Usage Pattern:** Start with `recipes-top.csv`, then consult the specific category file based on what the user needs. These curated lists contain the most practical and commonly used recipes for each category. + +### Refaster Template Recipes + +**Use when:** Simple expression/statement replacements + +**Advantages:** Faster than imperative, type-aware + +**Example use case:** Replace `StringUtils.equals()` with `Objects.equals()` + +### Imperative Java Recipes + +**Use when:** Complex logic, conditional transformations, custom analysis + +**Advantages:** Full control, complex transformations + +**Example use case:** Add modifiers only to variables that aren't reassigned + +**Decision Rule:** If it can be declarative, make it declarative. Use imperative only when necessary. + +## Examples Quick Reference + +Navigate to the right example based on your needs: + +- **New to recipes?** Start with `references/example-say-hello-recipe.java` +- **Need multi-file analysis?** See `references/example-scanning-recipe.java` +- **Composing recipes?** Check `references/example-declarative-migration.yml` + +## Imperative Recipe Development Workflow + +### 1. Set Up Recipe Class + +```java +@Value +@EqualsAndHashCode(callSuper = false) +public class YourRecipe extends Recipe { + + @Option(displayName = "Display Name", + description = "Clear description.", + example = "com.example.Type") + String parameterName; + + @Override + public String getDisplayName() { + return "Your recipe name"; + } + + @Override + public String getDescription() { + return "What this recipe does."; + } + + @Override + public TreeVisitor getVisitor() { + return new YourVisitor(); + } +} +``` + +**Key Points:** + +- Use `@Value` and `@EqualsAndHashCode(callSuper = false)` for immutability +- Ensure all recipes are serializable +- Define configurable parameters using `@Option` fields +- Return a NEW instance from `getVisitor()` each time (no caching) + +### 2. Implement the Visitor + +```java +public class YourVisitor extends JavaIsoVisitor { + + @Override + public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) { + // ALWAYS call super to traverse the tree + J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, ctx); + + // Check if change is needed (do no harm) + if (!shouldChange(cd)) { + return cd; + } + + // Make changes using JavaTemplate or LST methods + cd = makeChanges(cd); + + return cd; + } +} +``` + +**Visitor Guidelines:** + +- Use `JavaIsoVisitor` when returning the same type (most common) +- Use `JavaVisitor` only when changing LST types +- Call `super.visitX()` to traverse subtree in most cases. Omit the `super` call only when certain there could be no further edits below the current LST element +- Return unchanged LST if no change needed (referential equality check) +- Treat LSTs as immutable. Use `.withX()` methods for modifications + +### 3. Use JavaTemplate for Complex Changes + +```java +private final JavaTemplate template = JavaTemplate + .builder("public String hello() { return \"Hello from #{}!\"; }") + .build(); + +// In visitor method: +classDecl = template.apply( + new Cursor(getCursor(), classDecl.getBody()), + classDecl.getBody().getCoordinates().lastStatement(), + fullyQualifiedClassName +); +``` + +**Template Tips:** + +- Use `#{}` for string parameters +- Use `#{any(Type)}` for typed LST elements +- Declare imports: `.imports("java.util.List")` +- Add classpath: `.javaParser(JavaParser.fromJavaVersion().classpath("library-name"))` +- Prefer context-free templates (default) as they are faster +- Use `.contextSensitive()` only when referencing local scope + +### 4. Add Preconditions (Performance) + +```java +@Override +public TreeVisitor getVisitor() { + return Preconditions.check( + Preconditions.and( + new UsesType<>("com.example.Type", true), + new UsesJavaVersion<>(17) + ), + new YourVisitor() + ); +} +``` + +**Benefits:** Limits recipe execution to relevant files only, improving performance + +## Testing Recipes + +### Test Structure + +```java +class YourRecipeTest implements RewriteTest { + + @Override + public void defaults(RecipeSpec spec) { + spec.recipe(new YourRecipe("parameter-value")); + } + + @Test + void makesExpectedChange() { + rewriteRun( + //language=java + java( + // Before + """ + package com.example; + class Before { } + """, + // After + """ + package com.example; + class After { } + """ + ) + ); + } + + @Test + void doesNotChangeWhenNotNeeded() { + rewriteRun( + //language=java + java( + """ + package com.example; + class AlreadyCorrect { } + """ + // No second argument = no change expected + ) + ); + } +} +``` + +Notice how in Java template strings, the end `"""` delimiter is one indent to the right of the open delimiter. Java trims everything to the left of that same column. + +**Testing Best Practices:** + +- Test both changes AND no-changes cases +- Test edge cases +- Note that the test harness runs multiple cycles to ensure idempotence +- Add `//language=XXX` comments to the highest level statement whose string arguments entirely consist of code snippets of that same language. This helps the IDE syntax highlight the test code + +## ScanningRecipe Pattern + +Use when you need to: + +- See all files before making changes +- Generate new files based on analysis +- Share data across multiple files + +```java +@Value +@EqualsAndHashCode(callSuper = false) +public class YourScanningRecipe extends ScanningRecipe { + + public static class YourAccumulator { + Map projectData = new HashMap<>(); + } + + @Override + public YourAccumulator getInitialValue(ExecutionContext ctx) { + return new YourAccumulator(); + } + + @Override + public TreeVisitor getScanner(YourAccumulator acc) { + return new JavaIsoVisitor<>() { + @Override + public J.CompilationUnit visitCompilationUnit(J.CompilationUnit cu, ExecutionContext ctx) { + // Collect data into accumulator + return cu; + } + }; + } + + @Override + public TreeVisitor getVisitor(YourAccumulator acc) { + return new JavaIsoVisitor<>() { + @Override + public J.CompilationUnit visitCompilationUnit(J.CompilationUnit cu, ExecutionContext ctx) { + // Use data from accumulator to make changes + return cu; + } + }; + } +} +``` + +## Critical Best Practices + +### Do No Harm + +- If unsure whether a change is safe, DON'T make it +- Make minimal, least invasive changes +- Respect existing formatting + +### Immutability & Idempotence + +- Recipes must be immutable (no mutable state) +- Same input → same output, always +- Use `@Value` and `@EqualsAndHashCode(callSuper = false)` +- `getVisitor()` must return NEW instance + +### Never Mutate LSTs + +```java +// WRONG +method.getArguments().remove(0); + +// CORRECT +method.withArguments(ListUtils.map(method.getArguments(), (i, arg) -> + i == 0 ? null : arg +)); +``` + +### Naming Conventions + +- Display names: Sentence case, code in backticks, end with period +- Example: "Change type from `OldType` to `NewType`." +- Recipe names: `com.yourorg.VerbNoun` (e.g., `com.yourorg.ChangePackage`) + +### State Management + +- Within visitor: Use Cursor messaging (`getCursor().putMessage()`) +- Between visitors: Use ScanningRecipe accumulator +- Never use ExecutionContext for visitor state + +### Multi-Module Projects + +- Track per-project data: `Map` +- Don't assume single project per repository + +## Common Patterns + +### Adding Imports + +```java +maybeAddImport("java.util.List"); +maybeAddImport("java.util.Collections", "emptyList"); +``` + +### Removing Imports + +```java +maybeRemoveImport("old.package.Type"); +``` + +### Chaining Visitors + +```java +doAfterVisit(new OtherRecipe().getVisitor()); +``` + +### Checking Types + +```java +if (methodInvocation.getType() != null && + TypeUtils.isOfClassType(methodInvocation.getType(), "com.example.Type")) { + // ... +} +``` + +## Resources + +This skill includes several supporting files organized by purpose: + +- **Templates** (`assets/`) - Files used as starting points for recipe development: + + - `assets/template-imperative-recipe.java` - Boilerplate for imperative recipes + - `assets/template-declarative-recipe.yml` - YAML recipe template + - `assets/template-recipe-test.java` - Test class template + + **Load when:** Creating a new recipe or needing a template to start from + +- **Examples** (`references/`) - Reference documentation loaded as needed: + + - `references/example-say-hello-recipe.java` - Complete working recipe with test and YAML usage + - `references/example-scanning-recipe.java` - Advanced ScanningRecipe pattern for multi-file analysis + - `references/example-declarative-migration.yml` - Real-world YAML migration examples + + **Load when:** Needing to see a complete example, asking "show me an example", or understanding advanced patterns + +- **Recipe Catalogs** (`references/`) - Curated lists for finding recipes when building declarative YAML recipes: + - `references/recipes-top.csv` - 50 commonly used recipes (best starting point) + - `references/recipes-java-basic.csv` - 32 basic Java refactoring operations + - `references/recipes-spring-boot-common.csv` - 60 Spring Boot migrations and best practices + - `references/recipes-framework-migrations-common.csv` - 16 major framework migrations (10 different frameworks) + - `references/recipes-testing-common.csv` - 60 most useful testing recipes + - `references/recipes-dependencies-common.csv` - 49 dependency operations (Maven+Gradle when possible) + - `references/recipes-security-common.csv` - 30 security vulnerability recipes + - `references/recipes-xml-yaml-json-common.csv` - 50 configuration file operations + - `references/recipes-static-analysis-common.csv` - 50 code analysis recipes + - `references/recipes-logging.csv` - 153 logging framework recipes + - `references/recipes-file-operations.csv` - 14 file manipulation recipes + - Note: `references/recipes-all.csv` exists for maintenance/script purposes but is too large (4,958 recipes) to be used directly + + **Load when:** Looking for existing recipes + +- **Checklist** (`references/`) - Verification guide: + + - `references/checklist-recipe-development.md` - Comprehensive verification checklist covering planning, implementation, testing, and distribution + + **Load when:** Reviewing a recipe for completeness, ensuring best practices, or preparing for distribution + +- **Scripts** (`scripts/`) - Utility scripts: + + - `scripts/upload-skill.sh` - Script to upload/update the skill via API + + **Load when:** Managing the skill itself (meta-operation) + +## Quick Reference + +**Key Classes:** + +- `Recipe` - Base class for all recipes +- `JavaIsoVisitor` - Most common visitor +- `JavaTemplate` - For generating code snippets +- `RewriteTest` - Testing interface +- `ScanningRecipe` - Multi-file analysis + +**Key Methods:** + +- `getVisitor()` - Returns visitor instance +- `super.visitX()` - Traverse subtree +- `.withX()` - Create modified LST copy +- `ListUtils.map()` - Transform lists without mutation +- `doAfterVisit()` - Chain additional visitors + +**Use this skill for help with:** + +- Choosing the right recipe type +- Structuring recipe classes +- Writing visitor logic +- Using JavaTemplate +- Writing tests +- Debugging common issues +- Understanding LST structure diff --git a/skills/writing-openrewrite-recipes/assets/template-declarative-recipe.yml b/skills/writing-openrewrite-recipes/assets/template-declarative-recipe.yml new file mode 100644 index 0000000..6c1840f --- /dev/null +++ b/skills/writing-openrewrite-recipes/assets/template-declarative-recipe.yml @@ -0,0 +1,122 @@ +--- +# OpenRewrite Declarative Recipe Template +# Save this file in: src/main/resources/META-INF/rewrite/ + +# Required: Recipe type identifier +type: specs.openrewrite.org/v1beta/recipe + +# Required: Fully qualified recipe name (convention: com.yourorg.RecipeName) +name: com.yourorg.YourRecipeName + +# Required: Human-readable recipe name (sentence case, end with period if sentence) +displayName: Your recipe display name + +# Required: Clear description of what the recipe does +description: A clear description of what this recipe accomplishes. This can span multiple lines and should explain the purpose and effect of running this recipe. + +# Optional: Tags for categorization and searchability +tags: + - category1 + - category2 + - framework-name + +# Optional: Estimated time saved by this recipe (in ISO-8601 duration format) +# estimatedEffortPerOccurrence: PT5M + +# Optional: Set to true if this recipe requires multiple execution cycles +# causesAnotherCycle: true + +# Optional: Define preconditions that files must meet to run this recipe +# preconditions: +# - org.openrewrite.java.search.UsesType: +# fullyQualifiedTypeName: com.example.TargetType + +# Required: List of recipes to execute (in order) +recipeList: + # Example: Recipe with no parameters + - org.openrewrite.java.format.AutoFormat + + # Example: Recipe with parameters + - org.openrewrite.java.ChangeType: + oldFullyQualifiedTypeName: old.package.OldType + newFullyQualifiedTypeName: new.package.NewType + # Optional parameter + ignoreDefinition: false + + # Example: Another recipe with parameters + - org.openrewrite.java.ChangePackage: + oldPackageName: com.old.package + newPackageName: com.new.package + recursive: true + + # Example: Add a dependency (only if type is used) + - org.openrewrite.java.dependencies.AddDependency: + groupId: org.example + artifactId: example-library + version: latest.release + onlyIfUsing: com.example.SomeClass + configuration: implementation + + # Example: Maven-specific recipe + - org.openrewrite.maven.UpgradePluginVersion: + groupId: org.apache.maven.plugins + artifactId: maven-compiler-plugin + newVersion: 3.11.0 + + # Add your recipes here + # - com.yourorg.AnotherRecipe + # - com.yourorg.YetAnotherRecipe: + # parameter: value + +--- +# You can define multiple recipes in the same file by using '---' separator + +# type: specs.openrewrite.org/v1beta/recipe +# name: com.yourorg.AnotherRecipe +# displayName: Another recipe +# description: Description of the second recipe. +# recipeList: +# - ... + +# Common Recipe References: +# +# Java Type Changes: +# - org.openrewrite.java.ChangeType +# - org.openrewrite.java.ChangePackage +# - org.openrewrite.java.ChangeMethodName +# - org.openrewrite.java.ChangeFieldName +# +# Dependency Management: +# - org.openrewrite.java.dependencies.AddDependency +# - org.openrewrite.java.dependencies.RemoveDependency +# - org.openrewrite.java.dependencies.ChangeDependency +# - org.openrewrite.java.dependencies.UpgradeDependencyVersion +# +# Maven: +# - org.openrewrite.maven.UpgradePluginVersion +# - org.openrewrite.maven.UpgradeDependencyVersion +# - org.openrewrite.maven.ChangePropertyValue +# +# Static Analysis: +# - org.openrewrite.staticanalysis.CommonStaticAnalysis +# - org.openrewrite.staticanalysis.FinalizeLocalVariables +# - org.openrewrite.staticanalysis.RemoveUnusedImports +# +# Testing: +# - org.openrewrite.java.testing.junit5.JUnit4to5Migration +# - org.openrewrite.java.testing.junit5.AssertToAssertions +# +# Spring: +# - org.openrewrite.java.spring.boot3.UpgradeSpringBoot_3_0 +# - org.openrewrite.java.spring.boot2.UpgradeSpringBoot_2_7 +# +# Formatting: +# - org.openrewrite.java.format.AutoFormat +# - org.openrewrite.java.format.RemoveUnusedImports +# - org.openrewrite.java.format.TabsAndIndents +# +# Search recipes (use these in preconditions): +# - org.openrewrite.java.search.UsesType +# - org.openrewrite.java.search.UsesMethod +# - org.openrewrite.java.search.FindTypes +# - org.openrewrite.java.search.FindMethods diff --git a/skills/writing-openrewrite-recipes/assets/template-imperative-recipe.java b/skills/writing-openrewrite-recipes/assets/template-imperative-recipe.java new file mode 100644 index 0000000..4cd70c3 --- /dev/null +++ b/skills/writing-openrewrite-recipes/assets/template-imperative-recipe.java @@ -0,0 +1,200 @@ +package com.yourorg; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.EqualsAndHashCode; +import lombok.Value; +import org.jspecify.annotations.NonNull; +import org.openrewrite.*; +import org.openrewrite.java.JavaIsoVisitor; +import org.openrewrite.java.JavaTemplate; +import org.openrewrite.java.tree.J; + +/** + * TODO: Add recipe description + * + * Example usage in YAML: + * ```yaml + * type: specs.openrewrite.org/v1beta/recipe + * name: com.yourorg.MyRecipeGroup + * recipeList: + * - com.yourorg.YourRecipeName: + * parameterName: value + * ``` + */ +@Value +@EqualsAndHashCode(callSuper = false) +public class YourRecipeName extends Recipe { + + /** + * TODO: Add options for recipe configuration + * Each option becomes a parameter that can be configured in YAML + */ + @Option( + displayName = "Parameter Display Name", + description = "A clear description of what this parameter does.", + example = "com.example.ExampleValue" + ) + @NonNull + String parameterName; + + // Add more @Option fields as needed + // @Option(displayName = "Another Parameter", ...) + // String anotherParameter; + + /** + * All recipes must be serializable via Jackson. + * Use @JsonCreator and @JsonProperty annotations. + */ + @JsonCreator + public YourRecipeName( + @NonNull @JsonProperty("parameterName") String parameterName + ) { + this.parameterName = parameterName; + } + + @Override + public String getDisplayName() { + return "Your recipe display name"; + } + + @Override + public String getDescription() { + return "A clear description of what this recipe does. Use sentence case and end with a period."; + } + + /** + * Optional: Add preconditions to improve performance + * Recipes only run on files that match these conditions + */ + // @Override + // public TreeVisitor getVisitor() { + // return Preconditions.check( + // new UsesType<>("com.example.SomeType", true), + // new YourRecipeVisitor() + // ); + // } + + @Override + public TreeVisitor getVisitor() { + // IMPORTANT: Always return a NEW instance (no caching) + return new YourRecipeVisitor(); + } + + /** + * The visitor implements the actual transformation logic. + * Use JavaIsoVisitor when always returning the same LST type. + */ + public class YourRecipeVisitor extends JavaIsoVisitor { + + /** + * Optional: Create JavaTemplates for complex code generation + * Templates are parsed once and can be reused + */ + // private final JavaTemplate template = JavaTemplate + // .builder("your.code.template(#{any(String)})") + // .imports("your.imports.Here") + // .build(); + + /** + * Override visit methods for the LST elements you want to transform. + * Common visit methods: + * - visitCompilationUnit() - entire file + * - visitClassDeclaration() - class declarations + * - visitMethodDeclaration() - method declarations + * - visitMethodInvocation() - method calls + * - visitVariableDeclarations() - variable declarations + * - visitAssignment() - assignments + * - visitBinary() - binary operations + * - visitImport() - imports + */ + @Override + public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) { + // Step 1: ALWAYS call super to traverse the subtree + J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, ctx); + + // Step 2: Check if this element needs to be changed + // DO NO HARM: If unsure, return unchanged + if (!shouldChange(cd)) { + return cd; + } + + // Step 3: Make your changes + // Never mutate the LST - always use .withX() methods + cd = makeYourChanges(cd, ctx); + + // Step 4: Optional - chain other visitors + // doAfterVisit(new SomeOtherRecipe().getVisitor()); + + // Step 5: Optional - add/remove imports + // maybeAddImport("java.util.List"); + // maybeRemoveImport("old.package.Type"); + + return cd; + } + + /** + * Helper method to determine if changes are needed + */ + private boolean shouldChange(J.ClassDeclaration classDecl) { + // TODO: Implement your logic + // Check if change is necessary and safe + // Example: Check if class matches criteria + + // Check for null type (avoid NPE) + if (classDecl.getType() == null) { + return false; + } + + // Example: Check fully qualified name + // if (!classDecl.getType().getFullyQualifiedName().equals(parameterName)) { + // return false; + // } + + // Example: Check if change already exists + // if (alreadyHasTheChange(classDecl)) { + // return false; + // } + + return true; + } + + /** + * Helper method to perform the transformation + */ + private J.ClassDeclaration makeYourChanges(J.ClassDeclaration classDecl, ExecutionContext ctx) { + // TODO: Implement your transformation logic + + // Example: Using a JavaTemplate + // classDecl = classDecl.withBody( + // template.apply( + // new Cursor(getCursor(), classDecl.getBody()), + // classDecl.getBody().getCoordinates().lastStatement(), + // someParameter + // ) + // ); + + // Example: Modifying using LST methods + // classDecl = classDecl.withName(classDecl.getName().withSimpleName("NewName")); + + // Example: Using ListUtils to avoid mutation + // classDecl = classDecl.withModifiers( + // ListUtils.concat(classDecl.getModifiers(), newModifier) + // ); + + return classDecl; + } + + /** + * Optional: Example of another visit method + */ + // @Override + // public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { + // J.MethodInvocation m = super.visitMethodInvocation(method, ctx); + // + // // Your logic here + // + // return m; + // } + } +} diff --git a/skills/writing-openrewrite-recipes/assets/template-recipe-test.java b/skills/writing-openrewrite-recipes/assets/template-recipe-test.java new file mode 100644 index 0000000..a3f7de2 --- /dev/null +++ b/skills/writing-openrewrite-recipes/assets/template-recipe-test.java @@ -0,0 +1,292 @@ +package com.yourorg; + +import org.junit.jupiter.api.Test; +import org.openrewrite.DocumentExample; +import org.openrewrite.test.RecipeSpec; +import org.openrewrite.test.RewriteTest; + +import static org.openrewrite.java.Assertions.java; +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Test class for YourRecipeName + * + * Best Practices: + * - Test both cases where changes ARE made and where they ARE NOT made + * - Test edge cases and boundary conditions + * - Use meaningful test names that describe what is being tested + * - Add @DocumentExample to one test to generate documentation + */ +class YourRecipeNameTest implements RewriteTest { + + /** + * Configure defaults for all tests in this class. + * This is called before each test method. + */ + @Override + public void defaults(RecipeSpec spec) { + // Set the recipe to test with default parameters + spec.recipe(new YourRecipeName("parameter-value")); + + // Optional: Configure parser with classpath dependencies + // spec.parser(JavaParser.fromJavaVersion() + // .classpath("library-name") + // .logCompilationWarningsAndErrors(true)); + + // Optional: Configure for specific Java version + // spec.allSources(s -> s.markers(javaVersion(17))); + } + + /** + * Test that the recipe makes the expected change. + * @DocumentExample marks this as the primary example for documentation. + */ + @DocumentExample + @Test + void makesExpectedChange() { + rewriteRun( + // First argument: before state + // Second argument: after state + java( + """ + package com.example; + + class BeforeExample { + // TODO: Add code that should be changed + } + """, + """ + package com.example; + + class AfterExample { + // TODO: Add expected code after transformation + } + """ + ) + ); + } + + /** + * Test that the recipe does NOT make changes when they are not needed. + * This is crucial - recipes must not make unnecessary changes! + */ + @Test + void doesNotChangeWhenNotNeeded() { + rewriteRun( + java( + """ + package com.example; + + class AlreadyCorrect { + // TODO: Add code that should NOT be changed + } + """ + // No second argument means we expect NO changes + ) + ); + } + + /** + * Test edge case or boundary condition + */ + @Test + void handlesEdgeCase() { + rewriteRun( + java( + """ + package com.example; + + class EdgeCase { + // TODO: Add edge case scenario + } + """, + """ + package com.example; + + class EdgeCase { + // TODO: Add expected result for edge case + } + """ + ) + ); + } + + /** + * Example: Test with multiple files + * Demonstrates that some files change and others don't + */ + @Test + void handlesMultipleFiles() { + rewriteRun( + // First file: should change + java( + """ + package com.example; + + class ShouldChange { + } + """, + """ + package com.example; + + class DidChange { + } + """ + ), + // Second file: should NOT change + java( + """ + package com.example; + + class ShouldNotChange { + } + """ + ) + ); + } + + /** + * Example: Test with custom recipe spec for this specific test + */ + @Test + void testWithCustomConfiguration() { + rewriteRun( + // Customize the spec for just this test + spec -> spec + .recipe(new YourRecipeName("different-parameter")) + // Add specific classpath for this test + // .parser(JavaParser.fromJavaVersion().classpath("specific-library")) + , + java( + """ + package com.example; + + class Example { + } + """, + """ + package com.example; + + class Example { + // Changes based on different parameter + } + """ + ) + ); + } + + /** + * Example: Test with afterRecipe callback for additional assertions + */ + @Test + void testWithCallback() { + rewriteRun( + java( + """ + package com.example; + + class Example { + } + """, + """ + package com.example; + + class Example { + // Some change + } + """, + // Callback to perform additional assertions after recipe runs + spec -> spec.afterRecipe(cu -> { + // Custom assertions on the compilation unit + assertThat(cu.getClasses()).hasSize(1); + // Add more assertions as needed + }) + ) + ); + } + + /** + * Example: Test for declarative YAML recipe + */ + // @Test + // void testDeclarativeRecipe() { + // rewriteRun( + // spec -> spec + // .recipeFromResources("com.yourorg.YourRecipeName") + // .parser(JavaParser.fromJavaVersion() + // .classpath("dependencies-needed-for-before-code")), + // java( + // """ + // package com.example; + // + // class Before { + // } + // """, + // """ + // package com.example; + // + // class After { + // } + // """ + // ) + // ); + // } + + /** + * Example: Test with specific file path + */ + // @Test + // void testWithSpecificPath() { + // rewriteRun( + // java( + // """ + // server.port=8080 + // """, + // """ + // server.port=80 + // """, + // spec -> spec.path("src/main/resources/application.properties") + // ) + // ); + // } + + /** + * Example: Test with Java version marker + */ + // @Test + // void testWithJavaVersion() { + // rewriteRun( + // spec -> spec.allSources(s -> s.markers(javaVersion(17))), + // java( + // """ + // package com.example; + // + // class Example { + // // Java 17 specific code + // } + // """ + // ) + // ); + // } + + /** + * Example: Test combining different source file types + */ + // @Test + // void testMultipleFileTypes() { + // rewriteRun( + // java( + // """ + // package com.example; + // class Example { } + // """ + // ), + // // You can mix java(), xml(), yaml(), properties(), etc. + // // yaml( + // // """ + // // key: value + // // """ + // // ) + // ); + // } +} diff --git a/skills/writing-openrewrite-recipes/references/checklist-recipe-development.md b/skills/writing-openrewrite-recipes/references/checklist-recipe-development.md new file mode 100644 index 0000000..6b562e3 --- /dev/null +++ b/skills/writing-openrewrite-recipes/references/checklist-recipe-development.md @@ -0,0 +1,231 @@ +# OpenRewrite Recipe Development Checklist + +Use this checklist to ensure you've covered all important aspects of recipe development. + +## Contents +- [Planning Phase](#planning-phase) + - [Recipe Type Selection](#recipe-type-selection) + - [Requirements Gathering](#requirements-gathering) +- [Implementation Phase](#implementation-phase) + - [Recipe Class Structure](#recipe-class-structure) + - [Visitor Implementation](#visitor-implementation) + - [JavaTemplate Usage](#javatemplate-usage) + - [Advanced Features](#advanced-features) + - [Imports and Dependencies](#imports-and-dependencies) +- [Testing Phase](#testing-phase) + - [Test Structure](#test-structure) + - [Test Coverage](#test-coverage) + - [Test Quality](#test-quality) +- [Code Quality Phase](#code-quality-phase) + - [Best Practices](#best-practices) + - [Naming Conventions](#naming-conventions) + - [Performance](#performance) + - [Multi-Module Support](#multi-module-support) +- [Documentation Phase](#documentation-phase) + - [Code Documentation](#code-documentation) + - [External Documentation](#external-documentation) +- [Distribution Phase](#distribution-phase) + - [Build Configuration](#build-configuration) + - [Publishing](#publishing) +- [Final Verification](#final-verification) + - [Smoke Testing](#smoke-testing) + - [Common Pitfalls Avoided](#common-pitfalls-avoided) +- [Recipe-Specific Checklists](#recipe-specific-checklists) + - [For Declarative Recipes](#for-declarative-recipes) + - [For Refaster Template Recipes](#for-refaster-template-recipes) +- [Notes](#notes) + +## Planning Phase + +### Recipe Type Selection +- [ ] Determined if recipe can be declarative (preferred) +- [ ] Evaluated if Refaster template would work for simple replacements +- [ ] Confirmed imperative recipe is necessary for complex logic +- [ ] Identified which LST elements need to be visited +- [ ] Reviewed existing recipes to avoid duplication + +### Requirements Gathering +- [ ] Clearly defined what the recipe should change +- [ ] Identified what should NOT be changed +- [ ] Documented expected input and output +- [ ] Listed any dependencies or external types needed +- [ ] Determined if multi-file analysis is required (ScanningRecipe) + +## Implementation Phase + +### Recipe Class Structure +- [ ] Used `@Value` and `@EqualsAndHashCode(callSuper = false)` for immutability +- [ ] All fields are final (via Lombok or manual implementation) +- [ ] Added `@JsonCreator` constructor with `@JsonProperty` annotations +- [ ] Defined `@Option` fields with clear descriptions and examples +- [ ] Implemented `getDisplayName()` with sentence-case name +- [ ] Implemented `getDescription()` with clear, period-ending description +- [ ] `getVisitor()` returns NEW instance (never cached) + +### Visitor Implementation +- [ ] Chose correct visitor type (JavaIsoVisitor vs JavaVisitor) +- [ ] Called `super.visitX()` in overridden visit methods +- [ ] Checked for null before accessing type information +- [ ] Implemented "do no harm" - return unchanged LST when unsure +- [ ] Used `.withX()` methods instead of mutating LSTs +- [ ] Used `ListUtils` instead of stream operations on LST collections +- [ ] Avoided creating new lists unnecessarily + +### JavaTemplate Usage (if applicable) +- [ ] Used typed substitution `#{any(Type)}` for LST elements +- [ ] Used untyped substitution `#{}` for strings +- [ ] Declared all imports with `.imports()` +- [ ] Declared static imports with `.staticImports()` +- [ ] Configured parser with `.javaParser()` if referencing external types +- [ ] Added classpath dependencies or stubs as needed +- [ ] Used context-free templates (default) when possible +- [ ] Only used `.contextSensitive()` when necessary + +### Advanced Features (if applicable) +- [ ] Added preconditions with `Preconditions.check()` +- [ ] Used `UsesType` or `UsesMethod` to filter applicable files +- [ ] Implemented cursor messaging for intra-visitor communication +- [ ] For ScanningRecipe: defined accumulator with `Map` +- [ ] For ScanningRecipe: implemented `getInitialValue()` +- [ ] For ScanningRecipe: implemented `getScanner()` (no changes, only collect) +- [ ] For ScanningRecipe: implemented `getVisitor()` (uses accumulator data) +- [ ] For ScanningRecipe: implemented `generate()` if creating new files + +### Imports and Dependencies +- [ ] Used `maybeAddImport()` for new types +- [ ] Used `maybeRemoveImport()` for removed types +- [ ] Chained visitors with `doAfterVisit()` when needed + +## Testing Phase + +### Test Structure +- [ ] Created test class implementing `RewriteTest` +- [ ] Implemented `defaults(RecipeSpec)` with recipe configuration +- [ ] Added `@DocumentExample` to primary test + +### Test Coverage +- [ ] Test for expected changes (before → after) +- [ ] Test for no changes when not applicable (before only) +- [ ] Test for edge cases and boundary conditions +- [ ] Test with multiple files +- [ ] Test that recipe doesn't change already-correct code +- [ ] Test with different parameter values (if applicable) +- [ ] Test with different Java versions (if version-specific) +- [ ] Added classpath dependencies with `spec.parser()` + +### Test Quality +- [ ] Test names clearly describe what is being tested +- [ ] Used meaningful package and class names in test code +- [ ] Included comments explaining complex test scenarios +- [ ] Verified tests pass (including multi-cycle verification) +- [ ] Checked that recipe is idempotent (runs produce same result) + +## Code Quality Phase + +### Best Practices +- [ ] Recipe follows "do no harm" principle +- [ ] Recipe makes minimal, least invasive changes +- [ ] Recipe is immutable (no mutable state) +- [ ] Recipe is idempotent (same input → same output) +- [ ] Recipe never mutates LSTs +- [ ] Recipe respects existing formatting +- [ ] Used referential equality checks (same object = no change) + +### Naming Conventions +- [ ] Display name uses sentence case +- [ ] Display name uses backticks around code elements +- [ ] Display name ends with period (if complete sentence) +- [ ] Description is clear and concise +- [ ] Recipe class name follows `VerbNoun` pattern +- [ ] Package name follows `com.yourorg.category` pattern + +### Performance +- [ ] Added preconditions to skip irrelevant files +- [ ] Used context-free JavaTemplates when possible +- [ ] Avoided unnecessary LST allocations +- [ ] Recipe completes work in single cycle (no `causesAnotherCycle`) +- [ ] For ScanningRecipe: minimized accumulator size + +### Multi-Module Support +- [ ] For ScanningRecipe: tracked data per `JavaProject` +- [ ] Did not assume single project per repository +- [ ] Retrieved JavaProject from markers correctly + +## Documentation Phase + +### Code Documentation +- [ ] Added class-level JavaDoc describing the recipe +- [ ] Documented all `@Option` fields clearly +- [ ] Added inline comments for complex logic +- [ ] Included usage example in JavaDoc + +### External Documentation +- [ ] Created YAML file in `src/main/resources/META-INF/rewrite/` (if distributing) +- [ ] Added recipe to catalog/index (if applicable) +- [ ] Documented any known limitations +- [ ] Added tags for categorization + +## Distribution Phase + +### Build Configuration +- [ ] Recipe compiles with Java 8 target (or appropriate version) +- [ ] Added `-parameters` compiler flag for Jackson +- [ ] Included rewrite-recipe-bom for dependency management +- [ ] Tests run successfully with build tool + +### Publishing +- [ ] Published to local Maven repository for testing (`publishToMavenLocal`) +- [ ] Tested recipe in separate project +- [ ] Configured publishing to artifact repository (if applicable) +- [ ] Tagged release in version control + +## Final Verification + +### Smoke Testing +- [ ] Ran recipe on sample project +- [ ] Verified changes are correct +- [ ] Verified no unwanted changes were made +- [ ] Checked that formatting is preserved +- [ ] Ran recipe multiple times (idempotence check) + +### Common Pitfalls Avoided +- [ ] Did not mutate LSTs directly +- [ ] Did not cache visitor instances +- [ ] Did not use ExecutionContext for visitor state +- [ ] Did not forget to call `super.visitX()` +- [ ] Did not create unnecessary list allocations +- [ ] Did not forget imports in JavaTemplate +- [ ] Did not skip null checks on type information +- [ ] Did not assume single project per repository + +## Recipe-Specific Checklists + +### For Declarative Recipes +- [ ] Saved in `src/main/resources/META-INF/rewrite/` +- [ ] Used `type: specs.openrewrite.org/v1beta/recipe` +- [ ] All recipe names are fully qualified +- [ ] All parameters are correctly indented +- [ ] String values with special characters are quoted +- [ ] Recipe list is in logical order +- [ ] Tested with `spec.recipeFromResources()` + +### For Refaster Template Recipes +- [ ] Created template class with `@RecipeDescriptor` +- [ ] Implemented `@BeforeTemplate` methods +- [ ] Implemented single `@AfterTemplate` method +- [ ] Verified generated recipe works correctly +- [ ] Recipe name uses generated form (e.g., `RecipesName`) + +## Notes + +Remember: +- **Do no harm**: If unsure, don't change +- **Minimize changes**: Make only necessary modifications +- **Immutability**: Recipes and LSTs must not be mutated +- **Test thoroughly**: Both positive and negative cases +- **Document clearly**: Future maintainers will thank you + +For more information, see: +- SKILL.md in this skill directory +- OpenRewrite documentation in this repository +- Examples in examples/ directory diff --git a/skills/writing-openrewrite-recipes/references/example-declarative-migration.yml b/skills/writing-openrewrite-recipes/references/example-declarative-migration.yml new file mode 100644 index 0000000..bce117a --- /dev/null +++ b/skills/writing-openrewrite-recipes/references/example-declarative-migration.yml @@ -0,0 +1,257 @@ +--- +# ============================================================================== +# Example: Framework Migration Recipe +# ============================================================================== +# This example demonstrates a realistic declarative recipe for migrating +# from one version of a framework to another, combining multiple recipes +# with configuration. +# +# Save this file in: src/main/resources/META-INF/rewrite/ + +type: specs.openrewrite.org/v1beta/recipe +name: com.yourorg.MigrateToFrameworkX +displayName: Migrate to Framework X 2.0 +description: | + Migrates applications from Framework X 1.x to 2.0. This recipe performs the following steps: + - Updates dependency versions + - Migrates renamed packages and types + - Updates deprecated API usage + - Applies code formatting +tags: + - framework-x + - migration + - upgrade +estimatedEffortPerOccurrence: PT15M + +recipeList: + # Step 1: Update dependencies + - org.openrewrite.java.dependencies.ChangeDependency: + oldGroupId: com.example.frameworkx + oldArtifactId: frameworkx-core + newGroupId: com.example.frameworkx + newArtifactId: frameworkx-core + newVersion: 2.0.x + + - org.openrewrite.java.dependencies.AddDependency: + groupId: com.example.frameworkx + artifactId: frameworkx-new-module + version: 2.0.x + onlyIfUsing: com.example.frameworkx.NewFeature + configuration: implementation + + # Step 2: Package and type migrations + - org.openrewrite.java.ChangePackage: + oldPackageName: com.example.frameworkx.old + newPackageName: com.example.frameworkx.v2 + recursive: true + + - org.openrewrite.java.ChangeType: + oldFullyQualifiedTypeName: com.example.frameworkx.OldConfig + newFullyQualifiedTypeName: com.example.frameworkx.v2.NewConfig + + - org.openrewrite.java.ChangeType: + oldFullyQualifiedTypeName: com.example.frameworkx.OldClient + newFullyQualifiedTypeName: com.example.frameworkx.v2.Client + + # Step 3: Method migrations + - org.openrewrite.java.ChangeMethodName: + methodPattern: com.example.frameworkx.v2.Client execute(..) + newMethodName: run + + # Step 4: Apply custom recipes (if you have any) + # - com.yourorg.CustomFrameworkXMigration + + # Step 5: Format the code + - org.openrewrite.java.format.AutoFormat + +--- +# ============================================================================== +# Example: Security Fixes Recipe +# ============================================================================== +# This recipe applies common security fixes across a codebase + +type: specs.openrewrite.org/v1beta/recipe +name: com.yourorg.ApplySecurityFixes +displayName: Apply security best practices +description: Applies a collection of security-related fixes and improvements to the codebase. +tags: + - security + - SAST + +recipeList: + # Use secure random number generation + - org.openrewrite.java.security.SecureRandom + + # Fix SQL injection vulnerabilities + - org.openrewrite.java.security.UseFileCreateTempFile + + # Apply static analysis security fixes + - org.openrewrite.staticanalysis.CommonStaticAnalysis + + # Remove unused imports + - org.openrewrite.java.format.RemoveUnusedImports + +--- +# ============================================================================== +# Example: Testing Framework Migration +# ============================================================================== +# Migrates from JUnit 4 to JUnit 5 + +type: specs.openrewrite.org/v1beta/recipe +name: com.yourorg.MigrateToJUnit5 +displayName: Migrate to JUnit 5 +description: Migrates JUnit 4 tests to JUnit 5 (Jupiter). +tags: + - junit + - testing + - junit5 + +preconditions: + - org.openrewrite.java.search.UsesType: + fullyQualifiedTypeName: org.junit.Test + +recipeList: + # Update dependencies + - org.openrewrite.java.dependencies.RemoveDependency: + groupId: junit + artifactId: junit + + - org.openrewrite.java.dependencies.AddDependency: + groupId: org.junit.jupiter + artifactId: junit-jupiter + version: 5.9.x + onlyIfUsing: org.junit.Test + configuration: testImplementation + + # Migrate annotations and assertions + - org.openrewrite.java.testing.junit5.JUnit4to5Migration + + # Format + - org.openrewrite.java.format.AutoFormat + +--- +# ============================================================================== +# Example: Code Quality Improvements +# ============================================================================== +# A collection of code quality improvements + +type: specs.openrewrite.org/v1beta/recipe +name: com.yourorg.ImproveCodeQuality +displayName: Improve code quality +description: Applies a comprehensive set of code quality improvements. +tags: + - code-quality + - refactoring + - best-practices + +recipeList: + # Static analysis + - org.openrewrite.staticanalysis.CommonStaticAnalysis + + # Finalize local variables that aren't reassigned + - org.openrewrite.staticanalysis.FinalizeLocalVariables + + # Add missing @Override annotations + - org.openrewrite.staticanalysis.MissingOverrideAnnotation + + # Simplify boolean expressions + - org.openrewrite.staticanalysis.SimplifyBooleanExpression + + # Remove unnecessary null checks + - org.openrewrite.staticanalysis.UnnecessaryNullCheckBeforeInstanceOf + + # Format code + - org.openrewrite.java.format.AutoFormat + +--- +# ============================================================================== +# Example: Simple Type Replacement +# ============================================================================== +# A focused recipe that just replaces one type with another + +type: specs.openrewrite.org/v1beta/recipe +name: com.yourorg.ReplaceStringUtils +displayName: Replace Apache Commons StringUtils with Spring StringUtils +description: Replaces usage of Apache Commons StringUtils with Spring Framework's StringUtils. + +recipeList: + - org.openrewrite.java.ChangeType: + oldFullyQualifiedTypeName: org.apache.commons.lang3.StringUtils + newFullyQualifiedTypeName: org.springframework.util.StringUtils + + - org.openrewrite.java.dependencies.AddDependency: + groupId: org.springframework + artifactId: spring-core + version: 6.0.x + onlyIfUsing: org.springframework.util.StringUtils + configuration: implementation + +--- +# ============================================================================== +# TEST EXAMPLE +# ============================================================================== +# Here's how to test a declarative recipe: +# +# ```java +# package com.yourorg; +# +# import org.junit.jupiter.api.Test; +# import org.openrewrite.java.JavaParser; +# import org.openrewrite.test.RecipeSpec; +# import org.openrewrite.test.RewriteTest; +# +# import static org.openrewrite.java.Assertions.java; +# +# class MigrateToFrameworkXTest implements RewriteTest { +# +# @Override +# public void defaults(RecipeSpec spec) { +# spec +# // Load the recipe from resources +# .recipeFromResources("com.yourorg.MigrateToFrameworkX") +# // Add dependencies needed to compile the "before" code +# .parser(JavaParser.fromJavaVersion() +# .classpath("frameworkx-core-1.0")); +# } +# +# @Test +# void migratesFrameworkXCode() { +# rewriteRun( +# java( +# """ +# package com.example; +# +# import com.example.frameworkx.old.OldConfig; +# +# class Example { +# OldConfig config; +# } +# """, +# """ +# package com.example; +# +# import com.example.frameworkx.v2.NewConfig; +# +# class Example { +# NewConfig config; +# } +# """ +# ) +# ); +# } +# } +# ``` + +# ============================================================================== +# TIPS FOR DECLARATIVE RECIPES +# ============================================================================== +# 1. Keep them focused - one migration or fix per recipe +# 2. Use meaningful names that describe what the recipe does +# 3. Document the purpose and steps in the description +# 4. Add tags for searchability +# 5. Use preconditions to avoid running on irrelevant files +# 6. Order matters - recipes run sequentially +# 7. Consider adding AutoFormat at the end +# 8. Test each recipe thoroughly +# 9. Wrap string values in quotes if they contain special characters +# 10. Use estimatedEffortPerOccurrence to help users understand the impact diff --git a/skills/writing-openrewrite-recipes/references/example-say-hello-recipe.java b/skills/writing-openrewrite-recipes/references/example-say-hello-recipe.java new file mode 100644 index 0000000..a6585bc --- /dev/null +++ b/skills/writing-openrewrite-recipes/references/example-say-hello-recipe.java @@ -0,0 +1,186 @@ +package com.yourorg; + +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.EqualsAndHashCode; +import lombok.Value; +import org.jspecify.annotations.NonNull; +import org.openrewrite.*; +import org.openrewrite.java.JavaIsoVisitor; +import org.openrewrite.java.JavaTemplate; +import org.openrewrite.java.tree.J; + +/** + * A simple recipe that adds a hello() method to a specified class. + * + * This example demonstrates: + * - Basic recipe structure with @Value and @EqualsAndHashCode + * - Using @Option for configurable parameters + * - Using JavaTemplate for code generation + * - Checking preconditions before making changes + * - Following the "do no harm" principle + * + * Based on the official OpenRewrite tutorial: + * https://docs.openrewrite.org/authoring-recipes/writing-a-java-refactoring-recipe + */ +@Value +@EqualsAndHashCode(callSuper = false) +public class SayHelloRecipe extends Recipe { + + @Option( + displayName = "Fully Qualified Class Name", + description = "A fully qualified class name indicating which class to add a hello() method to.", + example = "com.yourorg.FooBar" + ) + @NonNull + String fullyQualifiedClassName; + + @JsonCreator + public SayHelloRecipe(@NonNull @JsonProperty("fullyQualifiedClassName") String fullyQualifiedClassName) { + this.fullyQualifiedClassName = fullyQualifiedClassName; + } + + @Override + public String getDisplayName() { + return "Say 'Hello'"; + } + + @Override + public String getDescription() { + return "Adds a \"hello\" method to the specified class."; + } + + @Override + public TreeVisitor getVisitor() { + // Always return a new instance - never cache visitors + return new JavaIsoVisitor() { + + @Override + public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) { + // Step 1: Traverse the subtree first + J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, ctx); + + // Step 2: Check if this is the class we're looking for + // Do no harm: return unchanged if this isn't the target class + if (cd.getType() == null || !cd.getType().getFullyQualifiedName().equals(fullyQualifiedClassName)) { + return cd; + } + + // Step 3: Check if the class already has a hello() method + // Do no harm: don't add if it already exists + boolean helloMethodExists = cd.getBody().getStatements().stream() + .filter(statement -> statement instanceof J.MethodDeclaration) + .map(J.MethodDeclaration.class::cast) + .anyMatch(methodDeclaration -> "hello".equals(methodDeclaration.getName().getSimpleName())); + + if (helloMethodExists) { + return cd; + } + + // Step 4: Add the hello() method using JavaTemplate + // The template uses #{} for parameter substitution + J.Block body = JavaTemplate.apply( + "public String hello() { return \"Hello from #{}!\"; }", + new Cursor(getCursor(), cd.getBody()), + cd.getBody().getCoordinates().lastStatement(), + fullyQualifiedClassName + ); + + return cd.withBody(body); + } + }; + } +} + +// ============================================================ +// TEST CLASS +// ============================================================ + +/* +package com.yourorg; + +import org.junit.jupiter.api.Test; +import org.openrewrite.DocumentExample; +import org.openrewrite.test.RecipeSpec; +import org.openrewrite.test.RewriteTest; + +import static org.openrewrite.java.Assertions.java; + +class SayHelloRecipeTest implements RewriteTest { + + @Override + public void defaults(RecipeSpec spec) { + spec.recipe(new SayHelloRecipe("com.yourorg.FooBar")); + } + + @DocumentExample + @Test + void addsHelloToFooBar() { + rewriteRun( + java( + """ + package com.yourorg; + + class FooBar { + } + """, + """ + package com.yourorg; + + class FooBar { + public String hello() { + return "Hello from com.yourorg.FooBar!"; + } + } + """ + ) + ); + } + + @Test + void doesNotChangeExistingHello() { + rewriteRun( + java( + """ + package com.yourorg; + + class FooBar { + public String hello() { return ""; } + } + """ + ) + ); + } + + @Test + void doesNotChangeOtherClasses() { + rewriteRun( + java( + """ + package com.yourorg; + + class OtherClass { + } + """ + ) + ); + } +} +*/ + +// ============================================================ +// YAML USAGE +// ============================================================ + +/* +Save this in src/main/resources/META-INF/rewrite/say-hello.yml: + +--- +type: specs.openrewrite.org/v1beta/recipe +name: com.yourorg.SayHelloToFooBar +displayName: Say Hello to FooBar +description: Adds a hello() method to the FooBar class. +recipeList: + - com.yourorg.SayHelloRecipe: + fullyQualifiedClassName: com.yourorg.FooBar +*/ diff --git a/skills/writing-openrewrite-recipes/references/example-scanning-recipe.java b/skills/writing-openrewrite-recipes/references/example-scanning-recipe.java new file mode 100644 index 0000000..76731e2 --- /dev/null +++ b/skills/writing-openrewrite-recipes/references/example-scanning-recipe.java @@ -0,0 +1,294 @@ +package com.yourorg; + +import lombok.EqualsAndHashCode; +import lombok.Value; +import org.openrewrite.*; +import org.openrewrite.java.JavaIsoVisitor; +import org.openrewrite.java.tree.J; +import org.openrewrite.marker.SearchResult; + +import java.util.HashMap; +import java.util.Map; + +/** + * A ScanningRecipe that marks classes only if the project uses a specific type. + * + * This example demonstrates: + * - ScanningRecipe with accumulator pattern + * - Three-phase execution: scan, generate (optional), edit + * - Tracking per-project information with Map + * - Using accumulator data to inform editing decisions + * - Proper handling of multi-module projects + * + * Use ScanningRecipe when you need to: + * - See all files before making changes + * - Generate new files based on analysis + * - Share data across multiple files + * - Make decisions based on project-wide information + */ +@Value +@EqualsAndHashCode(callSuper = false) +public class ScanningRecipeExample extends ScanningRecipe { + + /** + * The accumulator stores data collected during the scanning phase. + * This data is then available during the editing phase. + * + * Important: For multi-module projects, track data per JavaProject. + */ + public static class Accumulator { + // Track which projects use the target type + Map projectUsesTargetType = new HashMap<>(); + + // You can store any data structure you need + // Map> projectClasses = new HashMap<>(); + // Map> projectMethods = new HashMap<>(); + } + + @Override + public String getDisplayName() { + return "Mark classes in projects using target type"; + } + + @Override + public String getDescription() { + return "Marks classes with SearchResult only if the project uses a specific type."; + } + + /** + * Initialize the accumulator before scanning begins. + */ + @Override + public Accumulator getInitialValue(ExecutionContext ctx) { + return new Accumulator(); + } + + /** + * Phase 1: SCANNING + * + * The scanner visits all source files and collects information + * into the accumulator. No changes are made in this phase. + */ + @Override + public TreeVisitor getScanner(Accumulator acc) { + return new JavaIsoVisitor() { + + @Override + public J.CompilationUnit visitCompilationUnit(J.CompilationUnit cu, ExecutionContext ctx) { + // Get the JavaProject marker to track per-project data + JavaProject project = cu.getMarkers().findFirst(JavaProject.class).orElse(null); + if (project == null) { + return cu; + } + + // Initialize project tracking if needed + acc.projectUsesTargetType.putIfAbsent(project, false); + + // Scan for the target type in this file + // In this example, we're looking for usage of java.util.Optional + cu.getImports().stream() + .filter(imp -> imp.getTypeName().equals("java.util.Optional")) + .findFirst() + .ifPresent(imp -> acc.projectUsesTargetType.put(project, true)); + + // Continue scanning subtree + return super.visitCompilationUnit(cu, ctx); + } + + @Override + public J.Import visitImport(J.Import import_, ExecutionContext ctx) { + // You can also scan at finer granularity + // Example: track specific imports, method calls, etc. + return import_; + } + }; + } + + /** + * Phase 2: GENERATING (optional) + * + * This phase is used to generate new source files based on the + * accumulated data. Return null if no new files are needed. + * + * Uncomment to implement: + */ + /* + @Override + public Collection generate(Accumulator acc, ExecutionContext ctx) { + List newFiles = new ArrayList<>(); + + // Example: Generate a file for each project that uses the target type + for (Map.Entry entry : acc.projectUsesTargetType.entrySet()) { + if (entry.getValue()) { + JavaProject project = entry.getKey(); + // Create a new source file + // newFiles.add(createNewFile(project)); + } + } + + return newFiles; + } + */ + + /** + * Phase 3: EDITING + * + * The editor visits all source files again and makes changes + * based on the data collected in the scanning phase. + */ + @Override + public TreeVisitor getVisitor(Accumulator acc) { + return new JavaIsoVisitor() { + + @Override + public J.CompilationUnit visitCompilationUnit(J.CompilationUnit cu, ExecutionContext ctx) { + // Get the project for this file + JavaProject project = cu.getMarkers().findFirst(JavaProject.class).orElse(null); + if (project == null) { + return cu; + } + + // Check the accumulator to see if this project uses the target type + Boolean usesTargetType = acc.projectUsesTargetType.get(project); + if (usesTargetType == null || !usesTargetType) { + // Don't make changes in projects that don't use the target type + return cu; + } + + // This project uses the target type, continue with editing + return super.visitCompilationUnit(cu, ctx); + } + + @Override + public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) { + J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, ctx); + + // Get the project + JavaProject project = getCursor() + .firstEnclosing(J.CompilationUnit.class) + .getMarkers() + .findFirst(JavaProject.class) + .orElse(null); + + if (project == null) { + return cd; + } + + // Only mark classes in projects that use the target type + Boolean usesTargetType = acc.projectUsesTargetType.get(project); + if (usesTargetType != null && usesTargetType) { + // Mark this class with a SearchResult + return SearchResult.found(cd, "Found in project using Optional"); + } + + return cd; + } + }; + } +} + +// ============================================================ +// SIMPLIFIED EXAMPLE: COUNT CLASSES +// ============================================================ + +/* +Here's a simpler ScanningRecipe that counts classes per project: + +@Value +@EqualsAndHashCode(callSuper = false) +public class CountClasses extends ScanningRecipe { + + public static class Accumulator { + Map classCounts = new HashMap<>(); + } + + @Override + public String getDisplayName() { + return "Count classes per project"; + } + + @Override + public String getDescription() { + return "Counts the number of classes in each project."; + } + + @Override + public Accumulator getInitialValue(ExecutionContext ctx) { + return new Accumulator(); + } + + @Override + public TreeVisitor getScanner(Accumulator acc) { + return new JavaIsoVisitor() { + @Override + public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration cd, ExecutionContext ctx) { + JavaProject project = getCursor() + .firstEnclosing(J.CompilationUnit.class) + .getMarkers() + .findFirst(JavaProject.class) + .orElse(null); + + if (project != null) { + acc.classCounts.merge(project, 1, Integer::sum); + } + + return cd; + } + }; + } + + @Override + public TreeVisitor getVisitor(Accumulator acc) { + // Print the results + return new JavaIsoVisitor() { + private boolean printed = false; + + @Override + public J.CompilationUnit visitCompilationUnit(J.CompilationUnit cu, ExecutionContext ctx) { + if (!printed) { + System.out.println("Class counts by project:"); + acc.classCounts.forEach((project, count) -> + System.out.println(project.getProjectName() + ": " + count + " classes") + ); + printed = true; + } + return cu; + } + }; + } +} +*/ + +// ============================================================ +// KEY TAKEAWAYS +// ============================================================ + +/* +1. ScanningRecipe has THREE phases: + - Scan: Collect data (no changes) + - Generate: Create new files (optional) + - Edit: Make changes based on collected data + +2. Always track per-project data with Map + - Don't assume single project per repository + - Get JavaProject from markers + +3. Accumulator is shared across all phases + - Use it to pass data from scan to edit + - Keep it simple and focused + +4. Scanner makes NO changes + - Only collect information + - Mark files or store data + +5. Editor uses accumulator data + - Make informed decisions + - Can access all collected information + +6. When multiple ScanningRecipes are in a recipe list: + - All scanners run first + - Then all generators run + - Then all editors run + - Scanners see state before ANY edits + - But scanners DO see generated files +*/ diff --git a/skills/writing-openrewrite-recipes/references/recipes-all.csv b/skills/writing-openrewrite-recipes/references/recipes-all.csv new file mode 100644 index 0000000..212bd27 --- /dev/null +++ b/skills/writing-openrewrite-recipes/references/recipes-all.csv @@ -0,0 +1,4958 @@ +id,name,description,artifact +org.openrewrite.node.migrate.util.use-native-type-checking-methods,Replace deprecated `util.isX()` methods with native JavaScript,The `util` module's type-checking methods have been removed in Node 22.,:@openrewrite/recipes-nodejs: +org.openrewrite.java.logging.containerized.ContainerizeLog4j2PropertiesConfiguration,Containerize Log4j2 Properties configuration,Transforms Log4j2 Properties configuration to write logs to stdout instead of files suitable for containerized environments.,io.moderne.recipe:rewrite-containerized-logging:0.1.0-20251019.170238-104 +org.openrewrite.java.logging.containerized.ContainerizeLog4j2XmlConfiguration,Containerize Log4j2 XML configuration,Transforms Log4j2 XML configuration to write logs to stdout instead of files suitable for containerized environments.,io.moderne.recipe:rewrite-containerized-logging:0.1.0-20251019.170238-104 +org.openrewrite.java.logging.containerized.ContainerizeLog4j2YamlConfiguration,Containerize Log4j2 YAML configuration,Transforms Log4j2 YAML configuration to write logs to stdout instead of files suitable for containerized environments. (Implementation in progress),io.moderne.recipe:rewrite-containerized-logging:0.1.0-20251019.170238-104 +org.openrewrite.java.logging.containerized.ContainerizeLogbackConfiguration,Containerize Logback configuration,Transforms Logback XML configuration to write logs to stdout instead of files suitable for containerized environments.,io.moderne.recipe:rewrite-containerized-logging:0.1.0-20251019.170238-104 +org.openrewrite.java.logging.containerized.ReplaceFileLoggingWithStdout,Replace file logging with stdout,Transforms direct file writing operations (FileWriter PrintWriter FileOutputStream) to use System.out instead suitable for containerized environments.,io.moderne.recipe:rewrite-containerized-logging:0.1.0-20251019.170238-104 +org.openrewrite.java.logging.containerized.ContainerizeLogging,Containerize logging configuration,Transforms logging configurations to write to stdout instead of files making them suitable for containerized environments. This composite recipe applies transformations for multiple logging frameworks including Log4j2 Logback Log4j 1.x and Java Util Logging. ,io.moderne.recipe:rewrite-containerized-logging:0.1.0-20251019.170238-104 +org.openrewrite.java.logging.containerized.log4j2.ContainerizeLog4j2,Containerize Log4j2 configuration,Transforms all Log4j2 configuration formats (XML Properties YAML JSON) to write logs to stdout instead of files. ,io.moderne.recipe:rewrite-containerized-logging:0.1.0-20251019.170238-104 +org.openrewrite.java.logging.containerized.logback.ContainerizeLogback,Containerize Logback configuration,Transforms Logback XML configuration files (logback.xml logback-spring.xml) to write logs to stdout instead of files. ,io.moderne.recipe:rewrite-containerized-logging:0.1.0-20251019.170238-104 +io.moderne.cryptography.FindRSAKeyGenParameters,Find RSA key generation parameters,Finds RSAKeyGenParameterSpec instantiations and extracts their parameter values into a data table.,io.moderne.recipe:rewrite-cryptography:0.11.0-20251021.170654-11 +io.moderne.cryptography.FindSSLSocketParameters,Find SSL socket configuration parameters,Finds SSLSocket setter method invocations and extracts their parameter values into a data table.,io.moderne.recipe:rewrite-cryptography:0.11.0-20251021.170654-11 +io.moderne.cryptography.FindSecurityModifications,Find Security class modifications,Finds invocations of java.security.Security methods that modify security configuration such as removeProvider addProvider insertProviderAt setProperty and removeProperty.,io.moderne.recipe:rewrite-cryptography:0.11.0-20251021.170654-11 +io.moderne.cryptography.FindSecuritySetProperties,Find `Security.setProperty(..)` calls for certain properties,There is a defined set of properties that should not be set using `Security.setProperty(..)` as they can lead to security vulnerabilities.,io.moderne.recipe:rewrite-cryptography:0.11.0-20251021.170654-11 +io.moderne.cryptography.PostQuantumCryptography,Post quantum cryptography,This recipe searches for instances in code that may be impacted by post quantum cryptography. Applications may need to support larger key sizes different algorithms or use crypto agility to handle the migration. The recipe includes detection of hardcoded values that affect behavior in a post-quantum world programmatic configuration that may prevent algorithm changes and general cryptographic usage patterns that should be reviewed.,io.moderne.recipe:rewrite-cryptography:0.11.0-20251021.170654-11 +io.moderne.devcenter.JUnitJupiterUpgrade,Move to JUnit 6,Move to JUnit Jupiter.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.JavaVersionUpgrade,Move to a later Java version,Determine the current state of a repository relative to a desired Java version upgrade.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.LibraryUpgrade,Library upgrade,Determine the current state of a repository relative to a desired library upgrade.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.ParentPomUpgrade,Parent POM upgrade,Determine the current state of a repository relative to a desired parent POM upgrade.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.ReportAsSecurityIssues,Report as security issues,Look for results produced by recipes in the same recipe list that this recipe is part of and report them as security issues in DevCenter.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.QuarkusDevCenter,DevCenter for Quarkus,A DevCenter that tracks the latest Quarkus framework versions and applies best practices. This DevCenter includes recipes to upgrade Quarkus versions migrate from deprecated APIs and ensure compatibility with the latest Java versions and testing frameworks.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.UpgradeQuarkus3_x,Upgrade to Quarkus 3.26,Upgrades Quarkus dependencies to version 3.26.x including core extensions and tooling.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.UpgradeQuarkusUniverseBom,Upgrade Quarkus Universe BOM,Upgrades the Quarkus Universe BOM parent to the latest version.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.ApacheDevCenter,DevCenter for Apache,A DevCenter that tracks the latest Apache Maven parent POM versions and applies best practices.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.ApacheMavenDevCenter,DevCenter for Apache Maven,A DevCenter that tracks the latest Apache Maven parent POM versions and applies best practices. This DevCenter includes recipes to upgrade the parent POMs of Apache Maven as well as a collection of best practices for Maven POMs.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.UpgradeApacheParent,Upgrade Apache Parent POM,Upgrades the Apache parent POM to the latest version.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.UpgradeMavenParent,Upgrade Apache Maven Parent,Upgrades the Apache Maven parent POM to the latest version.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.UpgradeMavenPluginsParent,Upgrade Apache Maven Parent,Upgrades the Apache Maven parent POM to the latest version.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.UpgradeMavenSharedParent,Upgrade Apache Maven Parent,Upgrades the Apache Maven parent POM to the latest version.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.ApacheMavenBestPractices,Apache Maven best practices,A collection of recipes that apply best practices to Maven POMs. Some of these recipes affect build stability so they are reported as security issues in the DevCenter card.,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.DevCenterStarter,DevCenter,This is a default DevCenter configuration that can be used as a starting point for your own DevCenter configuration. It includes a combination of upgrades migrations and security fixes. You can customize this configuration to suit your needs. For more information on how to customize your DevCenter configuration see the [DevCenter documentation](https://docs.moderne.io/administrator-documentation/moderne-platform/how-to-guides/recipe-based-devcenter-beta/).,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.devcenter.SecurityStarter,OWASP top ten,This recipe is a starter card to reveal common OWASP Top 10 issues in your source code. You can customize this configuration to suit your needs. For more information on how to customize your DevCenter configuration see the [DevCenter documentation](https://docs.moderne.io/administrator-documentation/moderne-platform/how-to-guides/recipe-based-devcenter-beta/).,io.moderne.recipe:rewrite-devcenter:1.11.0-20251021.170730-11 +io.moderne.elastic.elastic9.ChangeApiNumericFieldType,Change numeric field type with conversion,Adds conversion methods with null checks for numeric type changes in Elasticsearch 9 API,io.moderne.recipe:rewrite-elastic:0.4.0-20251021.171041-11 +io.moderne.elastic.elastic9.MigrateDenseVectorElementType,Migrate DenseVectorProperty.elementType from String to DenseVectorElementType enum,In Elasticsearch 9 `DenseVectorProperty.elementType()` returns `DenseVectorElementType` enum instead of `String` and the builder method `elementType(String)` now accepts the enum type. This recipe handles both builder calls and getter calls.,io.moderne.recipe:rewrite-elastic:0.4.0-20251021.171041-11 +io.moderne.elastic.elastic9.MigrateDenseVectorSimilarity,Migrate DenseVectorProperty.similarity from String to DenseVectorSimilarity enum,In Elasticsearch 9 `DenseVectorProperty.similarity()` returns `DenseVectorSimilarity` enum instead of `String` and the builder method `similarity(String)` now accepts the enum type. This recipe handles both builder calls and getter calls.,io.moderne.recipe:rewrite-elastic:0.4.0-20251021.171041-11 +io.moderne.elastic.elastic9.MigrateMatchedQueries,Migrate `matchedQueries` from List to Map,In Elasticsearch Java Client 9.0 `Hit.matchedQueries()` changed from returning `List` to `Map`. This recipe migrates the usage by adding `.keySet()` for iterations and using `new ArrayList<>(result.keySet())` for assignments.,io.moderne.recipe:rewrite-elastic:0.4.0-20251021.171041-11 +io.moderne.elastic.elastic9.MigrateScriptSource,Migrate script source from String to Script/ScriptSource,Migrates `Script.source(String)` calls to use `ScriptSource.scriptString(String)` wrapper in Elasticsearch Java client 9.x.,io.moderne.recipe:rewrite-elastic:0.4.0-20251021.171041-11 +io.moderne.elastic.elastic9.MigrateSpanTermQueryValue,Migrate `SpanTermQuery.value()` from String to FieldValue,In Elasticsearch 9 `SpanTermQuery.value()` returns a `FieldValue` instead of `String`. This recipe updates calls to handle the new return type by checking if it's a string and extracting the string value.,io.moderne.recipe:rewrite-elastic:0.4.0-20251021.171041-11 +io.moderne.elastic.elastic9.RenameApiField,Rename `Elasticsearch valueBody()` methods,In Elasticsearch Java Client 9.0 the generic `valueBody()` method and `valueBody(...)` builder methods have been replaced with specific getter and setter methods that better reflect the type of data being returned. Similarly for `GetRepositoryResponse` the `result` field also got altered to `repositories`.,io.moderne.recipe:rewrite-elastic:0.4.0-20251021.171041-11 +io.moderne.elastic.elastic9.UseNamedValueParameters,Use NamedValue parameters instead of Map,Migrates `indicesBoost` and `dynamicTemplates` parameters from `Map` to `NamedValue` in Elasticsearch Java client 9.x.,io.moderne.recipe:rewrite-elastic:0.4.0-20251021.171041-11 +io.moderne.elastic.elastic9.MigrateToElasticsearch9,Migrate from Elasticsearch 8 to 9,This recipe performs a comprehensive migration from Elasticsearch 8 to Elasticsearch 9 addressing breaking changes API removals deprecations and required code modifications.,io.moderne.recipe:rewrite-elastic:0.4.0-20251021.171041-11 +io.moderne.elastic.elastic9.RenameApiFields,Rename API fields for Elasticsearch 9,Renames various API response fields from `valueBody` to align with Elasticsearch 9 specifications.,io.moderne.recipe:rewrite-elastic:0.4.0-20251021.171041-11 +io.moderne.elastic.elastic9.ChangeApiNumericFieldTypes,Change numeric field types for Elasticsearch 9,Handles changes between different numeric types (`Long` to `Integer` `int` to `Long`...) in Elasticsearch 9 API responses by adding appropriate conversion methods with null checks.,io.moderne.recipe:rewrite-elastic:0.4.0-20251021.171041-11 +io.moderne.hibernate.search.FindJPQLDefinitions,Find JPQL definitions,Find Java Persistence Query Language definitions in the codebase.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update66.FixConflictingClassTypeAnnotations,Fix conflicting class type annotation Hibernate 6.6,Since Hibernate 6.6 a mapped class can have *either* `@MappedSuperclass` or `@Embeddable` or `@Entity`. This recipe removes `@Entity` from classes annotated with `@MappedSuperclass` or `@Embeddable`. For the moment die combination of `@MappedSuperclass` or `@Embeddable` is advised to migrate to [Single Table Inheritance](https://docs.jboss.org/hibernate/orm/6.6/userguide/html_single/Hibernate_User_Guide.html#entity-inheritance-single-table) but still accepted and therefore stays.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.AddCascadePersistToIdMappedAssociations,Migrate implicit cascade=PERSIST for @Id and @MapsId associations,Hibernate used to automatically enable cascade=PERSIST for association fields annotated @Id or @MapsId. This was undocumented and unexpected behavior and no longer supported in Hibernate 7. Existing code which relies on this behavior will be modified by addition of explicit cascade=PERSIST to the association fields.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.CompositeUserTypeSessionFactoryImplementor,Remove leaking of SessionFactoryImplementor from `org.hibernate.usertype.CompositeUserType` invocations and implementations,Remove leaking of SessionFactoryImplementor from `org.hibernate.usertype.CompositeUserType` invocations and implementations.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.MigrateConfigurableToGeneratorCreationContext,Migrate `Configurable.configure()` to use `GeneratorCreationContext`,In Hibernate 7.0 `Configurable.configure()` now takes a `GeneratorCreationContext` parameter instead of `ServiceRegistry`. This recipe migrates method signatures and call sites.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.MigrateIntegratorMethod,Migrate Hibernate `Integrator#integrate` method,Migrate Hibernate `Integrator#integrate` method from deprecated signature to Hibernate 7 compatible signature. Changes `integrate(Metadata SessionFactoryImplementor SessionFactoryServiceRegistry)` to `integrate(Metadata BootstrapContext SessionFactoryImplementor)`.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.MigrateJdbcTypeToJdbcTypeCode,Migrate @JdbcType to @JdbcTypeCode,In Hibernate 7.0 various JDBC types were moved to internal packages. Use @JdbcTypeCode with SqlTypes constants instead of @JdbcType with specific classes.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.MigrateLockOptionsToDirectParameters,Migrate LockOptions to direct parameters,Migrates deprecated `LockOptions` usage to direct parameters in method calls. As of JPA 3.2 and Hibernate 7 `LockMode` `Timeout` and `PessimisticLockScope` are passed directly to `find()` `refresh()` and `lock()` methods instead of being wrapped in a `LockOptions` object.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.MigrateMetamodelImplementor,Migrate `MetamodelImplementor` to Hibernate 7.0,In Hibernate 7.0 `MetamodelImplementor` has been split into `MappingMetamodel` for ORM-specific operations and `JpaMetamodel` for JPA-standard operations. This recipe migrates the usage based on which methods are called.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.MigrateNaturalIdLoadAccess,Migrate NaturalIdLoadAccess method calls,Migrates NaturalIdLoadAccess#using(Object...) to using(Map.of(...)) variants for Hibernate 7.0.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.MigrateNaturalIdMultiLoadAccess,Migrate NaturalIdMultiLoadAccess method calls,Migrates NaturalIdMultiLoadAccess#compoundValue(Object...) to Map.of(...) variants for Hibernate 7.0.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.MigrateSessionInterface,Migrate Session interface method calls,Migrates code using deprecated Session interface methods to their Hibernate 7.0 replacements.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.MigrateSessionToDeferToJPA,Migrate Session save/update/delete method calls,Migrates code using deprecated Session load/get/refresh/save/update/delete methods to their Hibernate 7.0 replacements.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.MigrateSetFlushModeToSetQueryFlushMode,Migrate `setFlushMode()` to `setQueryFlushMode()`,In Hibernate 7.0 `CommonQueryContract.setFlushMode(FlushModeType)` has been replaced with `setQueryFlushMode(QueryFlushMode)`. This recipe migrates the method call and converts `FlushModeType` parameters to their `QueryFlushMode` equivalents.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.MigrateToTargetEmbeddable,Migrate to @TargetEmbeddable,Migrates code using removed @Target to to Hibernate 7.0's @TargetEmbeddable equivalent. Removes misused @Target annotations.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.RemoveUnnecessaryCastToSession,Remove unnecessary cast to `Session` for `SessionFactory.createEntityManager()`,In Hibernate 7.0 `SessionFactory.createEntityManager()` explicitly returns Session making casts to Session unnecessary.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.ReplaceHibernateWithJakartaAnnotations,Replace hibernate annotations with Jakarta variants,Tries to replaces annotations that have been removed in Hibernate 7.0 with its Jakarta equivalent such as Table @Where @OrderBy etc. If a annotation is used with arguments that do not have a direct replacement the annotation is not replaced at all.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.ReplaceSessionLockRequest,Replace Session.buildLockRequest with LockOptions,Migrates Session.buildLockRequest(LockOptions.X) calls to use session.lock(entity new LockOptions(LockMode.X)) in Hibernate 7.0.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.UnboxingTransactionTimeout,Null safe Transaction#getTimeout(),JPA 3.2 adds `#getTimeout` but uses `Integer` whereas Hibernate has historically used `int`. Note that this raises the possibility of a `NullPointerException` during migration if e.g. performing direct comparisons on the timeout value against an in (auto unboxing). This recipe adds ternary operators where `Transaction#getTimeout()` is used and a negative value will be used if the `getTimeout()` resulted in a null value.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.UserTypeNullSafeGetSharedSessionContractImplementorRecipe,Remove leaking of SharedSessionContractImplementor from `org.hibernate.usertype.UserType` invocations,Remove leaking of SharedSessionContractImplementor from `org.hibernate.usertype.UserType` invocations.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.UserTypeSharedSessionContractImplementor,Remove leaking of SharedSessionContractImplementor from `org.hibernate.usertype.UserType` implementations,Remove leaking of SharedSessionContractImplementor from `org.hibernate.usertype.UserType` implementations.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update66.RemoveTableFromInheritedEntity,Remove table from single table inherited entity,For Single Table Inherited Entities Hibernate ignores the `@Table` annotation on child entities. From Version 6.6 it is considered an error.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.MigrateToHibernate70,Migrate to Hibernate 7.0.x,This recipe will apply changes commonly needed when migrating to Hibernate 7.0.x.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update70.MigrateToHibernate7JFR,Migrate to Hibernate 7 JFR APIs,Migrates deprecated JFR integration APIs to their Hibernate 7 replacements. `EventManager` becomes `EventMonitor` and `HibernateMonitoringEvent` becomes `DiagnosticEvent`.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.MigrateToHibernate66,Migrate to Hibernate 6.6.x,This recipe will apply changes commonly needed when migrating to Hibernate 6.6.x.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.hibernate.update66.MigrateCascadeTypes,Migrate Hibernate CascadeType constants,Moving away from deprecated Hibernate CascadeType constants. CascadeType.SAVE_UPDATE -> CascadeType.PERSIST and/or CascadeType.MERGE CascadeType.DELETE -> CascadeType.REMOVE.,io.moderne.recipe:rewrite-hibernate:0.14.0-20251021.170654-12 +io.moderne.kafka.MigrateAlterConfigsToIncrementalAlterConfigs,Migrate `AdminClient.alterConfigs()` to `incrementalAlterConfigs()`,Migrates the removed `AdminClient.alterConfigs()` method to `incrementalAlterConfigs()` for Kafka 4.0 compatibility.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateConsumerCommittedToSet,Migrate `KafkaConsumer.committed(TopicPartition)` to `committed(Set)`,Migrates from the removed `KafkaConsumer.committed(TopicPartition)` to `committed(Set)` for Kafka 4.0 compatibility. Converts single `TopicPartition` arguments to `Collections.singleton()` calls.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateConsumerPollToDuration,Migrate `KafkaConsumer.poll(long)` to `poll(Duration)`,Migrates from the deprecated `KafkaConsumer.poll(long)` to `poll(Duration)` for Kafka 4.0 compatibility. Converts millisecond timeout values to `Duration.ofMillis()` calls.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateSendOffsetsToTransaction,Migrate deprecated `sendOffsetsToTransaction` to use `ConsumerGroupMetadata`,Migrates from the deprecated `KafkaProducer.sendOffsetsToTransaction(Map String)` to `sendOffsetsToTransaction(Map ConsumerGroupMetadata)` for Kafka 4.0 compatibility. This recipe uses a conservative approach with `new ConsumerGroupMetadata(groupId)`.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.RemoveDeprecatedKafkaProperties,Remove deprecated Kafka property,Removes a specific Kafka property that is no longer supported in Kafka 4.0.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.streams.MigrateKStreamToTable,Migrate KStream to KTable conversion to use `toTable()` method,In Kafka Streams 2.5 a new `toTable()` method was added to simplify converting a KStream to a KTable. This recipe replaces the manual aggregation pattern `.groupByKey().reduce((oldVal newVal) -> newVal)` with the more concise `.toTable()` method.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.streams.MigrateKafkaStreamsStoreMethod,Migrate deprecated `KafkaStreams#store` method,In Kafka Streams 2.5 the method `KafkaStreams#store(String storeName QueryableStoreType storeType)` was deprecated. It only allowed querying active stores and did not support any additional query options. Use the new `StoreQueryParameters` API instead.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.streams.MigrateRetryConfiguration,Migrate deprecated retry configuration to task timeout,In Kafka 2.7 `RETRIES_CONFIG` and `RETRY_BACKOFF_MS_CONFIG` were deprecated in favor of `TASK_TIMEOUT_MS_CONFIG`. This recipe migrates the old retry configuration to the new task timeout configuration attempting to preserve the retry budget by multiplying retries × backoff time. If only one config is present it falls back to 60000ms (1 minute).,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.streams.MigrateStreamsUncaughtExceptionHandler,Migrate to StreamsUncaughtExceptionHandler API,Migrates from the JVM-level Thread.UncaughtExceptionHandler to Kafka Streams' StreamsUncaughtExceptionHandler API introduced in version 2.8. This new API provides explicit control over how the Streams client should respond to uncaught exceptions (REPLACE_THREAD SHUTDOWN_CLIENT or SHUTDOWN_APPLICATION).,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.streams.MigrateTaskMetadataTaskId,Migrate `TaskMetadata.taskId()` to return `TaskId`,In Kafka Streams 3.0 `TaskMetadata.taskId()` changed its return type from `String` to `TaskId`. This recipe adds `.toString()` calls where necessary to maintain String compatibility.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.streams.MigrateWindowStorePutMethod,Migrate `WindowStore.put()` to include timestamp,In Kafka Streams 2.4 `WindowStore.put()` requires a timestamp parameter. This recipe adds `context.timestamp()` as the third parameter.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.streams.RemovePartitionGrouperConfiguration,Remove `PartitionGrouper` configuration,Starting with Kafka Streams 2.4 the `PartitionGrouper` API was deprecated and partition grouping is now fully handled internally by the library. This recipe removes the deprecated `PARTITION_GROUPER_CLASS_CONFIG` configuration.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateToKafka33,Migrate to Kafka 3.3,Migrate applications to the latest Kafka 3.3 release.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateToKafka40,Migrate to Kafka 4.0,Migrate applications to the latest Kafka 4.0 release. This includes updating dependencies to 4.0.x ensuring Java 11+ for clients and Java 17+ for brokers/tools and handling changes.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.UpgradeJavaForKafkaClients,Upgrade Java to 11+ for Kafka clients,Ensures Java 11 or higher is used when Kafka client libraries are present.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.UpgradeJavaForKafkaBroker,Upgrade Java to 17+ for Kafka broker/tools,Ensures Java 17 or higher is used when Kafka broker or tools dependencies are present.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateConsumerGroupStateToGroupState,Migrate `ConsumerGroupState` to `GroupState`,Migrates from the deprecated `ConsumerGroupState` to `GroupState` for Kafka 4.0 compatibility. `ConsumerGroupState` was deprecated in favor of `GroupState` which supports both consumer groups and share groups.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateToKafka28,Migrate to Kafka 2.8,Migrate applications to the latest Kafka 2.8 release.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateToKafka31,Migrate to Kafka 3.1,Migrate applications to the latest Kafka 3.1 release.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateToKafka23,Migrate to Kafka 2.3,Migrate applications to the latest Kafka 2.3 release.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.streams.MigrateJoinedNameMethod,Migrate `Joined.named()` to `Joined.as()`,In Kafka Streams 2.3 `Joined.named()` was deprecated in favor of `Joined.as()`. Additionally the `name()` method was deprecated for removal and should not be used.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateToKafka27,Migrate to Kafka 2.7,Migrate applications to the latest Kafka 2.7 release.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateToKafka24,Migrate to Kafka 2.4,Migrate applications to the latest Kafka 2.4 release.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateToKafka25,Migrate to Kafka 2.5,Migrate applications to the latest Kafka 2.5 release.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateToKafka26,Migrate to Kafka 2.6,Migrate applications to the latest Kafka 2.6 release.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.streams.ProcessingGuaranteeExactlyOnceToBeta,Migrate `exactly_once` to `exactly_once_beta`,Kafka Streams 2.6 introduces the exactly-once semantics v2 which is a more efficient implementation with improved internal handling. Though it is beta it’s fully backward-compatible from the API standpoint but internally it uses a different transaction/commit protocol. Starting from 3.0 it becomes the default "exactly_once_v2".,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateToKafka30,Migrate to Kafka 3.0,Migrate applications to the latest Kafka 3.0 release.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.streams.ProcessingGuaranteeExactlyOnceToV2,Migrate `exactly_once` and `exactly_once_beta` to `exactly_once_v2`,Kafka Streams 2.6 introduces the exactly-once semantics v2 which is a more efficient implementation with improved internal handling. Starting from 3.0 it becomes the default "exactly_once_v2".,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.streams.MigrateTaskAndThreadMetadata,Migrate TaskMetadata and ThreadMetadata,Migrates TaskMetadata and ThreadMetadata from org.apache.kafka.streams.processor package to org.apache.kafka.streams package and updates TaskMetadata.taskId() calls to include .toString() for String compatibility.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateToKafka41,Migrate to Kafka 4.1,Migrate applications to the latest Kafka 4.1 release. This includes updating dependencies to 4.1.x migrating deprecated Admin API methods updating Streams configuration properties and removing deprecated broker properties.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateAdminListConsumerGroups,Migrate `Admin.listConsumerGroups()` to `listGroups()`,Migrates the deprecated `Admin.listConsumerGroups()` method to `listGroups()` and updates related types for Kafka 4.1 compatibility.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +io.moderne.kafka.MigrateToKafka32,Migrate to Kafka 3.2,Migrate applications to the latest Kafka 3.2 release.,io.moderne.recipe:rewrite-kafka:0.4.0-20251021.170844-11 +org.openrewrite.analysis.java.FindNullPointerIssues,Find null pointer issues,Detects potential null pointer dereferences using path-sensitive analysis to distinguish between definite NPEs possible NPEs and safe dereferences.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +org.openrewrite.analysis.java.controlflow.FindUnusedDefinitions,Find unused variable definitions,Identifies variable assignments whose values are never used before being overwritten.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +org.openrewrite.analysis.java.controlflow.search.FindCyclomaticComplexity,Find cyclomatic complexity,Calculates the cyclomatic complexity of methods and produces a data table containing the class name method name argument types complexity value and complexity threshold.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +org.openrewrite.analysis.java.controlflow.search.FindUnreachableCode,Find unreachable code,Uses control flow analysis to identify statements that can never be executed.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +org.openrewrite.analysis.java.dataflow.FindDeadStores,Find dead stores,Identifies variable assignments whose values are never used before being overwritten or going out of scope.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +org.openrewrite.analysis.java.security.FindSecurityVulnerabilities,Find security vulnerabilities using taint analysis,Identifies potential security vulnerabilities where untrusted data from sources flows to sensitive sinks without proper sanitization.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +org.openrewrite.analysis.java.datalineage.TrackDataLineage,Track data lineage,Tracks the flow of data from database sources (JDBC queries JPA entities) to API sinks (REST endpoints GraphQL mutations) to understand data dependencies and support compliance requirements.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +org.openrewrite.analysis.java.privacy.FindPiiExposure,Find PII exposure in logs and external APIs,Detects when Personally Identifiable Information (PII) is exposed through logging statements or sent to external APIs without proper sanitization. This helps prevent data leaks and ensures compliance with privacy regulations like GDPR and CCPA.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +org.openrewrite.analysis.java.security.FindCommandInjection,Find command injection vulnerabilities,Detects when user-controlled input flows into system command execution methods like Runtime.exec() or ProcessBuilder which could allow attackers to execute arbitrary commands.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +org.openrewrite.analysis.java.security.FindLdapInjection,Find LDAP injection vulnerabilities,Finds LDAP injection vulnerabilities by tracking tainted data flow from user input to LDAP queries.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +org.openrewrite.analysis.java.security.FindPathTraversal,Find path traversal vulnerabilities,Detects potential path traversal vulnerabilities where user input flows to file system operations without proper validation.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +org.openrewrite.analysis.java.security.FindSqlInjection,Find SQL injection vulnerabilities,Detects potential SQL injection vulnerabilities where user input flows to SQL execution methods without proper sanitization.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +org.openrewrite.analysis.java.security.FindUnencryptedPiiStorage,Find unencrypted PII storage,Identifies when personally identifiable information (PII) is stored in databases files or other persistent storage without encryption.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +org.openrewrite.analysis.java.security.FindXssVulnerability,Find XSS vulnerabilities,Detects potential cross-site scripting vulnerabilities where user input flows to output methods without proper sanitization.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +org.openrewrite.analysis.java.security.FindXxeVulnerability,Find XXE vulnerabilities,Locates XML parsers that are not configured to prevent XML External Entity (XXE) attacks.,io.moderne.recipe:rewrite-program-analysis:0.6.0-20251021.170722-51 +io.moderne.java.spring.boot3.AddValidToConfigurationPropertiesFields,Add `@Valid` annotation to fields,In Spring Boot 3.4 validation of `@ConfigurationProperties` classes annotated with `@Validated` now follows the Bean Validation specification only cascading to nested properties if the corresponding field is annotated with `@Valid`. The recipe will add a `@Valid` annotation to each field which has a type that has a field which is annotated with a `jakarta.validation.constraints.*` annotation.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.CommentOnMockAndSpyBeansInConfigSpring34,Comment on `@MockitoSpyBean` and `@MockitoBean` in `@Configuration`,As stated in [Spring Docs](https://docs.spring.io/spring-framework/reference/testing/annotations/integration-spring/annotation-mockitobean.html) `@MockitoSpyBean` and `@MockitoBean` will only work in tests explicitly not in `@Configuration` annotated classes.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.ConditionalOnAvailableEndpointMigrationSpring34,Migrate `ConditionalOnAvailableEndpoint` for Spring Boot 3.4,Migrate `@ConditionalOnAvailableEndpoint(EndpointExposure.CLOUD_FOUNDRY)` to `@ConditionalOnAvailableEndpoint(EndpointExposure.WEB)` for Spring Boot 3.4.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.MigrateEndpointAnnotationAccessValueSpring34,Migrate `@Endpoint`s `defaultAccess` value,Since Spring Boot 3.4 the `@Endpoint` access configuration values are no longer `true|false` but `none|read-only|unrestricted`.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.RemoveDeprecatedConditions,Remove Spring Boot 3.5 deprecated conditions,Replace Spring Boot 3.5 deprecated condition classes with their corresponding conditional annotations.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.RemoveReplaceNoneFromAutoConfigureTestDatabase,Remove `Replace.NONE` from `@AutoConfigureTestDatabase`,`Replace.NONE` is the default value for `@AutoConfigureTestDatabase` since Spring Boot 3.4.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.RemoveTestRestTemplateEnableRedirectsOptionRecipe,Remove `TestRestTemplate.HttpClientOption.ENABLE_REDIRECTS` option,The `TestRestTemplate` now uses the same follow redirects settings as the regular RestTemplate. The `HttpOption.ENABLE_REDIRECTS` option has also been deprecated. This recipe removes the option from the `TestRestTemplate` constructor arguments.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.ReplaceConditionalOutcomeInverse,Replace ConditionOutcome.inverse() with constructor,Replace deprecated `ConditionOutcome.inverse(ConditionOutcome outcome)` calls with `new ConditionOutcome(!outcome.isMatch() outcome.getConditionMessage())`.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.ReplaceDeprecatedKafkaConnectionDetailsBootstrapServerGetters,Replace deprecated `KafkaConnectionDetails` bootstrap server methods,Replace deprecated `KafkaConnectionDetails` bootstrap server methods with chained calls. For example `getProducerBootstrapServers()` becomes `getProducer().getBootstrapServers()`.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.ReplaceDeprecatedThreadPoolTaskSchedulerConstructor,Replace deprecated ThreadPoolTaskSchedulerBuilder 5-argument constructor,The 5-parameter constructor of `ThreadPoolTaskSchedulerBuilder` has been deprecated in Spring Boot 3.5. This recipe transforms it to use the builder pattern instead omitting null values and defaults.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.ReplaceKafkaTransactionManagerSetter,Use `kafkaAwareTransactionManager` setter,Replace deprecated `ContainerProperties#setTransactionManager(org.springframework.transaction.PlatformTransactionManager)` method with `ContainerProperties#setKafkaAwareTransactionManager(org.springframework.kafka.transaction.KafkaAwareTransactionManager)`. The method will be replaced only if its argument has the type `KafkaAwareTransactionManager`.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.ResolveTaskExecutorFromContext,Replace `taskExecutor` with `applicationTaskExecutor`,Use bean name `applicationTaskExecutor` instead of `taskExecutor` when resolving `TaskExecutor` Bean from application context,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.security6.MigrateAntPathRequestMatcher,Migrate antPathRequestMatcher to pathPatternRequestMatcher,In Spring Security 6.5 `AntPathRequestMatcher` is deprecated in favor of `PathPatternRequestMatcher`. This recipe migrates static method calls and constructor usage to the new pattern.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot.IsLikelyNotSpringBoot,Is likely not a Spring Boot project,Marks the project if it's likely not a Spring Boot project.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot.IsLikelySpringBoot,Is likely a Spring Boot project,Marks the project if it's likely a Spring Boot project.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot.MigrateSpringFrameworkDependenciesToSpringBoot,Migrate Spring Framework Dependencies to Spring Boot,Migrate Spring Framework Dependencies to Spring Boot.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.framework.IsLikelySpringFramework,Is likely a Spring Framework project,Marks the project if it's likely a Spring Framework project.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.framework.beansxml.BeansXmlToConfiguration,Migrate `beans.xml` to Spring Framework configuration class,Converts Java/Jakarta EE `beans.xml` configuration files to Spring Framework `@Configuration` classes.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.framework.webxml.WebXmlToWebApplicationInitializer,Migrate `web.xml` to `WebApplicationInitializer`,Migrate `web.xml` to `WebApplicationInitializer` for Spring applications. This allows for programmatic configuration of the web application context replacing the need for XML-based configuration. This recipe only picks up `web.xml` files located in the `src/main/webapp/WEB-INF` directory to avoid inference with tests.It creates a `WebXmlWebAppInitializer` class in `src/main/java` with respect to submodules if they contain java files.**If it finds an existing `WebXmlWebAppInitializer` it skips the creation**.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.security6.UpgradeSpringSecurity_6_4,Migrate to Spring Security 6.4,Migrate applications to the latest Spring Security 6.4 release. This recipe will modify an application's build files make changes to deprecated/preferred APIs and migrate configuration settings that have changes between versions.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.cloud2022.SpringCloudProperties_2022,Migrate Spring Cloud properties to 2022,Migrate properties found in `application.properties` and `application.yml`.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.cloud2020.SpringCloudProperties_2020,Migrate Spring Cloud properties to 2020,Migrate properties found in `application.properties` and `application.yml`.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.SpringBootProperties_3_4,Migrate `@Endpoint` Security properties to 3.4,Migrate the settings for Spring Boot Management Endpoint Security from `true`|`false` to `read-only`|`none`.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.UpgradeSpringBoot_3_5,Migrate to Spring Boot 3.5,Migrate applications to the latest Spring Boot 3.5 release. This recipe will modify an application's build files make changes to deprecated/preferred APIs and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework Spring Data etc) that are required as part of the migration to Spring Boot 3.5.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.ReplaceTaskExecutorNameByApplicationTaskExecutorName,Use bean name `applicationTaskExecutor` instead of `taskExecutor`,Spring Boot 3.5 removed the bean name `taskExecutor`. Where this bean name is used the recipe replaces the bean name to `applicationTaskExecutor`. This also includes instances where the developer provided their own bean named `taskExecutor`. This also includes scenarios where JSR-250's `@Resource` annotation is used.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot4.SpringBootProperties_4_0,Migrate Spring Boot properties to 4.0,Migrate properties found in `application.properties` and `application.yml`.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.security6.UpgradeSpringSecurity_6_5,Migrate to Spring Security 6.5,Migrate applications to the latest Spring Security 6.5 release. This recipe will modify an application's build files make changes to deprecated/preferred APIs and migrate configuration settings that have changes between versions.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.UpgradeSpringKafka_3_3,Migrate to Spring Kafka 3.3,Migrate applications to the latest Spring Kafka 3.3 release.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.cloud2025.SpringCloudProperties_2025,Migrate Spring Cloud properties to 2025,Migrate properties found in `application.properties` and `application.yml`.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.SpringBoot3BestPractices,Spring Boot 3.5 best practices,Applies best practices to Spring Boot 3.5+ applications.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.cloud2021.SpringCloudProperties_2021,Migrate Spring Cloud properties to 2021,Migrate properties found in `application.properties` and `application.yml`.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot.SpringToSpringBoot,Migrate Spring to Spring Boot,Migrate non Spring Boot applications to the latest compatible Spring Boot release. This recipe will modify an application's build files introducing Maven dependency management for Spring Boot or adding the Gradle Spring Boot build plugin.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.SpringBoot35Deprecations,Migrate Spring Boot 3.5 deprecated classes and methods,Migrate deprecated classes and methods that have been marked for removal in Spring Boot 3.5.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.UpdateOpenTelemetryResourceAttributes,Update OpenTelemetry resource attributes,The `service.group` resource attribute has been deprecated for OpenTelemetry in Spring Boot 3.5. Consider using alternative attributes or remove the deprecated attribute.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.cloud2023.SpringCloudProperties_2023,Migrate Spring Cloud properties to 2023,Migrate properties found in `application.properties` and `application.yml`.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.cloud2024.SpringCloudProperties_2024,Migrate Spring Cloud properties to 2024,Migrate properties found in `application.properties` and `application.yml`.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.UpgradeSpringBoot_3_4,Migrate to Spring Boot 3.4,Migrate applications to the latest Spring Boot 3.4 release. This recipe will modify an application's build files make changes to deprecated/preferred APIs and migrate configuration settings that have changes between versions. This recipe will also chain additional framework migrations (Spring Framework Spring Data etc) that are required as part of the migration to Spring Boot 3.4.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.CommentDeprecations,Comment deprecated methods in Spring 3.4,Spring Boot 3.4 deprecates methods that are not commonly used or need manual interaction.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.UpgradeGradle7Spring34,Upgrade Gradle to 7.6.4+ for Spring Boot 3.4,Spring Boot 3.4 requires Gradle 7.6.4.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.UpgradeGradle8Spring34,Upgrade Gradle 8 to 8.4+ for Spring Boot 3.4,Spring Boot 3.4 requires Gradle 8.4+.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.UpgradeMyBatisToSpringBoot_3_4,Upgrade MyBatis to Spring Boot 3.4,Upgrade MyBatis Spring modules to a version corresponding to Spring Boot 3.4.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.java.spring.boot3.UpgradeSpringCloudAWSToSpringBoot_3_4,Upgrade Spring Cloud AWS to Spring Boot 3.4 compatible version,Upgrade the Spring Cloud AWS dependency to a version compatible with Spring Boot 3.4.,io.moderne.recipe:rewrite-spring:0.15.0-20251021.190803-14 +io.moderne.vulncheck.FixVulnCheckVulnerabilities,Use [VulnCheck Exploit Intelligence](https://docs.vulncheck.com/products/exploit-and-vulnerability-intelligence/exploit-intelligence) to fix vulnerabilities,This software composition analysis (SCA) tool detects and upgrades dependencies with publicly disclosed vulnerabilities. This recipe both generates a report of vulnerable dependencies and upgrades to newer versions with fixes. This recipe by default only upgrades to the latest **patch** version. If a minor or major upgrade is required to reach the fixed version this can be controlled using the `maximumUpgradeDelta` option. Vulnerability information comes from VulnCheck Vulnerability Intelligence. The recipe has an option to limit fixes to only those vulnerabilities that have evidence of exploitation at various levels of severity.,io.moderne.recipe:rewrite-vulncheck:0.6.0-20250930.170510-39 +org.openrewrite.cobol.cleanup.RemoveWithDebuggingMode,Remove with debugging mode,Remove debugging mode from SOURCE-COMPUTER paragraphs.,org.openrewrite:rewrite-cobol:2.14.0-20251019.180854-103 +org.openrewrite.cobol.search.FindCopybook,Find copybook usage,Find all copy statements with the copybook name.,org.openrewrite:rewrite-cobol:2.14.0-20251019.180854-103 +org.openrewrite.cobol.search.FindIndicators,Find indicators,Find matching indicators. Currently this recipe will not mark indicators on copybook code.,org.openrewrite:rewrite-cobol:2.14.0-20251019.180854-103 +org.openrewrite.cobol.search.FindReference,Find matching identifiers in COBOL copybooks and JCL,Finds an identifier by an exact match or regex pattern in COBOL copybooks and/or JCL.,org.openrewrite:rewrite-cobol:2.14.0-20251019.180854-103 +org.openrewrite.cobol.search.FindRelationships,Find COBOL relationships,Build a list of relationships for diagramming and exploration.,org.openrewrite:rewrite-cobol:2.14.0-20251019.180854-103 +org.openrewrite.cobol.search.FindWord,Find matching words in the source code,Search for COBOL words based on a search term.,org.openrewrite:rewrite-cobol:2.14.0-20251019.180854-103 +org.openrewrite.AddToGitignore,Add entries to `.gitignore`,Adds entries to the project's `.gitignore` file. If no `.gitignore` file exists one will be created. Existing entries that match will not be duplicated.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.DeleteSourceFiles,Delete files,Delete files by source path.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.ExcludeFileFromGitignore,Remove ignoral of files or directories from .gitignore,This recipe will remove a file or directory from the .gitignore file. If the file or directory is already in the .gitignore file it will be removed or negated. If the file or directory is not in the .gitignore file no action will be taken.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.FindCollidingSourceFiles,Find colliding source files,Finds source files which share a path with another source file. There should always be exactly one source file per path within a repository. This is a diagnostic for finding problems in OpenRewrite parsers/build plugins.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.FindDeserializationErrors,Find deserialization errors,Produces a data table collecting all deserialization errors of serialized LSTs.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.FindGitProvenance,Show Git source control metadata,List out the contents of each unique `GitProvenance` marker in the set of source files. When everything is working correctly exactly one such marker should be printed as all source files are expected to come from the same repository / branch / commit hash.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.FindLstProvenance,Find LST provenance,Produces a data table showing what versions of OpenRewrite/Moderne tooling was used to produce a given LST.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.FindParseFailures,Find source files with `ParseExceptionResult` markers,This recipe explores parse failures after an LST is produced for classifying the types of failures that can occur and prioritizing fixes according to the most common problems.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.FindQuarks,Find instances of type `Quark`,`Quark` source files are pointers to the existence of a file without capturing any of the contents of the file.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.FindSourceFiles,Find files,Find files by source path. Paths are always interpreted as relative to the repository root.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.IsInRepository,Is in repository,A search recipe which marks files that are in a repository with one of the supplied names. Intended for use as a precondition for other recipes being run over many different repositories.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.ListRuntimeClasspath,List runtime classpath,A diagnostic utility which emits the runtime classpath to a data table.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.MoveFile,Move a file,Move a file to a different directory. The file name will remain the same.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.RenameFile,Rename a file,Rename a file while keeping it in the same directory.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.SetFilePermissions,Set file permission attributes,Set a file's read write and executable permission attributes.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.search.FindBuildMetadata,Find build metadata,Find source files with matching build metadata.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.search.FindCommitters,Find committers on repositories,List the committers on a repository.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.search.FindParseToPrintInequality,Find parse to print inequality,OpenRewrite `Parser` implementations should produce `SourceFile` objects whose `printAll()` method should be byte-for-byte equivalent with the original source file. When this isn't true recipes can still run on the `SourceFile` and even produce diffs but the diffs would fail to apply as a patch to the original source file. Most `Parser` use `Parser#requirePrintEqualsInput` to produce a `ParseError` when they fail to produce a `SourceFile` that is print idempotent.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.search.RepositoryContainsFile,Repository contains file,Intended to be used primarily as a precondition for other recipes this recipe checks if a repository contains a specific file or files matching a pattern. If present all files in the repository are marked with a `SearchResult` marker. If you want to get only the matching file as a search result use `FindSourceFiles` instead.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.text.AppendToTextFile,Append to text file,Appends or replaces content of an existing plain text file or creates a new one if it doesn't already exist. Please note that this recipes requires existing plain text files' format to be successfully parsable by OpenRewrite. If a file is left unchanged it might be parsed as a `Quark` rather than plain text. In such case use the `plainTextMask` option. See the [Gradle](https://docs.openrewrite.org/reference/gradle-plugin-configuration#configuring-the-rewrite-dsl) or [Maven](https://openrewrite.github.io/rewrite-maven-plugin/run-mojo.html#plainTextMasks) plugin configuration page.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.text.ChangeText,Change text,Completely replaces the contents of the text file with other text. Use together with a `FindSourceFiles` precondition to limit which files are changed.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.text.CreateTextFile,Create text file,Creates a new plain text file.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.text.EndOfLineAtEndOfFile,End of Line @ End of File (EOL @ EOF),Ensure that the file ends with the newline character. *Note*: If this recipe modifies a file it converts the file into plain text. As such this recipe should be run after any recipe that modifies the language-specific LST.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.text.Find,Find text,Textual search optionally using Regular Expression (regex) to query.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.text.FindAndReplace,Find and replace,Textual find and replace optionally interpreting the search query as a Regular Expression (regex). When operating on source files that are language-specific Lossless Semantic Tree such as Java or XML this operation converts the source file to plain text for the rest of the recipe run. So if you are combining this recipe with language-specific recipes in a single recipe run put all the language-specific recipes before this recipe.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.text.FindMultiselect,Experimental find text with multiselect,Search for text treating all textual sources as plain text. This version of the recipe exists to experiment with multiselect recipe options.,org.openrewrite:rewrite-core:8.64.0-20251021.195831-50 +org.openrewrite.csharp.recipes.meziantou.AbstractTypesShouldNotHaveConstructorsMA0017,Abstract types should not have public or internal constructors,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.ArgumentExceptionShouldSpecifyArgumentNameMA0043,Use nameof operator in ArgumentException,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.AvoidComparisonWithBoolConstantMA0073,Avoid comparison with bool constant,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.AvoidUsingRedundantElseMA0071,Avoid using redundant else,The 'if' block contains a jump statement (break continue goto return throw yield break). Using 'else' is redundant and needlessly maintains a higher nesting level.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.ClassMustBeSealedMA0053,Make class sealed,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.CommaMA0007,Add a comma after the last value,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.DoNotRemoveOriginalExceptionFromThrowStatementMA0027,Prefer rethrowing an exception implicitly,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.DoNotUseBlockingCallInAsyncContextMA0042,Do not use blocking calls in an async method,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.DoNotUseBlockingCallInAsyncContextMA0045,Do not use blocking calls in a sync method (need to make calling method async),,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.DoNotUseEqualityComparerDefaultOfStringMA0024,Use an explicit StringComparer when possible,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.DoNotUseEqualityOperatorsForSpanOfCharMA0103,Use SequenceEqual instead of equality operator,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.DoNotUseStringGetHashCodeMA0021,Use StringComparer.GetHashCode instead of string.GetHashCode,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.EqualityShouldBeCorrectlyImplementedMA0077,A class that provides Equals(T) should implement IEquatable,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.EventsShouldHaveProperArgumentsMA0091,Sender should be 'this' for instance events,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.MakeClassStaticMA0036,Make class static,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.MakeInterpolatedStringMA0165,Make interpolated string,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.MakeMemberReadOnlyMA0102,Make member readonly,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.MakeMethodStaticMA0038,Make method static (deprecated use CA1822 instead),,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.MakeMethodStaticMA0041,Make property static (deprecated use CA1822 instead),,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.MarkAttributesWithAttributeUsageAttributeMA0010,Mark attributes with AttributeUsageAttribute,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.MethodOverridesShouldNotChangeParameterDefaultsMA0061,Method overrides should not change default values,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.NamedParameterMA0003,Add parameter name to improve readability,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.NotPatternShouldBeParenthesizedCodeMA0164,Use parentheses to make not pattern clearer,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.OptimizeLinqUsageMA0020,Use direct methods instead of LINQ methods,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.OptimizeLinqUsageMA0029,Combine LINQ methods,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.OptimizeLinqUsageMA0030,Remove useless OrderBy call,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.OptimizeLinqUsageMA0031,Optimize Enumerable.Count() usage,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.OptimizeLinqUsageMA0078,Use 'Cast' instead of 'Select' to cast,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.OptimizeLinqUsageMA0098,Use indexer instead of LINQ methods,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.OptimizeLinqUsageMA0159,Use 'Order' instead of 'OrderBy',,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.OptimizeStartsWithMA0089,Optimize string method usage,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.OptimizeStringBuilderUsageMA0028,Optimize StringBuilder usage,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.ParameterAttributeForRazorComponentMA0116,Parameters with [SupplyParameterFromQuery] attributes should also be marked as [Parameter],,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.ParameterAttributeForRazorComponentMA0117,Parameters with [EditorRequired] attributes should also be marked as [Parameter],,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.PreserveParamsOnOverrideMA0081,Method overrides should not omit params keyword,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.RemoveEmptyStatementMA0037,Remove empty statement,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.RemoveUselessToStringMA0044,Remove useless ToString call,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.ReplaceEnumToStringWithNameofMA0052,Replace constant Enum.ToString with nameof,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.ReturnTaskFromResultInsteadOfReturningNullMA0022,Return Task.FromResult instead of returning null,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.SimplifyCallerArgumentExpressionMA0108,Remove redundant argument value,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.StringShouldNotContainsNonDeterministicEndOfLineMA0101,String contains an implicit end of line character,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseAnOverloadThatHasCancellationTokenFixer_ArgumentMA0040,Forward the CancellationToken parameter to methods that take one,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseAnOverloadThatHasCancellationTokenFixer_AwaitForEachMA0079,Forward the CancellationToken using .WithCancellation(),,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseAnOverloadThatHasTimeProviderMA0166,Forward the TimeProvider to methods that take one,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseArrayEmptyMA0005,Use Array.Empty(),,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseConfigureAwaitMA0004,Use Task.ConfigureAwait,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseDateTimeUnixEpochMA0113,Use DateTime.UnixEpoch,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseDateTimeUnixEpochMA0114,Use DateTimeOffset.UnixEpoch,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseEventArgsEmptyMA0019,Use EventArgs.Empty,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseEventArgsEmptyMA0093,EventArgs should not be null,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseGuidEmptyMA0067,Use Guid.Empty,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseIsPatternInsteadOfSequenceEqualMA0128,Use 'is' operator instead of SequenceEqual,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseJSRuntimeInvokeVoidAsyncWhenReturnValueIsNotUsedMA0120,Use InvokeVoidAsync when the returned value is not used,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseLangwordInXmlCommentMA0154,Use langword in XML comment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UsePatternMatchingForEqualityComparisonsMA0141,Use pattern matching instead of inequality operators for null check,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UsePatternMatchingForEqualityComparisonsMA0142,Use pattern matching instead of equality operators for null check,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UsePatternMatchingForEqualityComparisonsMA0148,Use pattern matching instead of equality operators for discrete value,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UsePatternMatchingForEqualityComparisonsMA0149,Use pattern matching instead of inequality operators for discrete value,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UsePatternMatchingInsteadOfHasvalueMA0171,Use pattern matching instead of inequality operators for discrete value,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseRegexSourceGeneratorMA0110,Use the Regex source generator,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseStringComparerMA0002,IEqualityComparer or IComparer is missing,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseStringComparisonMA0001,StringComparison is missing,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseStringComparisonMA0074,Avoid implicit culture-sensitive methods,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseStringCreateInsteadOfFormattableStringMA0111,Use string.Create instead of FormattableString,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseStringEqualsMA0006,Use String.Equals instead of equality operator,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.UseStructLayoutAttributeMA0008,Add StructLayoutAttribute,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.meziantou.ValidateArgumentsCorrectlyMA0050,Validate arguments correctly in iterator methods,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.AbstractTypesShouldNotHaveConstructorsCA1012,Abstract types should not have public constructors,Constructors on abstract types can be called only by derived types. Because public constructors create instances of a type and you cannot create instances of an abstract type an abstract type that has a public constructor is incorrectly designed.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.AvoidConstArraysCA1861,Avoid constant arrays as arguments,Constant arrays passed as arguments are not reused when called repeatedly which implies a new array is created each time. Consider extracting them to 'static readonly' fields to improve performance if the passed array is not mutated within the called method.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.AvoidLengthCalculationWhenSlicingToEndCA1514,Avoid redundant length argument,An explicit length calculation can be error-prone and can be avoided when slicing to end of the buffer.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.AvoidUnreliableStreamReadCA2022,Avoid inexact read with 'Stream.Read',A call to 'Stream.Read' may return fewer bytes than requested resulting in unreliable code if the return value is not checked.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.AvoidUnsealedAttributesCA1813,Avoid unsealed attributes,The .NET Framework class library provides methods for retrieving custom attributes. By default these methods search the attribute inheritance hierarchy. Sealing the attribute eliminates the search through the inheritance hierarchy and can improve performance.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.AvoidUnusedPrivateFieldsCA1823,Avoid unused private fields,Private fields were detected that do not appear to be accessed in the assembly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.AvoidZeroLengthArrayAllocationsCA1825,Avoid zero-length array allocations,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpAvoidDuplicateElementInitializationCA2244,Do not duplicate indexed element initializations,Indexed elements in objects initializers must initialize unique elements. A duplicate index might overwrite a previous element initialization.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpDisableRuntimeMarshallingCA1421,This method uses runtime marshalling even when the 'DisableRuntimeMarshallingAttribute' is applied,This method uses runtime marshalling even when runtime marshalling is disabled which can cause unexpected behavior differences at runtime due to different expectations of a type's native layout.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpDisposeMethodsShouldCallBaseClassDisposeCA2215,Dispose methods should call base class dispose,A type that implements System.IDisposable inherits from a type that also implements IDisposable. The Dispose method of the inheriting type does not call the Dispose method of the parent type. To fix a violation of this rule call base.Dispose in your Dispose method.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpDoNotCompareSpanToNullCA2265,Do not compare Span to 'null' or 'default',Comparing a span to 'null' or 'default' might not do what you intended. 'default' and the 'null' literal are implicitly converted to 'Span.Empty'. Remove the redundant comparison or make the code more explicit by using 'IsEmpty'.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpDoNotGuardCallCA1853,Unnecessary call to 'Dictionary.ContainsKey(key)',Do not guard 'Dictionary.Remove(key)' with 'Dictionary.ContainsKey(key)'. The former already checks whether the key exists and will not throw if it does not.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpDoNotGuardCallCA1868,Unnecessary call to 'Contains(item)',Do not guard 'Add(item)' or 'Remove(item)' with 'Contains(item)' for the set. The former two already check whether the item exists and will return if it was added or removed.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpDoNotInitializeUnnecessarilyCA1805,Do not initialize unnecessarily,The .NET runtime initializes all fields of reference types to their default values before running the constructor. In most cases explicitly initializing a field to its default value in a constructor is redundant adding maintenance costs and potentially degrading performance (such as with increased assembly size) and the explicit initialization can be removed. In some cases such as with static readonly fields that permanently retain their default value consider instead changing them to be constants or properties.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpDoNotPassNonNullableValueToArgumentNullExceptionThrowIfNullCA1871,Do not pass a nullable struct to 'ArgumentNullException.ThrowIfNull','ArgumentNullException.ThrowIfNull' accepts an 'object' so passing a nullable struct may cause the value to be boxed.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpDoNotPassNonNullableValueToArgumentNullExceptionThrowIfNullCA2264,Do not pass a non-nullable value to 'ArgumentNullException.ThrowIfNull','ArgumentNullException.ThrowIfNull' throws when the passed argument is 'null'. Certain constructs like non-nullable structs 'nameof()' and 'new' expressions are known to never be null so 'ArgumentNullException.ThrowIfNull' will never throw.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpDoNotUseCountWhenAnyCanBeUsedCA1827,Do not use Count() or LongCount() when Any() can be used,For non-empty collections Count() and LongCount() enumerate the entire sequence while Any() stops at the first item or the first item that satisfies a condition.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpDoNotUseCountWhenAnyCanBeUsedCA1828,Do not use CountAsync() or LongCountAsync() when AnyAsync() can be used,For non-empty collections CountAsync() and LongCountAsync() enumerate the entire sequence while AnyAsync() stops at the first item or the first item that satisfies a condition.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpDoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyCA1826,Do not use Enumerable methods on indexable collections,This collection is directly indexable. Going through LINQ here causes unnecessary allocations and CPU work.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpDynamicInterfaceCastableImplementationCA2256,All members declared in parent interfaces must have an implementation in a DynamicInterfaceCastableImplementation-attributed interface,Types attributed with 'DynamicInterfaceCastableImplementationAttribute' act as an interface implementation for a type that implements the 'IDynamicInterfaceCastable' type. As a result it must provide an implementation of all of the members defined in the inherited interfaces because the type that implements 'IDynamicInterfaceCastable' will not provide them otherwise.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpDynamicInterfaceCastableImplementationCA2257,Members defined on an interface with the 'DynamicInterfaceCastableImplementationAttribute' should be 'static',Since a type that implements 'IDynamicInterfaceCastable' may not implement a dynamic interface in metadata calls to an instance interface member that is not an explicit implementation defined on this type are likely to fail at runtime. Mark new interface members 'static' to avoid runtime errors.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpEnumStorageShouldBeInt32CA1028,Enum Storage should be Int32,An enumeration is a value type that defines a set of related named constants. By default the System.Int32 data type is used to store the constant value. Although you can change this underlying type it is not required or recommended for most scenarios.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpEnumsShouldHaveZeroValueCA1008,Enums should have zero value,The default value of an uninitialized enumeration just as other value types is zero. A nonflags-attributed enumeration should define a member by using the value of zero so that the default value is a valid value of the enumeration. If an enumeration that has the FlagsAttribute attribute applied defines a zero-valued member its name should be ""None"" to indicate that no values have been set in the enumeration.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpForwardCancellationTokenToInvocationsCA2016,Forward the 'CancellationToken' parameter to methods,Forward the 'CancellationToken' parameter to methods to ensure the operation cancellation notifications gets properly propagated or pass in 'CancellationToken.None' explicitly to indicate intentionally not propagating the token.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpIdentifiersShouldNotContainUnderscoresCA1707,Identifiers should not contain underscores,By convention identifier names do not contain the underscore (_) character. This rule checks namespaces types members and parameters.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpMakeTypesInternalCA1515,Consider making public types internal,Unlike a class library an application's API isn't typically referenced publicly so types can be marked internal.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpMarkAllNonSerializableFieldsCA2235,Mark all non-serializable fields,An instance field of a type that is not serializable is declared in a type that is serializable.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpMarkMembersAsStaticCA1822,Mark members as static,Members that do not access instance data or call instance methods can be marked as static. After you mark the methods as static the compiler will emit nonvirtual call sites to these members. This can give you a measurable performance gain for performance-sensitive code.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpOverrideEqualsAndOperatorEqualsOnValueTypesCA1815,Override equals and operator equals on value types,For value types the inherited implementation of Equals uses the Reflection library and compares the contents of all fields. Reflection is computationally expensive and comparing every field for equality might be unnecessary. If you expect users to compare or sort instances or to use instances as hash table keys your value type should implement Equals.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpPreferAsSpanOverSubstringCA1846,Prefer 'AsSpan' over 'Substring','AsSpan' is more efficient than 'Substring'. 'Substring' performs an O(n) string copy while 'AsSpan' does not and has a constant cost.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpPreferDictionaryContainsMethodsCA1841,Prefer Dictionary.Contains methods,'ContainsKey' is usually O(1) while 'Keys.Contains' may be O(n) in some cases. Additionally many dictionary implementations lazily initialize the Keys collection to cut back on allocations.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpPreferDictionaryTryMethodsOverContainsKeyGuardCA1854,Prefer the 'IDictionary.TryGetValue(TKey out TValue)' method,Prefer a 'TryGetValue' call over a Dictionary indexer access guarded by a 'ContainsKey' check. 'ContainsKey' and the indexer both would lookup the key under the hood so using 'TryGetValue' removes the extra lookup.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpPreferDictionaryTryMethodsOverContainsKeyGuardCA1864,Prefer the 'IDictionary.TryAdd(TKey TValue)' method,Prefer a 'TryAdd' call over an 'Add' call guarded by a 'ContainsKey' check. 'TryAdd' behaves the same as 'Add' except that when the specified key already exists it returns 'false' instead of throwing an exception.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpPreferGenericOverloadsCA2263,Prefer generic overload when type is known,Using a generic overload is preferable to the 'System.Type' overload when the type is known promoting cleaner and more type-safe code with improved compile-time checks.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpPreferHashDataOverComputeHashCA1850,Prefer static 'HashData' method over 'ComputeHash',It is more efficient to use the static 'HashData' method over creating and managing a HashAlgorithm instance to call 'ComputeHash'.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpPreferIsEmptyOverCountCA1836,Prefer IsEmpty over Count,For determining whether the object contains or not any items prefer using 'IsEmpty' property rather than retrieving the number of items from the 'Count' property and comparing it to 0 or 1.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpPreferLengthCountIsEmptyOverAnyCA1860,Avoid using 'Enumerable.Any()' extension method,Prefer using 'IsEmpty' 'Count' or 'Length' properties whichever available rather than calling 'Enumerable.Any()'. The intent is clearer and it is more performant than using 'Enumerable.Any()' extension method.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpPreferStreamAsyncMemoryOverloadsCA1835,Prefer the 'Memory'-based overloads for 'ReadAsync' and 'WriteAsync','Stream' has a 'ReadAsync' overload that takes a 'Memory' as the first argument and a 'WriteAsync' overload that takes a 'ReadOnlyMemory' as the first argument. Prefer calling the memory based overloads which are more efficient.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpRecommendCaseInsensitiveStringComparisonCA1862,Use the 'StringComparison' method overloads to perform case-insensitive string comparisons,Avoid calling 'ToLower' 'ToUpper' 'ToLowerInvariant' and 'ToUpperInvariant' to perform case-insensitive string comparisons because they lead to an allocation. Instead prefer calling the method overloads of 'Contains' 'IndexOf' and 'StartsWith' that take a 'StringComparison' enum value to perform case-insensitive comparisons. Switching to using an overload that takes a 'StringComparison' might cause subtle changes in behavior so it's important to conduct thorough testing after applying the suggestion. Additionally if a culturally sensitive comparison is not required consider using 'StringComparison.OrdinalIgnoreCase'.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpSpecifyCultureForToLowerAndToUpperCA1311,Specify a culture or use an invariant version,Specify culture to help avoid accidental implicit dependency on current culture. Using an invariant version yields consistent results regardless of the culture of an application.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpSpecifyMarshalingForPInvokeStringArgumentsCA2101,Specify marshaling for P/Invoke string arguments,A platform invoke member allows partially trusted callers has a string parameter and does not explicitly marshal the string. This can cause a potential security vulnerability.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpStaticHolderTypesCA1052,Static holder types should be Static or NotInheritable,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpTestForEmptyStringsUsingStringLengthCA1820,Test for empty strings using string length,Comparing strings by using the String.Length property or the String.IsNullOrEmpty method is significantly faster than using Equals.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpTestForNaNCorrectlyCA2242,Test for NaN correctly,This expression tests a value against Single.Nan or Double.Nan. Use Single.IsNan(Single) or Double.IsNan(Double) to test the value.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpUseAsSpanInsteadOfRangeIndexerCA1831,Use AsSpan or AsMemory instead of Range-based indexers when appropriate,The Range-based indexer on string values produces a copy of requested portion of the string. This copy is usually unnecessary when it is implicitly used as a ReadOnlySpan or ReadOnlyMemory value. Use the AsSpan method to avoid the unnecessary copy.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpUseAsSpanInsteadOfRangeIndexerCA1832,Use AsSpan or AsMemory instead of Range-based indexers when appropriate,The Range-based indexer on array values produces a copy of requested portion of the array. This copy is usually unnecessary when it is implicitly used as a ReadOnlySpan or ReadOnlyMemory value. Use the AsSpan method to avoid the unnecessary copy.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpUseAsSpanInsteadOfRangeIndexerCA1833,Use AsSpan or AsMemory instead of Range-based indexers when appropriate,The Range-based indexer on array values produces a copy of requested portion of the array. This copy is often unwanted when it is implicitly used as a Span or Memory value. Use the AsSpan method to avoid the copy.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpUseLiteralsWhereAppropriateCA1802,Use literals where appropriate,A field is declared static and read-only (Shared and ReadOnly in Visual Basic) and is initialized by using a value that is computable at compile time. Because the value that is assigned to the targeted field is computable at compile time change the declaration to a const (Const in Visual Basic) field so that the value is computed at compile time instead of at runtime.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpUseOrdinalStringComparisonCA1309,Use ordinal string comparison,A string comparison operation that is nonlinguistic does not set the StringComparison parameter to either Ordinal or OrdinalIgnoreCase. By explicitly setting the parameter to either StringComparison.Ordinal or StringComparison.OrdinalIgnoreCase your code often gains speed becomes more correct and becomes more reliable.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpUsePropertyInsteadOfCountMethodWhenAvailableCA1829,Use Length/Count property instead of Count() when available,Enumerable.Count() potentially enumerates the sequence while a Length/Count property is a direct access.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpUseSearchValuesCA1870,Use a cached 'SearchValues' instance,Using a cached 'SearchValues' instance is more efficient than passing values to 'IndexOfAny'/'ContainsAny' directly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpUseSpanBasedStringConcatCA1845,Use span-based 'string.Concat',It is more efficient to use 'AsSpan' and 'string.Concat' instead of 'Substring' and a concatenation operator.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpUseSpanClearInsteadOfFillCA1855,Prefer 'Clear' over 'Fill',It is more efficient to use 'Clear' instead of 'Fill' with default value.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpUseStartsWithInsteadOfIndexOfComparisonWithZeroCodeFixCA1858,Use 'StartsWith' instead of 'IndexOf',It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpUseStringContainsCharOverloadWithSingleCharactersCA1847,Use char literal for a single character lookup,'string.Contains(char)' is available as a better performing overload for single char lookup.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.CSharpUseStringMethodCharOverloadWithSingleCharactersCA1865,Use char overload,The char overload is a better performing overload than a string with a single char.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.DefineAccessorsForAttributeArgumentsCA1019,Define accessors for attribute arguments,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.DoNotCallToImmutableCollectionOnAnImmutableCollectionValueCA2009,Do not call ToImmutableCollection on an ImmutableCollection value,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.DoNotCreateTaskCompletionSourceWithWrongArgumentsCA2247,Argument passed to TaskCompletionSource constructor should be TaskCreationOptions enum instead of TaskContinuationOptions enum,TaskCompletionSource has constructors that take TaskCreationOptions that control the underlying Task and constructors that take object state that's stored in the task. Accidentally passing a TaskContinuationOptions instead of a TaskCreationOptions will result in the call treating the options as state.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.DoNotDirectlyAwaitATaskCA2007,Consider calling ConfigureAwait on the awaited task,When an asynchronous method awaits a Task directly continuation occurs in the same thread that created the task. Consider calling Task.ConfigureAwait(Boolean) to signal your intention for continuation. Call ConfigureAwait(false) on the task to schedule continuations to the thread pool thereby avoiding a deadlock on the UI thread. Passing false is a good option for app-independent libraries. Calling ConfigureAwait(true) on the task has the same behavior as not explicitly calling ConfigureAwait. By explicitly calling this method you're letting readers know you intentionally want to perform the continuation on the original synchronization context.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.DoNotUseWhenAllOrWaitAllWithSingleArgumentCA1842,Do not use 'WhenAll' with a single task,Using 'WhenAll' with a single task may result in performance loss await or return the task instead.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.DoNotUseWhenAllOrWaitAllWithSingleArgumentCA1843,Do not use 'WaitAll' with a single task,Using 'WaitAll' with a single task may result in performance loss await or return the task instead.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.EnumWithFlagsAttributeCA1027,Mark enums with FlagsAttribute,An enumeration is a value type that defines a set of related named constants. Apply FlagsAttribute to an enumeration when its named constants can be meaningfully combined.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.EnumWithFlagsAttributeCA2217,Do not mark enums with FlagsAttribute,An externally visible enumeration is marked by using FlagsAttribute and it has one or more values that are not powers of two or a combination of the other defined values on the enumeration.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.EquatableCA1066,Implement IEquatable when overriding Object.Equals,When a type T overrides Object.Equals(object) the implementation must cast the object argument to the correct type T before performing the comparison. If the type implements IEquatable and therefore offers the method T.Equals(T) and if the argument is known at compile time to be of type T then the compiler can call IEquatable.Equals(T) instead of Object.Equals(object) and no cast is necessary improving performance.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.EquatableCA1067,Override Object.Equals(object) when implementing IEquatable,When a type T implements the interface IEquatable it suggests to a user who sees a call to the Equals method in source code that an instance of the type can be equated with an instance of any other type. The user might be confused if their attempt to equate the type with an instance of another type fails to compile. This violates the "principle of least surprise".,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.ExceptionsShouldBePublicCA1064,Exceptions should be public,An internal exception is visible only inside its own internal scope. After the exception falls outside the internal scope only the base exception can be used to catch the exception. If the internal exception is inherited from T:System.Exception T:System.SystemException or T:System.ApplicationException the external code will not have sufficient information to know what to do with the exception.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.ImplementStandardExceptionConstructorsCA1032,Implement standard exception constructors,Failure to provide the full set of constructors can make it difficult to correctly handle exceptions.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.InstantiateArgumentExceptionsCorrectlyCA2208,Instantiate argument exceptions correctly,A call is made to the default (parameterless) constructor of an exception type that is or derives from ArgumentException or an incorrect string argument is passed to a parameterized constructor of an exception type that is or derives from ArgumentException.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.InterfaceMethodsShouldBeCallableByChildTypesCA1033,Interface methods should be callable by child types,An unsealed externally visible type provides an explicit method implementation of a public interface and does not provide an alternative externally visible method that has the same name.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.MarkAttributesWithAttributeUsageCA1018,Mark attributes with AttributeUsageAttribute,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.MarkTypesWithSerializableCA2237,Mark ISerializable types with serializable,To be recognized by the common language runtime as serializable types must be marked by using the SerializableAttribute attribute even when the type uses a custom serialization routine through implementation of the ISerializable interface.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.OperatorOverloadsHaveNamedAlternatesCA2225,Operator overloads have named alternates,An operator overload was detected and the expected named alternative method was not found. The named alternative member provides access to the same functionality as the operator and is provided for developers who program in languages that do not support overloaded operators.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.OperatorsShouldHaveSymmetricalOverloadsCA2226,Operators should have symmetrical overloads,A type implements the equality or inequality operator and does not implement the opposite operator.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.OverloadOperatorEqualsOnOverridingValueTypeEqualsCA2231,Overload operator equals on overriding value type Equals,In most programming languages there is no default implementation of the equality operator (==) for value types. If your programming language supports operator overloads you should consider implementing the equality operator. Its behavior should be identical to that of Equals.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.OverrideMethodsOnComparableTypesCA1036,Override methods on comparable types,A public or protected type implements the System.IComparable interface. It does not override Object.Equals nor does it overload the language-specific operator for equality inequality less than less than or equal greater than or greater than or equal.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.ParameterNamesShouldMatchBaseDeclarationCA1725,Parameter names should match base declaration,Consistent naming of parameters in an override hierarchy increases the usability of the method overrides. A parameter name in a derived method that differs from the name in the base declaration can cause confusion about whether the method is an override of the base method or a new overload of the method.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.PreferConstCharOverConstUnitStringCA1834,Consider using 'StringBuilder.Append(char)' when applicable,'StringBuilder.Append(char)' is more efficient than 'StringBuilder.Append(string)' when the string is a single character. When calling 'Append' with a constant prefer using a constant char rather than a constant string containing one character.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.PreferConvertToHexStringOverBitConverterCA1872,Prefer 'Convert.ToHexString' and 'Convert.ToHexStringLower' over call chains based on 'BitConverter.ToString',Use 'Convert.ToHexString' or 'Convert.ToHexStringLower' when encoding bytes to a hexadecimal string representation. These methods are more efficient and allocation-friendly than using 'BitConverter.ToString' in combination with 'String.Replace' to replace dashes and 'String.ToLower'.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.PreferStringContainsOverIndexOfCA2249,Consider using 'string.Contains' instead of 'string.IndexOf',Calls to 'string.IndexOf' where the result is used to check for the presence/absence of a substring can be replaced by 'string.Contains'.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.PreferTypedStringBuilderAppendOverloadsCA1830,Prefer strongly-typed Append and Insert method overloads on StringBuilder,StringBuilder.Append and StringBuilder.Insert provide overloads for multiple types beyond System.String. When possible prefer the strongly-typed overloads over using ToString() and the string-based overload.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.ProvidePublicParameterlessSafeHandleConstructorCA1419,Provide a parameterless constructor that is as visible as the containing type for concrete types derived from 'System.Runtime.InteropServices.SafeHandle',Providing a parameterless constructor that is as visible as the containing type for a type derived from 'System.Runtime.InteropServices.SafeHandle' enables better performance and usage with source-generated interop solutions.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.RemoveEmptyFinalizersCA1821,Remove empty Finalizers,Finalizers should be avoided where possible to avoid the additional performance overhead involved in tracking object lifetime.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.RethrowToPreserveStackDetailsCA2200,Rethrow to preserve stack details,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.SealInternalTypesCA1852,Seal internal types,When a type is not accessible outside its assembly and has no subtypes within its containing assembly it can be safely sealed. Sealing types can improve performance.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.SealMethodsThatSatisfyPrivateInterfacesCA2119,Seal methods that satisfy private interfaces,An inheritable public type provides an overridable method implementation of an internal (Friend in Visual Basic) interface. To fix a violation of this rule prevent the method from being overridden outside the assembly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.TypesThatOwnDisposableFieldsShouldBeDisposableCA1001,Types that own disposable fields should be disposable,A class declares and implements an instance field that is a System.IDisposable type and the class does not implement IDisposable. A class that declares an IDisposable field indirectly owns an unmanaged resource and should implement the IDisposable interface.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.UriParametersShouldNotBeStringsCA1054,URI-like parameters should not be strings,This rule assumes that the parameter represents a Uniform Resource Identifier (URI). A string representation or a URI is prone to parsing and encoding errors and can lead to security vulnerabilities. 'System.Uri' class provides these services in a safe and secure manner.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.UseCancellationTokenThrowIfCancellationRequestedCA2250,Use 'ThrowIfCancellationRequested','ThrowIfCancellationRequested' automatically checks whether the token has been canceled and throws an 'OperationCanceledException' if it has.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.UseEnvironmentMembersCA1837,Use 'Environment.ProcessId','Environment.ProcessId' is simpler and faster than 'Process.GetCurrentProcess().Id'.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.UseEnvironmentMembersCA1839,Use 'Environment.ProcessPath','Environment.ProcessPath' is simpler and faster than 'Process.GetCurrentProcess().MainModule.FileName'.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.UseEnvironmentMembersCA1840,Use 'Environment.CurrentManagedThreadId','Environment.CurrentManagedThreadId' is simpler and faster than 'Thread.CurrentThread.ManagedThreadId'.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.UseExceptionThrowHelpersCA1510,Use ArgumentNullException throw helper,Throw helpers are simpler and more efficient than an if block constructing a new exception instance.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.UseExceptionThrowHelpersCA1511,Use ArgumentException throw helper,Throw helpers are simpler and more efficient than an if block constructing a new exception instance.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.UseExceptionThrowHelpersCA1512,Use ArgumentOutOfRangeException throw helper,Throw helpers are simpler and more efficient than an if block constructing a new exception instance.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.UseExceptionThrowHelpersCA1513,Use ObjectDisposedException throw helper,Throw helpers are simpler and more efficient than an if block constructing a new exception instance.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.UseNameOfInPlaceOfStringCA1507,Use nameof to express symbol names,Using nameof helps keep your code valid when refactoring.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.microsoft.UseStringEqualsOverStringCompareCA2251,Use 'string.Equals',It is both clearer and likely faster to use 'string.Equals' instead of comparing the result of 'string.Compare' to zero.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AddBracesRCS1001,Add braces (when expression spans over multiple lines),,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AddBracesRCS1007,Add braces,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AddBracesRCS1126,Add braces to if-else,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AddBracesToIfElseRCS1003,Add braces to if-else (when expression spans over multiple lines),,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AddExceptionToDocumentationCommentRCS1140,Add exception to documentation comment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AddOrRemoveParenthesesWhenCreatingNewObjectRCS1050,Include/omit parentheses when creating new object,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AddOrRemoveTrailingCommaRCS1260,Add/remove trailing comma,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AddParagraphToDocumentationCommentRCS1226,Add paragraph to documentation comment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AddParenthesesWhenNecessaryRCS1123,Add parentheses when necessary,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AnonymousMethodRCS1048,Use lambda expression instead of anonymous method,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AssignmentExpressionRCS1089,Use --/++ operator instead of assignment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AssignmentExpressionRCS1114,Remove redundant delegate creation,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AttributeArgumentListRCS1039,Remove argument list from attribute,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AvoidBoxingOfValueTypeRCS1198,Avoid unnecessary boxing of value type,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AvoidNullReferenceExceptionRCS1202,Avoid NullReferenceException,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.AwaitExpressionRCS1090,Add/remove 'ConfigureAwait(false)' call,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BaseArgumentListRCS1205,Order named arguments according to the order of parameters,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BaseTypeRCS1182,Remove redundant base interface,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BinaryExpressionRCS1098,Constant values should be placed on right side of comparisons,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BinaryExpressionRCS1113,Use 'string.IsNullOrEmpty' method,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BinaryExpressionRCS1143,Simplify coalesce expression,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BinaryExpressionRCS1145,Remove redundant 'as' operator,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BinaryExpressionRCS1156,Use string.Length instead of comparison with empty string,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BinaryExpressionRCS1165,Unconstrained type parameter checked for null,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BinaryExpressionRCS1166,Value type object is never equal to null,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BinaryExpressionRCS1190,Join string expressions,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BinaryExpressionRCS1195,Use ^ operator,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BinaryExpressionRCS1199,Unnecessary null check,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BinaryExpressionRCS1233,Use short-circuiting operator,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BinaryExpressionRCS1240,Operator is unnecessary,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BinaryExpressionRCS1268,Simplify numeric comparison,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BlockRCS1031,Remove unnecessary braces in switch section,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.BlockRCS1171,Simplify lazy initialization,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.CaseSwitchLabelRCS1069,Remove unnecessary case label,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.CastExpressionRCS1257,Use enum field explicitly,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ClassDeclarationRCS1102,Make class static,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ClassDeclarationRCS1108,Add 'static' modifier to all partial class declarations,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ClassDeclarationRCS1194,Implement exception constructors,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ClassDeclarationRCS1203,Use AttributeUsageAttribute,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ClassDeclarationRCS1225,Make class sealed,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.CompositeEnumValueContainsUndefinedFlagRCS1157,Composite enum value contains undefined flag,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ConditionalExpressionRCS1084,Use coalesce expression instead of conditional expression,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ConditionalExpressionRCS1104,Simplify conditional expression,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ConditionalExpressionRCS1206,Use conditional access instead of conditional expression,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ConditionalExpressionRCS1238,Avoid nested ?: operators,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ConstructorDeclarationRCS1071,Remove redundant base constructor call,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ConstructorDeclarationRCS1074,Remove redundant constructor,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ConstructorDeclarationRCS1160,Abstract type should not have public constructors,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ConvertLambdaExpressionBodyToExpressionBodyRCS1021,Convert lambda expression body to expression body,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.DeclareEachAttributeSeparatelyRCS1052,Declare each attribute separately,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.DeclareEnumMemberWithZeroValueRCS1135,Declare enum member with zero value (when enum has FlagsAttribute),,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.DeclareTypeInsideNamespaceRCS1110,Declare type inside namespace,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.DefaultExpressionRCS1244,Simplify 'default' expression,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.DestructorDeclarationRCS1106,[deprecated] Remove empty destructor,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.DirectiveTriviaRCS1222,Merge preprocessor directives,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.DisposeResourceAsynchronouslyRCS1261,Resource can be disposed asynchronously,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.DoStatementRCS1063,[deprecated] Avoid usage of do statement to create an infinite loop,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.DocumentRCS1093,File contains no code,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.DocumentationCommentRCS1139,Add summary element to documentation comment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.DuplicateWordInCommentRCS1243,Duplicate word in a comment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ElseClauseRCS1006,Merge 'else' with nested 'if',,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ElseClauseRCS1040,[deprecated] Remove empty 'else' clause,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.EmptyStatementRCS1038,[deprecated] Remove empty statement,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.EndRegionDirectiveTriviaRCS1189,Add or remove region name,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.EnumDeclarationRCS1154,Sort enum members,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.EnumDeclarationRCS1161,Enum should declare explicit values,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.EnumDeclarationRCS1237,[deprecated] Use bit shift operator,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.EnumMemberDeclarationRCS1191,Declare enum value as combination of names,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.EnumMemberDeclarationRCS1234,Duplicate enum value,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.EnumMemberDeclarationRCS1254,Normalize format of enum flag value,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ExpressionRCS1051,Add/remove parentheses from condition in conditional operator,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ExpressionRCS1215,Expression is always equal to true/false,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ExtractMemberToNewDocumentRCS1060,Declare each type in separate file,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.FinallyClauseRCS1066,[deprecated] Remove empty 'finally' clause,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ForStatementRCS1064,[deprecated] Avoid usage of for statement to create an infinite loop,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.IfStatementRCS1061,Merge 'if' with nested 'if',,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.IfStatementRCS1073,Convert 'if' to 'return' statement,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.IfStatementRCS1103,Convert 'if' to assignment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.IfStatementRCS1173,Use coalesce expression instead of 'if',,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.IfStatementRCS1208,Reduce 'if' nesting,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.IfStatementRCS1236,Use exception filter,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.IfStatementRCS1255,Simplify argument null check,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ImplementNonGenericCounterpartRCS1241,Implement non-generic counterpart,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.InitializerRCS1035,[deprecated] Remove redundant comma in initializer,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.InterpolatedStringRCS1214,Unnecessary interpolated string,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.InterpolatedStringRCS1217,Convert interpolated string to concatenation,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.InterpolationRCS1105,Unnecessary interpolation,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.InvalidArgumentNullCheckRCS1256,Invalid argument null check,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.InvocationExpressionRCS1080,Use 'Count/Length' property instead of 'Any' method,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.InvocationExpressionRCS1097,Remove redundant 'ToString' call,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.InvocationExpressionRCS1107,Remove redundant 'ToCharArray' call,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.InvocationExpressionRCS1112,Combine 'Enumerable.Where' method chain,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.InvocationExpressionRCS1196,Call extension method as instance method,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.InvocationExpressionRCS1200,Call 'Enumerable.ThenBy' instead of 'Enumerable.OrderBy',,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.InvocationExpressionRCS1267,Use string interpolation instead of 'string.Concat',,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.LocalDeclarationStatementRCS1124,Inline local variable,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.LockStatementRCS1059,Avoid locking on publicly accessible instance,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.MarkLocalVariableAsConstRCS1118,Mark local variable as const,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.MarkTypeWithDebuggerDisplayAttributeRCS1223,Mark publicly visible type with DebuggerDisplay attribute,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.MemberDeclarationRCS1018,Add/remove accessibility modifiers,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.MemberDeclarationRCS1019,Order modifiers,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.MemberDeclarationRCS1034,Remove redundant 'sealed' modifier,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.MemberDeclarationRCS1055,Unnecessary semicolon at the end of declaration,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.MemberDeclarationRCS1132,Remove redundant overriding member,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.MemberDeclarationRCS1169,Make field read-only,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.MemberDeclarationRCS1170,Use read-only auto-implemented property,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.MemberDeclarationRCS1181,Convert comment to documentation comment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.MemberDeclarationRCS1187,Use constant instead of field,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.MemberDeclarationRCS1224,Make method an extension method,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.NamespaceDeclarationRCS1072,[deprecated] Remove empty namespace declaration,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.NamespaceDeclarationRCS1094,Declare using directive on top level,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.NormalizeNullCheckProviderRCS1248,Normalize null check,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.NormalizeUsageOfInfiniteLoopRCS1252,Normalize usage of infinite loop,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ObjectCreationExpressionRCS1204,Use EventArgs.Empty,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.OptimizeLinqMethodCallRCS1077,Optimize LINQ method call,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.OptimizeLinqMethodCallRCS1246,Use element access,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.OptimizeMethodCallRCS1235,Optimize method call,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.OptimizeStringBuilderAppendCallRCS1197,Optimize StringBuilder.Append/AppendLine call,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.OrderElementsInDocumentationCommentRCS1232,Order elements in documentation comment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.OrderTypeParameterConstraintsRCS1209,Order type parameter constraints,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ParameterNameDiffersFromBaseRCS1168,Parameter name differs from base name,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ParameterRCS1193,Overriding member should not change 'params' modifier,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ParameterRCS1231,Make parameter ref read-only,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ParameterRCS1242,Do not pass non-read-only struct by read-only reference,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ParenthesizedExpressionRCS1032,Remove redundant parentheses,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.PropertyDeclarationRCS1188,Remove redundant auto-property initialization,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RawStringLiteralRCS1262,Unnecessary raw string literal,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RawStringLiteralRCS1266,Use raw string literal,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RegionDirectiveTriviaRCS1091,[deprecated] Remove empty region,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveBracesFromIfElseRCS1004,Remove braces from if-else,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveBracesRCS1002,Remove braces,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveElementInDocumentationCommentRCS1228,Unused element in a documentation comment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveElementInDocumentationCommentRCS1263,Invalid reference in a documentation comment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveEmptyInitializerRCS1041,[deprecated] Remove empty initializer,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveEmptySyntaxRCS1259,Remove empty syntax,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveEnumDefaultBaseTypeRCS1042,Remove enum default underlying type,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveOriginalExceptionRCS1044,Remove original exception from throw statement,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemovePartialModifierFromTypeWithSinglePartRCS1043,Remove 'partial' modifier from type with a single part,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveRedundantAssignmentRCS1212,Remove redundant assignment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveRedundantAsyncAwaitRCS1174,Remove redundant async/await,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveRedundantBooleanLiteralRCS1033,Remove redundant boolean literal,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveRedundantCastRCS1151,Remove redundant cast,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveRedundantCatchBlockRCS1265,Remove redundant catch block,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveUnnecessaryBracesRCS1251,Remove unnecessary braces from record declaration,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.RemoveUnnecessaryElseRCS1211,Remove unnecessary 'else',,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ReturnCompletedTaskInsteadOfNullRCS1210,Return completed task instead of returning null,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.SimplifyBooleanComparisonRCS1049,Simplify boolean comparison,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.SimplifyCodeBranchingRCS1218,Simplify code branching,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.SimplifyLogicalNegationRCS1068,Simplify logical negation,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.SimplifyNestedUsingStatementRCS1005,Simplify nested using statement,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.SimplifyNullableOfTRCS1020,Simplify Nullable to T?,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.SingleLineDocumentationCommentTriviaRCS1100,[deprecated] Format documentation summary on a single line,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.SingleLineDocumentationCommentTriviaRCS1101,[deprecated] Format documentation summary on multiple lines,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.SingleLineDocumentationCommentTriviaRCS1141,Add 'param' element to documentation comment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.SingleLineDocumentationCommentTriviaRCS1142,Add 'typeparam' element to documentation comment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.SingleLineDocumentationCommentTriviaRCS1253,Format documentation comment summary,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.StatementRCS1133,Remove redundant Dispose/Close call,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.StatementRCS1134,Remove redundant statement,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.StatementRCS1180,Inline lazy initialization,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.StatementRCS1201,Use method chaining,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.SwitchSectionRCS1070,Remove redundant default switch section,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.SwitchSectionRCS1099,Default label should be the last label in a switch section,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.SwitchSectionRCS1111,Add braces to switch section with multiple statements,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.SwitchSectionRCS1136,Merge switch sections with equivalent content,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.TokenRCS1249,Unnecessary null-forgiving operator,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.TypeParameterRCS1164,Unused type parameter,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.TypeRCS1159,Use EventHandler,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UnnecessaryAssignmentRCS1179,Unnecessary assignment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UnnecessaryEnumFlagRCS1258,Unnecessary enum flag,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UnnecessaryExplicitUseOfEnumeratorRCS1230,Unnecessary explicit use of enumerator,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UnnecessaryUnsafeContextRCS1216,Unnecessary unsafe context,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UnnecessaryUsageOfVerbatimStringLiteralRCS1192,Unnecessary usage of verbatim string literal,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UnusedMemberRCS1213,Remove unused member declaration,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UnusedParameterRCS1163,Unused parameter,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseAnonymousFunctionOrMethodGroupRCS1207,Use anonymous function or method group,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseAsyncAwaitRCS1229,Use async/await when necessary,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseAutoPropertyRCS1085,Use auto-implemented property,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseBlockBodyOrExpressionBodyRCS1016,Use block body or expression body,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseCoalesceExpressionRCS1128,Use coalesce expression,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseCompoundAssignmentRCS1058,Use compound assignment,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseConditionalAccessRCS1146,Use conditional access,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseEmptyStringLiteralOrStringEmptyRCS1078,Use "" or 'string.Empty',,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseExplicitTypeInsteadOfVarInForEachRCS1009,[deprecated] Use explicit type instead of 'var' (foreach variable),,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseExplicitTypeInsteadOfVarRCS1008,[deprecated] Use explicit type instead of 'var' (when the type is not obvious),,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseExplicitTypeInsteadOfVarRCS1012,[deprecated] Use explicit type instead of 'var' (when the type is obvious),,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseExplicitlyOrImplicitlyTypedArrayRCS1014,Use explicitly/implicitly typed array,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseHasFlagMethodOrBitwiseOperatorRCS1096,Use 'HasFlag' method or bitwise operator,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseImplicitOrExplicitObjectCreationRCS1250,Use implicit/explicit object creation,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseIsOperatorInsteadOfAsOperatorRCS1172,Use 'is' operator instead of 'as' operator,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseNameOfOperatorRCS1015,Use nameof operator,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UsePatternMatchingInsteadOfAsAndNullCheckRCS1221,Use pattern matching instead of combination of 'as' operator and null check,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UsePatternMatchingInsteadOfIsAndCastRCS1220,Use pattern matching instead of combination of 'is' operator and cast operator,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UsePredefinedTypeRCS1013,Use predefined type,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseRegexInstanceInsteadOfStaticMethodRCS1186,Use Regex instance instead of static method,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseStringComparisonRCS1155,Use StringComparison when comparing strings,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseVarInsteadOfExplicitTypeRCS1010,[deprecated] Use 'var' instead of explicit type (when the type is obvious),,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseVarInsteadOfExplicitTypeRCS1176,[deprecated] Use 'var' instead of explicit type (when the type is not obvious),,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseVarInsteadOfExplicitTypeRCS1177,[deprecated] Use 'var' instead of explicit type (in foreach),,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UseVarOrExplicitTypeRCS1264,Use 'var' or explicit type,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.UsingDirectiveRCS1056,Avoid usage of using alias directive,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.ValidateArgumentsCorrectlyRCS1227,Validate arguments correctly,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.VariableDeclarationRCS1081,Split variable declaration,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.VariableDeclaratorRCS1129,Remove redundant field initialization,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.WhileStatementRCS1065,[deprecated] Avoid usage of while statement to create an infinite loop,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.WhileStatementRCS1239,Use 'for' statement instead of 'while' statement,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.WhitespaceTriviaRCS1036,[deprecated] Remove unnecessary blank line,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.WhitespaceTriviaRCS1037,Remove trailing white-space,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.roslynator.XmlNodeRCS1247,Fix documentation comment tag,,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.IndentationSA1137,Elements should have the same indentation,Elements at the same level in the syntax tree should have the same indentation.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.PropertySummaryDocumentationSA1623,Property summary documentation should match accessors,The documentation text within a C# property’s tag does not match the accessors within the property.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.PropertySummaryDocumentationSA1624,Property summary documentation should omit accessor with restricted access,The documentation text within a C# property’s tag takes into account all of the accessors within the property but one of the accessors has limited access.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.RemoveRegionSA1123,Do not place regions within elements,The C# code contains a region within the body of a code element.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.RemoveRegionSA1124,Do not use regions,The C# code contains a region.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.RenameToLowerCaseSA1306,Field names should begin with lower-case letter,The name of a field in C# does not begin with a lower-case letter.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.RenameToLowerCaseSA1312,Variable names should begin with lower-case letter,The name of a variable in C# does not begin with a lower-case letter.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.RenameToLowerCaseSA1313,Parameter names should begin with lower-case letter,The name of a parameter in C# does not begin with a lower-case letter.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.RenameToUpperCaseSA1300,Element should begin with upper-case letter,The name of a C# element does not begin with an upper-case letter.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.RenameToUpperCaseSA1303,Const field names should begin with upper-case letter,The name of a constant C# field should begin with an upper-case letter.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.RenameToUpperCaseSA1304,Non-private readonly fields should begin with upper-case letter,The name of a non-private readonly C# field should being with an upper-case letter.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.RenameToUpperCaseSA1307,Accessible fields should begin with upper-case letter,The name of a public or internal field in C# does not begin with an upper-case letter.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.RenameToUpperCaseSA1311,Static readonly fields should begin with upper-case letter,The name of a static readonly field does not begin with an upper-case letter.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1003SA1003,Symbols should be spaced correctly,The spacing around an operator symbol is incorrect within a C# code file.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1004SA1004,Documentation lines should begin with single space,A line within a documentation header above a C# element does not begin with a single space.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1005SA1005,Single line comments should begin with single space,A single-line comment within a C# code file does not begin with a single space.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1018SA1018,Nullable type symbols should be spaced correctly,A nullable type symbol within a C# element is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1025SA1025,Code should not contain multiple whitespace in a row,The code contains multiple whitespace characters in a row.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1027SA1027,Use tabs correctly,The code contains a tab or space character which is not consistent with the current project settings.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1028SA1028,Code should not contain trailing whitespace,There should not be any whitespace at the end of a line of code.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1100SA1100,Do not prefix calls with base unless local implementation exists,A call to a member from an inherited class begins with 'base.' and the local class does not contain an override or implementation of the member.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1101SA1101,Prefix local calls with this,A call to an instance member of the local class or a base class is not prefixed with 'this.' within a C# code file.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1102SA1102,Query clause should follow previous clause,A C# query clause does not begin on the same line as the previous clause or on the next line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1103SA1103,Query clauses should be on separate lines or all on one line,The clauses within a C# query expression are not all placed on the same line and each clause is not placed on its own line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1104SA1105SA1104,Query clause should begin on new line when previous clause spans multiple lines,A clause within a C# query expression begins on the same line as the previous clause when the previous clause spans across multiple lines.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1104SA1105SA1105,Query clauses spanning multiple lines should begin on own line,A clause within a C# query expression spans across multiple lines and does not begin on its own line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1106SA1106,Code should not contain empty statements,The C# code contains an extra semicolon.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1107SA1107,Code should not contain multiple statements on one line,The C# code contains more than one statement on a single line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1116SA1116,Split parameters should start on line after declaration,The parameters to a C# method or indexer call or declaration span across multiple lines but the first parameter does not start on the line after the opening bracket.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1119SA1119,Statement should not use unnecessary parenthesis,A C# statement contains parenthesis which are unnecessary and should be removed.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1119SA1119_p,Statement should not use unnecessary parenthesis,A C# statement contains parenthesis which are unnecessary and should be removed.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1120SA1120,Comments should contain text,The C# comment does not contain any comment text.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1121SA1121,Use built-in type alias,The code uses one of the basic C# types but does not use the built-in alias for the type.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1122SA1122,Use string.Empty for empty strings,The C# code includes an empty string written as "".,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1127SA1127,Generic type constraints should be on their own line,Each type constraint clause for a generic type parameter should be listed on a line of code by itself.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1128SA1128,Put constructor initializers on their own line,A constructor initializer including the colon character should be on its own line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1129SA1129,Do not use default value type constructor,When creating a new instance of a value type T the syntax 'default(T)' is functionally equivalent to the syntax 'new T()'. To avoid confusion regarding the behavior of the resulting instance the first form is preferred.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1130SA1130,Use lambda syntax,Lambda expressions are more succinct and easier to read than anonymous methods so they should are preferred whenever the two are functionally equivalent.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1131SA1131,Use readable conditions,When a comparison is made between a variable and a literal the variable should be placed on the left-hand-side to maximize readability.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1132SA1132,Do not combine fields,Each field should be declared on its own line in order to clearly see each field of a type and allow for proper documentation of the behavior of each field.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1133SA1133,Do not combine attributes,Each attribute usage should be placed in its own set of square brackets for maximum readability.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1134SA1134,Attributes should not share line,Each attribute should be placed on its own line of code.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1135SA1135,Using directives should be qualified,All using directives should be qualified.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1136SA1136,Enum values should be on separate lines,Enum values should be placed on their own lines for maximum readability.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1139SA1139,Use literal suffix notation instead of casting,Use literal suffix notation instead of casting in order to improve readability avoid bugs related to illegal casts and ensure that optimal IL is produced.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1205SA1205,Partial elements should declare access,The partial element does not have an access modifier defined.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1206SA1206,Declaration keywords should follow order,The keywords within the declaration of an element do not follow a standard ordering scheme.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1207SA1207,Protected should come before internal,The keyword '{0}' is positioned after the keyword '{1}' within the declaration of a {0} {1} C# element.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1212SA1213SA1212,Property accessors should follow order,A get accessor appears after a set accessor within a property or indexer.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1212SA1213SA1213,Event accessors should follow order,An add accessor appears after a remove accessor within an event.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1302SA1302,Interface names should begin with I,The name of a C# interface does not begin with the capital letter I.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1308SA1308,Variable names should not be prefixed,A field name in C# is prefixed with 'm_' 's_' or 't_'.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1309SA1309,Field names should not begin with underscore,A field name in C# begins with an underscore.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1310SA1310,Field names should not contain underscore,A field name in C# contains an underscore.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1314SA1314,Type parameter names should begin with T,The name of a C# type parameter does not begin with the capital letter T.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1400SA1400,Access modifier should be declared,The access modifier for a C# element has not been explicitly defined.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1402SA1402,File may only contain a single type,A C# code file contains more than one unique type.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1404SA1404,Code analysis suppression should have justification,A Code Analysis SuppressMessage attribute does not include a justification.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1407SA1408SA1407,Arithmetic expressions should declare precedence,A C# statement contains a complex arithmetic expression which omits parenthesis around operators.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1407SA1408SA1408,Conditional expressions should declare precedence,A C# statement contains a complex conditional expression which omits parenthesis around operators.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1410SA1411SA1410,Remove delegate parenthesis when possible,A call to a C# anonymous method does not contain any method parameters yet the statement still includes parenthesis.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1410SA1411SA1411,Attribute constructor should not use unnecessary parenthesis,TODO.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1412SA1412,Store files as UTF-8 with byte order mark,Source files should be saved using the UTF-8 encoding with a byte order mark,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1413SA1413,Use trailing comma in multi-line initializers,A multi-line initializer in a C# code file should use a comma on the last line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1500SA1500,Braces for multi-line statements should not share line,The opening or closing brace within a C# statement element or expression is not placed on its own line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1501SA1501,Statement should not be on a single line,A C# statement containing opening and closing braces is written completely on a single line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1502SA1502,Element should not be on a single line,A C# element containing opening and closing braces is written completely on a single line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1503SA1503,Braces should not be omitted,The opening and closing braces for a C# statement have been omitted.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1503SA1519,Braces should not be omitted from multi-line child statement,The opening and closing braces for a multi-line C# statement have been omitted.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1503SA1520,Use braces consistently,The opening and closing braces of a chained if/else if/else construct were included for some clauses but omitted for others.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1504SA1504,All accessors should be single-line or multi-line,Within a C# property indexer or event at least one of the child accessors is written on a single line and at least one of the child accessors is written across multiple lines.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1505SA1505,Opening braces should not be followed by blank line,An opening brace within a C# element statement or expression is followed by a blank line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1506SA1506,Element documentation headers should not be followed by blank line,An element documentation header above a C# element is followed by a blank line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1507SA1507,Code should not contain multiple blank lines in a row,The C# code contains multiple blank lines in a row.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1508SA1508,Closing braces should not be preceded by blank line,A closing brace within a C# element statement or expression is preceded by a blank line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1509SA1509,Opening braces should not be preceded by blank line,An opening brace within a C# element statement or expression is preceded by a blank line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1510SA1510,Chained statement blocks should not be preceded by blank line,Chained C# statements are separated by a blank line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1511SA1511,While-do footer should not be preceded by blank line,The while footer at the bottom of a do-while statement is separated from the statement by a blank line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1512SA1512,Single-line comments should not be followed by blank line,A single-line comment within C# code is followed by a blank line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1513SA1513,Closing brace should be followed by blank line,A closing brace within a C# element statement or expression is not followed by a blank line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1514SA1514,Element documentation header should be preceded by blank line,An element documentation header above a C# element is not preceded by a blank line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1515SA1515,Single-line comment should be preceded by blank line,A single-line comment within C# code is not preceded by a blank line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1516SA1516,Elements should be separated by blank line,Adjacent C# elements are not separated by a blank line.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1517SA1517,Code should not contain blank lines at start of file,The code file has blank lines at the start.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1518SA1518,Use line endings correctly at end of file,Code should not contain blank lines at the end of the file,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1609SA1610SA1609,Property documentation should have value,The XML header documentation for a C# property does not contain a tag.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1609SA1610SA1610,Property documentation should have value text,The XML header documentation for a C# property contains an empty tag.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1615SA1616SA1615,Element return value should be documented,A C# element is missing documentation for its return value.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1615SA1616SA1616,Element return value documentation should have text,The tag within a C# element's documentation header is empty.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1617SA1617,Void return value should not be documented,A C# code element does not contain a return value or returns void but the documentation header for the element contains a tag.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1626SA1626,Single-line comments should not use documentation style slashes,The C# code contains a single-line comment which begins with three forward slashes in a row.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1629SA1629,Documentation text should end with a period,A section of the XML header documentation for a C# element does not end with a period.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1642SA1643SA1642,Constructor summary documentation should begin with standard text,The XML documentation header for a C# constructor does not contain the appropriate summary text.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1642SA1643SA1643,Destructor summary documentation should begin with standard text,The XML documentation header for a C# finalizer does not contain the appropriate summary text.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SA1651SA1651,Do not use placeholder elements,The element documentation contains a element.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SX1101SX1101,Do not prefix local calls with 'this.',A call to an instance member of the local class or a base class is prefixed with `this.`.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SX1309SX1309,Field names should begin with underscore,A field name in C# does not begin with an underscore.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SX1309SX1309S,Static field names should begin with underscore,A static field name in C# does not begin with an underscore.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SettingsFileSA1600,Elements should be documented,A C# code element is missing a documentation header.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SettingsFileSA1601,Partial elements should be documented,A C# partial element is missing a documentation header.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SettingsFileSA1602,Enumeration items should be documented,An item within a C# enumeration is missing an Xml documentation header.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SettingsFileSA1633,File should have header,A C# code file is missing a standard file header.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SettingsFileSA1634,File header should show copyright,The file header at the top of a C# code file is missing a copyright tag.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SettingsFileSA1635,File header should have copyright text,The file header at the top of a C# code file is missing copyright text.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SettingsFileSA1636,File header copyright text should match,The file header at the top of a C# code file does not contain the appropriate copyright text.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SettingsFileSA1637,File header should contain file name,The file header at the top of a C# code file is missing the file name.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SettingsFileSA1638,File header file name documentation should match file name,The file attribute within copyright tag of the file header at the top of a C# code file does not contain the name of the file.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SettingsFileSA1639,File header should have summary,The file header at the top of a C# code file does not contain a filled-in summary tag.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SettingsFileSA1640,File header should have valid company text,The file header at the top of a C# code file does not contain company name text.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SettingsFileSA1641,File header company name text should match,The file header at the top of a C# code file does not contain the appropriate company name text.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.SettingsFileSA1649,File name should match first type name,The file name of a C# code file does not match the first type declared in the file.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1000,Keywords should be spaced correctly,The spacing around a C# keyword is incorrect.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1001,Commas should be spaced correctly,The spacing around a comma is incorrect within a C# code file.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1002,Semicolons should be spaced correctly,The spacing around a semicolon is incorrect within a C# code file.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1006,Preprocessor keywords should not be preceded by space,A C# preprocessor-type keyword is preceded by space.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1007,Operator keyword should be followed by space,The operator keyword within a C# operator overload method is not followed by any whitespace.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1008,Opening parenthesis should be spaced correctly,An opening parenthesis within a C# statement is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1009,Closing parenthesis should be spaced correctly,A closing parenthesis within a C# statement is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1010,Opening square brackets should be spaced correctly,An opening square bracket within a C# statement is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1011,Closing square brackets should be spaced correctly,A closing square bracket within a C# statement is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1012,Opening braces should be spaced correctly,An opening brace within a C# element is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1013,Closing braces should be spaced correctly,A closing brace within a C# element is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1014,Opening generic brackets should be spaced correctly,An opening generic bracket within a C# element is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1015,Closing generic brackets should be spaced correctly,A closing generic bracket within a C# element is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1016,Opening attribute brackets should be spaced correctly,An opening attribute bracket within a C# element is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1017,Closing attribute brackets should be spaced correctly,A closing attribute bracket within a C# element is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1019,Member access symbols should be spaced correctly,The spacing around a member access symbol is incorrect within a C# code file.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1020,Increment decrement symbols should be spaced correctly,An increment or decrement symbol within a C# element is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1021,Negative signs should be spaced correctly,A negative sign within a C# element is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1022,Positive signs should be spaced correctly,A positive sign within a C# element is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1023,Dereference and access of symbols should be spaced correctly,A dereference symbol or an access-of symbol within a C# element is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1024,Colons Should Be Spaced Correctly,A colon within a C# element is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1026,Code should not contain space after new or stackalloc keyword in implicitly typed array allocation,An implicitly typed array allocation within a C# code file is not spaced correctly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1110,Opening parenthesis or bracket should be on declaration line,The opening parenthesis or bracket is not placed on the same line as the method/indexer/attribute/array name.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1111,Closing parenthesis should be on line of last parameter,The closing parenthesis or bracket in a call to or declaration of a C# method/indexer/attribute/array/constructor/delegate is not placed on the same line as the last parameter.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1112,Closing parenthesis should be on line of opening parenthesis,The closing parenthesis or bracket in a call to a C# method or indexer or the declaration of a method or indexer is not placed on the same line as the opening bracket when the element does not take any parameters.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.TokenSpacingSA1113,Comma should be on the same line as previous parameter,A comma between two parameters in a call to a C# method or indexer or in the declaration of a method or indexer is not placed on the same line as the previous parameter.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.UsingSA1200,Using directives should be placed correctly,A C# using directive is placed outside of a namespace element.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.UsingSA1208,System using directives should be placed before other using directives,A using directive which declares a member of the 'System' namespace appears after a using directive which declares a member of a different namespace within a C# code file.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.UsingSA1209,Using alias directives should be placed after other using directives,A using-alias directive is positioned before a regular using directive.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.UsingSA1210,Using directives should be ordered alphabetically by namespace,The using directives within a C# code file are not sorted alphabetically by namespace.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.UsingSA1211,Using alias directives should be ordered alphabetically by alias name,The using-alias directives within a C# code file are not sorted alphabetically by alias name.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.UsingSA1216,Using static directives should be placed at the correct location.,A using static directive is positioned before a regular or after an alias using directive.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.stylecop.UsingSA1217,Using static directives should be ordered alphabetically,All using static directives should be ordered alphabetically.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.AddAttributeListFixWPF0130,Add [TemplatePart] to the type,Add [TemplatePart] to the type.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.AddAttributeListFixWPF0176,StyleTypedProperty is missing,StyleTypedProperty is missing.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.AddDefaultMemberFixWPF0070,Add default field to converter,Add default field to converter.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.AttachedPropertyBrowsableForTypeArgumentFixWPF0034,Use correct argument for [AttachedPropertyBrowsableForType],Use correct argument for [AttachedPropertyBrowsableForType].,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.AttachedPropertyBrowsableForTypeAttributeFixWPF0033,Add [AttachedPropertyBrowsableForType],Add [AttachedPropertyBrowsableForType].,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.AttachedPropertyBrowsableForTypeAttributeFixWPF0071,Add ValueConversion attribute,Add ValueConversion attribute.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.CastFixWPF0019,Cast sender to correct type,Cast sender to correct type.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.CastFixWPF0020,Cast value to correct type,Cast value to correct type.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.CastFixWPF0021,Cast sender to containing type,Cast sender to correct type.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.CastFixWPF0022,Cast value to correct type,Cast value to correct type.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.ChangeTypeofFixWPF0081,MarkupExtensionReturnType must use correct return type,MarkupExtensionReturnType must use correct return type.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.ComponentResourceKeyFixWPF0140,Use containing type when creating a ComponentResourceKey,Use containing type when creating a ComponentResourceKey.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.ComponentResourceKeyFixWPF0141,Use containing member as key when creating a ComponentResourceKey,Use containing member as key when creating a ComponentResourceKey.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.ConstructorArgumentAttributeArgumentFixWPF0082,[ConstructorArgument] must match,[ConstructorArgument] must match the name of the constructor parameter.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.ConstructorArgumentAttributeFixWPF0083,Add [ConstructorArgument],Add [ConstructorArgument] for the property.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.ConvertToLambdaFixWPF0023,The callback is trivial convert to lambda,The callback is trivial convert to lambda for better locality.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.DocumentationFixWPF0060,Backing member for DependencyProperty should have standard documentation text,Backing member for DependencyProperty should have standard documentation text.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.DocumentationFixWPF0061,Accessor method for attached property should have standard documentation text,Accessor method for attached property should have standard documentation text.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.DocumentationFixWPF0062,Property changed callback should have standard documentation text,Property changed callback should have standard documentation text.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.DocumentationFixWPF0108,Backing member for RoutedEvent should have standard documentation text,Backing member for RoutedEvent should have standard documentation text.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.MakeFieldStaticReadonlyFixWPF0030,Backing field for a DependencyProperty should be static and readonly,Backing field for a DependencyProperty should be static and readonly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.MakeFieldStaticReadonlyFixWPF0107,Backing member for a RoutedEvent should be static and readonly,Backing member for a RoutedEvent should be static and readonly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.MakeFieldStaticReadonlyFixWPF0123,Backing field for a RoutedCommand should be static and readonly,Backing field for a RoutedCommand should be static and readonly.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.MakeNullableFixWPF0024,Parameter type should be nullable,Parameter type should be nullable.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.MarkupExtensionReturnTypeAttributeFixWPF0080,Add MarkupExtensionReturnType attribute,Add MarkupExtensionReturnType attribute.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.MoveFixWPF0031,DependencyPropertyKey member must be declared before DependencyProperty member,DependencyPropertyKey member must be declared before DependencyProperty member.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.RegisterRoutedCommandFixWPF0122,Register name and owning type for routed command,Register containing type as owner for routed command.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.RenameMemberFixWPF0001,Backing field for a DependencyProperty should match registered name,A dependency property's backing field should be named with the name it is registered with suffixed by 'Property'. This is the convention in the framework.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.RenameMemberFixWPF0002,Backing field for a DependencyPropertyKey should match registered name,A DependencyPropertyKey's backing field must be named with the name it is registered with suffixed by 'PropertyKey'.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.RenameMemberFixWPF0003,CLR property for a DependencyProperty should match registered name,A CLR property accessor for a DependencyProperty must have the same name as the DependencyProperty is registered with.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.RenameMemberFixWPF0004,CLR method for a DependencyProperty must match registered name,CLR methods for accessing a DependencyProperty must have names matching the name the DependencyProperty is registered with.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.RenameMemberFixWPF0005,Name of PropertyChangedCallback should match registered name,Name of PropertyChangedCallback should match registered name.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.RenameMemberFixWPF0006,Name of CoerceValueCallback should match registered name,Name of CoerceValueCallback should match registered name.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.RenameMemberFixWPF0007,Name of ValidateValueCallback should match registered name,Name of ValidateValueCallback should match registered name.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.RenameMemberFixWPF0090,Name the invoked method OnEventName,Name the invoked method OnEventName.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.RenameMemberFixWPF0091,Name the invoked method OnEventName,Name the invoked method OnEventName.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.RenameMemberFixWPF0100,Backing field for a RoutedEvent should match registered name,A routed event's backing field should be named with the name it is registered with suffixed by 'Event'.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.RenameMemberFixWPF0102,Name of the event should match registered name,Name of the event should match registered name.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.UseContainingTypeFixWPF0011,Containing type should be used as registered owner,When registering a DependencyProperty register containing type as owner type.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.UseContainingTypeFixWPF0101,Containing type should be used as registered owner,When registering a RoutedEvent register containing type as owner type.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.UseContainingTypeFixWPF0121,Register containing type as owner for routed command,Register containing type as owner for routed command.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.UseCorrectDelegateFixWPF0092,Use correct handler type,Use correct handler type.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.UseDependencyPropertyKeyFixWPF0040,A readonly DependencyProperty must be set with DependencyPropertyKey,A readonly DependencyProperty must be set with DependencyPropertyKey.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.UseNameofFixWPF0120,Register containing member name as name for routed command,Register containing member name as name for routed command.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.UseNameofFixWPF0150,Use nameof() instead of literal,Use nameof() as it is less fragile than string literal.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.UseNameofFixWPF0151,Use nameof() instead of constant,Use nameof() as it is less fragile than constant.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.UseRegisteredTypeFixWPF0012,CLR property type should match registered type,CLR property type should match registered type.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.UseRegisteredTypeFixWPF0013,CLR accessor for attached property must match registered type,CLR accessor for attached property must match registered type.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.UseSetCurrentValueFixWPF0041,Set mutable dependency properties using SetCurrentValue,Prefer setting mutable dependency properties using SetCurrentValue.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.UseSetValueFixWPF0035,Use SetValue in setter,Use SetValue in setter.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.UseSetValueFixWPF0043,Don't set DataContext and Style using SetCurrentValue,Set DataContext and Style using SetValue.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.ValueConversionAttributeArgumentFixWPF0072,ValueConversion must use correct types,ValueConversion must use correct types.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.ValueConversionAttributeFixWPF0073,Add ValueConversion attribute (unknown types),Add ValueConversion attribute (unknown types).,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.csharp.recipes.wpfanalyzers.XmlnsDefinitionFixWPF0052,XmlnsDefinitions does not map all namespaces with public types,XmlnsDefinitions does not map all namespaces with public types.,org.openrewrite:rewrite-csharp:0.31.0-20251015.184033-21 +org.openrewrite.gradle.ChangeDependency,Change Gradle dependency,Change a Gradle dependency coordinates. The `newGroupId` or `newArtifactId` **MUST** be different from before.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.ChangeDependencyArtifactId,Change Gradle dependency artifact,Change the artifact of a specified Gradle dependency.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.ChangeDependencyClassifier,Change a Gradle dependency classifier,Changes classifier of an existing dependency declared in `build.gradle` files.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.ChangeDependencyConfiguration,Change a Gradle dependency configuration,A common example is the need to change `compile` to `api`/`implementation` as [part of the move](https://docs.gradle.org/current/userguide/upgrading_version_6.html) to Gradle 7.x and later.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.ChangeDependencyExtension,Change a Gradle dependency extension,Changes extension of an existing dependency declared in `build.gradle` files.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.ChangeDependencyGroupId,Change Gradle dependency group,Change the group of a specified Gradle dependency.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.ChangeExtraProperty,Change Extra Property,Gradle's [ExtraPropertiesExtension](https://docs.gradle.org/current/dsl/org.gradle.api.plugins.ExtraPropertiesExtension.html) is a commonly used mechanism for setting arbitrary key/value pairs on a project. This recipe will change the value of a property with the given key name if that key can be found. It assumes that the value being set is a String literal. Does not add the value if it does not already exist.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.ChangeManagedDependency,Change Gradle managed dependency,Change a Gradle managed dependency coordinates. The `newGroupId` or `newArtifactId` **MUST** be different from before. For now only Spring Dependency Management Plugin entries are supported and no other forms of managed dependencies (yet).,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.DependencyConstraintToRule,Dependency constraint to resolution rule,Gradle [dependency constraints](https://docs.gradle.org/current/userguide/dependency_constraints.html#dependency-constraints) are useful for managing the versions of transitive dependencies. Some plugins such as the Spring Dependency Management plugin do not respect these constraints. This recipe converts constraints into [resolution rules](https://docs.gradle.org/current/userguide/resolution_rules.html) which can achieve similar effects to constraints but are harder for plugins to ignore.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.DependencyUseMapNotation,Use `Map` notation for Gradle dependency declarations,In Gradle dependencies can be expressed as a `String` like `"groupId:artifactId:version"` or equivalently as a `Map` like `group: 'groupId' name: 'artifactId' version: 'version'` (groovy) or `group = "groupId" name = "artifactId" version = "version"` (kotlin). This recipe replaces dependencies represented as `Strings` with an equivalent dependency represented as a `Map`.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.DependencyUseStringNotation,Use `String` notation for Gradle dependency declarations,In Gradle dependencies can be expressed as a `String` like `"groupId:artifactId:version"` or equivalently as a `Map` like `group: 'groupId' name: 'artifactId' version: 'version'`. This recipe replaces dependencies represented as `Maps` with an equivalent dependency represented as a `String` as recommended per the [Gradle best practices for dependencies to use a single GAV](https://docs.gradle.org/8.14.2/userguide/best_practices_dependencies.html#single-gav-string).,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.EnableDevelocityBuildCache,Enable Develocity build cache,Adds `buildCache` configuration to `develocity` where not yet present.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.RemoveDependency,Remove a Gradle dependency,Removes a single dependency from the dependencies section of the `build.gradle`.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.RemoveEnableFeaturePreview,Remove an enabled Gradle preview feature,Remove an enabled Gradle preview feature from `settings.gradle`.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.RemoveExtension,Remove build extension by name,Remove a Gradle build extension from `settings.gradle(.kts)` or `build.gradle(.kts)` files.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.RemoveRedundantDependencyVersions,Remove redundant explicit dependencies and versions,Remove explicitly-specified dependency versions that are managed by a Gradle `platform` `enforcedPlatform` or the `io.spring.dependency-management` plugin. Also removes redundant direct dependencies and dependency constraints that are already satisfied by transitive dependencies.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.RemoveRepository,Remove repository,Removes a repository from Gradle build scripts. Named repositories include "jcenter" "mavenCentral" "mavenLocal" and "google".,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.UpdateJavaCompatibility,Update Gradle project Java compatibility,Find and updates the Java compatibility for the Gradle project.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.gradle8.JacocoReportDeprecations,Replace Gradle 8 introduced deprecations in JaCoCo report task,Set the `enabled` to `required` and the `destination` to `outputLocation` for Reports deprecations that were removed in gradle 8. See [the gradle docs on this topic](https://docs.gradle.org/current/userguide/upgrading_version_7.html#report_and_testreport_api_cleanup).,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.plugins.AddBuildPlugin,Add Gradle plugin,Add a build plugin to a Gradle build file's `plugins` block.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.plugins.AddDevelocityGradlePlugin,Add the Develocity Gradle plugin,Add the Develocity Gradle plugin to settings.gradle files.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.plugins.AddSettingsPlugin,Add Gradle settings plugin,Add plugin to Gradle settings file `plugins` block by id.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.plugins.AddSettingsPluginRepository,Add a Gradle settings repository,Add a Gradle settings repository to `settings.gradle(.kts)`.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.plugins.ChangePlugin,Change a Gradle plugin,Changes the selected Gradle plugin to the new plugin.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.plugins.ChangePluginVersion,Change a Gradle plugin version by id,Change a Gradle plugin by id to a later version.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.plugins.MigrateGradleEnterpriseToDevelocity,Migrate from Gradle Enterprise to Develocity,Migrate from the Gradle Enterprise Gradle plugin to the Develocity Gradle plugin.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.plugins.RemoveBuildPlugin,Remove Gradle plugin,Remove plugin from Gradle `plugins` block by its id. Does not remove plugins from the `buildscript` block.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.plugins.RemoveDevelocityConfiguration,Remove Develocity configuration,Remove Develocity configuration from a Gradle build.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.plugins.RemoveSettingsPlugin,Remove Gradle settings plugin,Remove plugin from Gradle settings file `plugins` block by id.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.search.DependencyInsight,Gradle dependency insight,Find direct and transitive dependencies matching a group artifact resolved version and optionally a configuration name. Results include dependencies that either directly match or transitively include a matching dependency.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.search.DoesNotIncludeDependency,Does not include Gradle dependency,A precondition which returns false if visiting a Gradle file which includes the specified dependency in the classpath of some scope. For compatibility with multimodule projects this should most often be applied as a precondition.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.search.FindDependency,Find Gradle dependency,Finds dependencies declared in gradle build files. See the [reference](https://docs.gradle.org/current/userguide/java_library_plugin.html#sec:java_library_configurations_graph) on Gradle configurations or the diagram below for a description of what configuration to use. A project's compile and runtime classpath is based on these configurations. Gradle compile classpath A project's test classpath is based on these configurations. Gradle test classpath.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.search.FindDependencyHandler,Find Gradle `dependencies` blocks,Find the dependency handler containing any number of dependency definitions.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.search.FindGradleProject,Find Gradle projects,Gradle projects are those with `build.gradle` or `build.gradle.kts` files.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.search.FindGradleWrapper,Find Gradle wrappers,Find Gradle wrappers.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.search.FindJVMTestSuites,Find Gradle JVMTestSuite plugin configuration,Find Gradle JVMTestSuite plugin configurations and produce a data table.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.search.FindPlugins,Find Gradle plugin,Find a Gradle plugin by id and/or class name. For best results both should be specified as one cannot automatically be used to infer the other.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.search.FindRepository,Find Gradle repository,Find a Gradle repository by url.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.security.UseHttpsForRepositories,Use HTTPS for repositories,Use HTTPS for repository URLs.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.AddDependency,Add Gradle dependency,Add a gradle dependency to a `build.gradle` file in the correct configuration based on where it is used.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.AddPlatformDependency,Add Gradle platform dependency,Add a gradle platform dependency to a `build.gradle` file in the correct configuration based on where it is used.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.AddProperty,Add Gradle property,Add a property to the `gradle.properties` file.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.UpdateGradleWrapper,Update Gradle wrapper,Update the version of Gradle used in an existing Gradle wrapper. Queries services.gradle.org to determine the available releases but prefers the artifact repository URL which already exists within the wrapper properties file. If your artifact repository does not contain the same Gradle distributions as services.gradle.org then the recipe may suggest a version which is not available in your artifact repository.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.UpgradeDependencyVersion,Upgrade Gradle dependency versions,Upgrade the version of a dependency in a build.gradle file. Supports updating dependency declarations of various forms: * `String` notation: `"group:artifact:version"` * `Map` notation: `group: 'group' name: 'artifact' version: 'version'` Can update version numbers which are defined earlier in the same file in variable declarations.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.UpgradeTransitiveDependencyVersion,Upgrade transitive Gradle dependencies,Upgrades the version of a transitive dependency in a Gradle build file. There are many ways to do this in Gradle so the mechanism for upgrading a transitive dependency must be considered carefully depending on your style of dependency management.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.plugins.UpgradePluginVersion,Update a Gradle plugin by id,Update a Gradle plugin by id to a later version defined by the plugins DSL. To upgrade a plugin dependency defined by `buildscript.dependencies` use the `UpgradeDependencyVersion` recipe instead.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.search.ModuleHasDependency,Module has dependency,Searches for Gradle Projects (modules) that have a dependency matching the specified id or implementing class. Places a `SearchResult` marker on all sources within a project with a matching dependency. This recipe is intended to be used as a precondition for other recipes. For example this could be used to limit the application of a spring boot migration to only projects that use spring-boot-starter limiting unnecessary upgrading. If the search result you want is instead just the build.gradle(.kts) file that use the dependency use the `FindDependency` recipe instead.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.search.ModuleHasPlugin,Module has plugin,Searches for Gradle Projects (modules) that have a plugin matching the specified id or implementing class. Places a `SearchResult` marker on all sources within a project with a matching plugin. This recipe is intended to be used as a precondition for other recipes. For example this could be used to limit the application of a spring boot migration to only projects that apply the spring dependency management plugin limiting unnecessary upgrading. If the search result you want is instead just the build.gradle(.kts) file applying the plugin use the `FindPlugins` recipe instead.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.MigrateToGradle8,Migrate to Gradle 8 from Gradle 7,Migrate to version 8.x. See the Gradle upgrade guide from [version 7.x to 8.0](https://docs.gradle.org/current/userguide/upgrading_version_7.html) and [version 8.x to latest](https://docs.gradle.org/current/userguide/upgrading_version_8.html) for more information.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.AddJUnitPlatformLauncher,Add JUnit Platform Launcher,Add the JUnit Platform Launcher to the buildscript dependencies.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.MigrateToGradle5,Migrate to Gradle 5 from Gradle 4,Migrate to version 5.x. See the Gradle upgrade guide from [version 4.x to 5.0](https://docs.gradle.org/current/userguide/upgrading_version_4.html) for more information.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.GradleBestPractices,Apply Gradle best practices,Apply a set of [Gradle best practices](https://docs.gradle.org/current/userguide/best_practices_general.html) to the build files for more efficient and ideomatic builds.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.EnableGradleBuildCache,Enable Gradle build cache,Enable the Gradle build cache. By enabling build cache the build outputs are stored externally and fetched from the cache when it is determined that those inputs have no changed avoiding the expensive work of regenerating them. See the [Gradle Build Cache](https://docs.gradle.org/current/userguide/build_cache.html) for more information.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.EnableGradleParallelExecution,Enable Gradle parallel execution,Most builds consist of more than one project and some of those projects are usually independent of one another. Yet Gradle will only run one task at a time by default regardless of the project structure. By using the `--parallel` switch you can force Gradle to execute tasks in parallel as long as those tasks are in different projects. See the [Gradle performance documentation](https://docs.gradle.org/current/userguide/performance.html#parallel_execution) for more information.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.plugins.RemoveDevelocity,Remove Develocity,Remove the Develocity plugin and configuration from the Gradle build and settings files.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.MigrateToGradle6,Migrate to Gradle 6 from Gradle 5,Migrate to version 6.x. See the Gradle upgrade guide from [version 5.x to 6.0](https://docs.gradle.org/current/userguide/upgrading_version_5.html) for more information.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.MigrateToGradle7,Migrate to Gradle 7 from Gradle 6,Migrate to version 7.x. See the Gradle upgrade guide from [version 6.x to 7.0](https://docs.gradle.org/current/userguide/upgrading_version_6.html) for more information.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.gradle.MigrateToGradle9,Migrate to Gradle 9 from Gradle 8,Migrate to version 9.x. See the Gradle upgrade guide from [version 8.x to 9.0](https://docs.gradle.org/9.0.0/userguide/upgrading_major_version_9.html) for more information.,org.openrewrite:rewrite-gradle:8.65.0-20251023.122421-9 +org.openrewrite.groovy.format.AutoFormat,Format Groovy code,Format Groovy code using a standard comprehensive set of Groovy formatting recipes.,org.openrewrite:rewrite-groovy:8.64.0-20251021.195831-50 +org.openrewrite.groovy.format.GStringCurlyBraces,Groovy GString curly braces,In Groovy [GStrings](https://docs.groovy-lang.org/latest/html/api/groovy/lang/GString.html) curly braces are optional for single variable expressions. This recipe adds them so that the expression is always surrounded by curly braces.,org.openrewrite:rewrite-groovy:8.64.0-20251021.195831-50 +org.openrewrite.groovy.format.OmitParenthesesForLastArgumentLambda,Move a closure which is the last argument of a method invocation out of parentheses,Groovy allows a shorthand syntax that allows a closure to be placed outside of parentheses.,org.openrewrite:rewrite-groovy:8.64.0-20251021.195831-50 +org.openrewrite.groovy.format.OmitParenthesesFormat,Stylize Groovy code to omit parentheses,Omit parentheses for last argument lambdas in Groovy code.,org.openrewrite:rewrite-groovy:8.64.0-20251021.195831-50 +org.openrewrite.hcl.DeleteContent,Delete content,Delete HCL content by path.,org.openrewrite:rewrite-hcl:8.64.0-20251021.195831-50 +org.openrewrite.hcl.ReplaceLegacyAttributeIndexSyntax,Replace legacy attribute index syntax,Replace legacy attribute index syntax (`.0`) with the new syntax (`[0]`).,org.openrewrite:rewrite-hcl:8.64.0-20251021.195831-50 +org.openrewrite.hcl.format.AutoFormat,Format HCL code,Format HCL code using a standard comprehensive set of HCL formatting recipes.,org.openrewrite:rewrite-hcl:8.64.0-20251021.195831-50 +org.openrewrite.hcl.format.BlankLines,Blank lines,Add and/or remove blank lines.,org.openrewrite:rewrite-hcl:8.64.0-20251021.195831-50 +org.openrewrite.hcl.format.NormalizeFormat,Normalize format,Move whitespace to the outermost LST element possible.,org.openrewrite:rewrite-hcl:8.64.0-20251021.195831-50 +org.openrewrite.hcl.format.RemoveTrailingWhitespace,Remove trailing whitespace,Remove any extra trailing whitespace from the end of each line.,org.openrewrite:rewrite-hcl:8.64.0-20251021.195831-50 +org.openrewrite.hcl.format.Spaces,Spaces,Format whitespace in HCL code.,org.openrewrite:rewrite-hcl:8.64.0-20251021.195831-50 +org.openrewrite.hcl.format.TabsAndIndents,Tabs and indents,Format tabs and indents in HCL code.,org.openrewrite:rewrite-hcl:8.64.0-20251021.195831-50 +org.openrewrite.hcl.search.FindAndReplaceLiteral,Find and replace literals in HCL files,Find and replace literal values in HCL files. This recipe parses the source files on which it runs as HCL meaning you can execute HCL language-specific recipes before and after this recipe in a single recipe run.,org.openrewrite:rewrite-hcl:8.64.0-20251021.195831-50 +org.openrewrite.hcl.search.FindContent,Find content,Find HCL content by path.,org.openrewrite:rewrite-hcl:8.64.0-20251021.195831-50 +org.openrewrite.hcl.MoveContentToFile,Move content to another file,Move content to another HCL file deleting it in the original file.,org.openrewrite:rewrite-hcl:8.64.0-20251021.195831-50 +org.openrewrite.java.AddCommentToImport,Add comment to import statement,Add a comment to an import statement in a Java source file.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.AddCommentToMethod,Add comment to method declarations,Add a comment to method declarations in a Java source file.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.AddCommentToMethodInvocations,Add comment to method invocations,Add a comment to method invocations in a Java source file.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.AddLicenseHeader,Add license header,Adds license headers to Java source files when missing. Does not override existing license headers.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.AddLiteralMethodArgument,Add a literal method argument,Add a literal `String` or `int` argument to method invocations.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.AddMethodParameter,Add method parameter to a method declaration,Adds a new method parameter to an existing method declaration.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.AddNullMethodArgument,Add a `null` method argument,Add a `null` argument to method invocations.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.AddOrUpdateAnnotationAttribute,Add or update annotation attribute,Some annotations accept arguments. This recipe sets an existing argument to the specified value or adds the argument if it is not already set.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ChangeAnnotationAttributeName,Change annotation attribute name,Some annotations accept arguments. This recipe renames an existing attribute.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ChangeMethodAccessLevel,Change method access level,Change the access level (public protected private package private) of a method.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ChangeMethodInvocationReturnType,Change method invocation return type,Changes the return type of a method invocation.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ChangeMethodName,Change method name,Rename a method.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ChangeMethodTargetToStatic,Change method target to static,Change method invocations to static method calls.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ChangeMethodTargetToVariable,Change method target to variable,Change method invocations to method calls on a variable.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ChangePackage,Rename package name,A recipe that will rename a package name in package statements imports and fully-qualified types.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ChangePackageInStringLiteral,Rename package name in String literals,A recipe that will rename a package name in String literals.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ChangeStaticFieldToMethod,Change static field access to static method access,Migrate accesses to a static field to invocations of a static method.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ChangeType,Change type,Change a given type to another.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ChangeTypeInStringLiteral,Change type in String literals,Change a given type to another when used in a String literal.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.DeleteMethodArgument,Delete method argument,Delete an argument from method invocations.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.InlineMethodCalls,Inline method calls,Inline method calls using a template replacement pattern. Supports both method invocations and constructor calls with optional imports.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.NoStaticImport,Remove static import,Removes static imports and replaces them with qualified references. For example `emptyList()` becomes `Collections.emptyList()`.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.OrderImports,Order imports,Groups and orders import statements. If a [style has been defined](https://docs.openrewrite.org/concepts-and-explanations/styles) this recipe will order the imports according to that style. If no style is detected this recipe will default to ordering imports in the same way that IntelliJ IDEA does.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.RandomizeId,Randomize tree IDs,Scramble the IDs. This was intended as a utility to test _en masse_ different techniques for UUID generation and compare their relative performance outside a microbenchmark.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.RecipeMarkupDemonstration,Demonstrate rendering of `Markup` markers,Tooling may decide to elide or display differently markup of different levels.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.RemoveAnnotation,Remove annotation,Remove matching annotations wherever they occur.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.RemoveAnnotationAttribute,Remove annotation attribute,Some annotations accept arguments. This recipe removes an existing attribute.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.RemoveImplements,Remove interface implementations,Removes `implements` clauses from classes implementing the specified interface. Removes `@Overrides` annotations from methods which no longer override anything.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.RemoveMethodInvocations,Remove method invocations,Remove method invocations if syntactically safe.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.RemoveObjectsIsNull,Transform calls to `Objects.isNull(..)` and `Objects.nonNull(..)`,Replace calls to `Objects.isNull(..)` and `Objects.nonNull(..)` with a simple null check. Using these methods outside of stream predicates is not idiomatic.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.RemoveUnusedImports,Remove unused imports,Remove imports for types that are not referenced. As a precaution against incorrect changes no imports will be removed from any source where unknown types are referenced. The most common cause of unknown types is the use of annotation processors not supported by OpenRewrite such as lombok.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ReorderMethodArguments,Reorder method arguments,Reorder method arguments into the specified order.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ReplaceAnnotation,Replace annotation,Replace an Annotation with another one if the annotation pattern matches. Only fixed parameters can be set in the replacement.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ReplaceConstant,Replace constant with literal value,Replace a named constant with a literal value when you wish to remove the old constant. A `String` literal must include escaped quotes.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ReplaceConstantWithAnotherConstant,Replace constant with another constant,Replace a constant with another constant adding/removing import on class if needed.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ReplaceMethodInvocationWithConstant,Replace method invocation with constant,Replace all method invocations matching the method pattern with the specified constant.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ReplaceStringLiteralValue,Replace `String` literal,Replace the value of a complete `String` literal.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ReplaceStringLiteralWithConstant,Replace String literal with constant,Replace String literal with constant adding import on class if needed.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ShortenFullyQualifiedTypeReferences,Add imports for fully qualified references to types,Any fully qualified references to Java types will be replaced with corresponding simple names and import statements provided that it doesn't result in any conflicts with other imports or types declared in the local compilation unit.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.SimplifyMethodChain,Simplify a call chain,Simplify `a.b().c()` to `a.d()`.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.SimplifySingleElementAnnotation,Simplify single-element annotation,This recipe will remove the attribute `value` on single-element annotations. According to JLS a _single-element annotation_ is a shorthand designed for use with single-element annotation types.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.UpdateSourcePositions,Update source positions,Calculate start position and length for every LST element.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.UseStaticImport,Use static import,Removes unnecessary receiver types from static method invocations. For example `Collections.emptyList()` becomes `emptyList()`.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ai.ClassDefinitionLength,Calculate token length of classes,Locates class definitions and predicts the number of token in each.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.ai.MethodDefinitionLength,Calculate token length of method definitions,Locates method definitions and predicts the number of token in each.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.AutoFormat,Format Java code,Format Java code using a standard comprehensive set of Java formatting recipes.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.BlankLines,Blank lines,Add and/or remove blank lines.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.EmptyNewlineAtEndOfFile,End files with a single newline,Some tools work better when files end with an empty line.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.MethodParamPad,Method parameter padding,Fixes whitespace padding between the identifier of a method definition or method invocation and the left parenthesis of the parameter list. For example when configured to remove spacing `someMethodInvocation (x);` becomes `someMethodInvocation(x)`.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.NoWhitespaceAfter,No whitespace after,Removes unnecessary whitespace appearing after a token. A linebreak after a token is allowed unless `allowLineBreaks` is set to `false` in which case it will be removed.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.NoWhitespaceBefore,No whitespace before,Removes unnecessary whitespace preceding a token. A linebreak before a token will be removed unless `allowLineBreaks` is set to `true`.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.NormalizeFormat,Normalize format,Move whitespace to the outermost LST element possible.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.NormalizeLineBreaks,Normalize line breaks,Consistently use either Windows style (CRLF) or Linux style (LF) line breaks. If no `GeneralFormatStyle` is specified this will use whichever style of line endings are more common.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.NormalizeTabsOrSpaces,Normalize to tabs or spaces,Consistently use either tabs or spaces in indentation.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.PadEmptyForLoopComponents,Pad empty `for` loop components,Fixes padding on empty `for` loop iterators and initializers to match Checkstyle policies.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.RemoveTrailingWhitespace,Remove trailing whitespace,Remove any extra trailing whitespace from the end of each line.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.SingleLineComments,Single line comments begin with a whitespace,Write `// hi` instead of `//hi`.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.Spaces,Spaces,Format whitespace in Java code.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.TabsAndIndents,Tabs and indents,Format tabs and indents in Java code.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.TypecastParenPad,Typecast parentheses padding,Fixes whitespace padding between a typecast type identifier and the enclosing left and right parenthesis. For example when configured to remove spacing `( int ) 0L;` becomes `(int) 0L;`.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.format.WrappingAndBraces,Wrapping and braces,Format line wraps and braces in Java code.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.DoesNotUseType,Check whether a type is **not** in use,Useful as a precondition to skip over compilation units using the argument type.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindAnnotations,Find annotations,Find all annotations matching the annotation pattern.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindClassHierarchy,Find class hierarchy,Discovers all class declarations within a project recording which files they appear in their superclasses and interfaces. That information is then recorded in a data table.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindComments,Find within comments and literals,Find regular expression matches within comments and literals. "Literals" includes string literals character literals and numeric literals.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindCompileErrors,Find compile errors,Compile errors result in a particular LST structure that can be searched for.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindDeprecatedClasses,Find uses of deprecated classes,Find uses of deprecated classes optionally ignoring those classes that are inside deprecated scopes.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindDeprecatedFields,Find uses of deprecated fields,Find uses of deprecated fields in any API.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindDeprecatedMethods,Find uses of deprecated methods,Find uses of deprecated methods in any API.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindDeprecatedUses,Find uses of deprecated classes methods and fields,Find deprecated uses of methods fields and types. Optionally ignore those classes that are inside deprecated scopes.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindEmptyClasses,Find empty classes,Find empty classes without annotations that do not implement an interface or extend a class.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindEmptyMethods,Find methods with empty bodies,Find methods with empty bodies and single public no arg constructors.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindFields,Find fields,Find uses of a field.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindFieldsOfType,Find fields of type,Finds declared fields matching a particular class name.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindImplementations,Find implementing classes,Find class declarations which implement the specified type. If the specified type is a class its subclasses will be matched. If the specified type is an interface classes which implement it will be matched.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindImports,Find source files with imports,Locates source files that have imports matching the given type pattern regardless of whether that import is used in the code.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindLiterals,Find literals,Find literals matching a pattern.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindMethodDeclaration,Find method declaration,Locates the declaration of a method.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindMethods,Find method usages,Find method calls by pattern.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindMissingTypes,Find missing type information on Java LSTs,This is a diagnostic recipe to highlight where LSTs are missing type attribution information.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindRepeatableAnnotations,Find uses of `@Repeatable` annotations,Java 8 introduced the concept of `@Repeatable` annotations.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindTypes,Find types,Find type references by name.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.HasBuildToolVersion,Find files with a particular build tool version,Finds Java source files built with a particular build tool. This is useful especially as a precondition for other recipes.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.HasJavaVersion,Find files compiled at a specific Java version,Finds Java source files matching a particular language level. This is useful especially as a precondition for other recipes.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.HasMethod,Find files that have at least one use of a method,Marks files that have at least one occurrence of a method matching a pattern.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.HasSourceSet,Find files in a source set,Source sets are a way to organize your source code into logical groups. For example Java projects commonly have a `main` source set for application code and a `test` source set for test code. This recipe will find all files in a given source set.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.HasType,Find files that have at least one use of a type,Marks files that have at least one occurrence of a type even if the name of that type doesn't appear in the source code.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.IsLikelyNotTest,Find files that are likely not tests,Sources that do not contain indicators of being or being exclusively for the use in tests. This recipe is simply a negation of the `org.openrewrite.java.search.IsLikelyTest` recipe.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.IsLikelyTest,Find sources that are likely tests,Sources that contain indicators of being or being exclusively for the use in tests. This recipe is not exhaustive but is intended to be a good starting point for finding test sources. Looks at the source set name and types in use; for example looks for uses of JUnit & TestNG annotations/assertions.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.ResultOfMethodCallIgnored,Result of method call ignored,Find locations where the result of the method call is being ignored.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.CreateEmptyJavaClass,Create Java class,Create a new empty Java class.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.ClasspathTypeCounts,Study the size of the classpath by source set,Emit one data table row per source set in a project with the number of types in the source set.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindDistinctMethods,Find distinct methods in use,A sample of every distinct method in use in a repository. The code sample in the method calls data table will be a representative use of the method though there may be many other such uses of the method.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindTypeMappings,Find type mappings,Study the frequency of `J` types and their `JavaType` type attribution.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.HasMinimumJavaVersion,Find the oldest Java version in use,The oldest Java version in use is the lowest Java version in use in any source set of any subproject of a repository. It is possible that for example the main source set of a project uses Java 8 but a test source set uses Java 17. In this case the oldest Java version in use is Java 8.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.search.FindSecrets,Find plain text secrets,Find secrets stored in plain text in code.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.java.AddApache2LicenseHeader,Add ASLv2 license header,Adds the Apache Software License Version 2.0 to Java source files which are missing a license header.,org.openrewrite:rewrite-java:8.65.0-20251023.085903-8 +org.openrewrite.json.AddKeyValue,Add value to JSON Object,Adds a `value` at the specified `keyPath` with the specified `key` if the key doesn't already exist.,org.openrewrite:rewrite-json:8.64.0-20251021.195831-50 +org.openrewrite.json.ChangeKey,Change key,Change a JSON mapping entry key while leaving the value intact.,org.openrewrite:rewrite-json:8.64.0-20251021.195831-50 +org.openrewrite.json.ChangeValue,Change value,Change a JSON mapping entry value leaving the key intact.,org.openrewrite:rewrite-json:8.64.0-20251021.195831-50 +org.openrewrite.json.DeleteKey,Delete key,Delete a JSON mapping entry key.,org.openrewrite:rewrite-json:8.64.0-20251021.195831-50 +org.openrewrite.json.format.AutoFormat,Format JSON,Format JSON code using a standard comprehensive set of JSON formatting recipes.,org.openrewrite:rewrite-json:8.64.0-20251021.195831-50 +org.openrewrite.json.format.Indents,JSON indent,Format tabs and indents in JSON.,org.openrewrite:rewrite-json:8.64.0-20251021.195831-50 +org.openrewrite.json.format.WrappingAndBraces,JSON new lines,Split members into separate lines in JSON.,org.openrewrite:rewrite-json:8.64.0-20251021.195831-50 +org.openrewrite.json.search.FindKey,Find JSON object members,Find JSON object members by JsonPath expression.,org.openrewrite:rewrite-json:8.64.0-20251021.195831-50 +org.openrewrite.json.CreateJsonFile,Create JSON file,Create a new JSON file.,org.openrewrite:rewrite-json:8.64.0-20251021.195831-50 +org.openrewrite.kotlin.FindKotlinSources,Find Kotlin sources and collect data metrics,Use data table to collect source files types and counts of files with extensions `.kt`.,org.openrewrite:rewrite-kotlin:8.64.0-20251021.195831-50 +org.openrewrite.kotlin.RenameTypeAlias,Rename type alias,Change the name of a given type alias.,org.openrewrite:rewrite-kotlin:8.64.0-20251021.195831-50 +org.openrewrite.kotlin.cleanup.EqualsMethodUsage,Structural equality tests should use `==` or `!=`,In Kotlin `==` means structural equality and `!=` structural inequality and both map to the left-side term’s `equals()` function. It is therefore redundant to call `equals()` as a function. Also `==` and `!=` are more general than `equals()` and `!equals()` because it allows either of both operands to be `null`. Developers using `equals()` instead of `==` or `!=` is often the result of adapting styles from other languages like Java where `==` means reference equality and `!=` means reference inequality. The `==` and `!=` operators are a more concise and elegant way to test structural equality than calling a function.,org.openrewrite:rewrite-kotlin:8.64.0-20251021.195831-50 +org.openrewrite.kotlin.cleanup.ImplicitParameterInLambda,`it` shouldn't be used as a lambda parameter name,`it` is a special identifier that allows you to refer to the current parameter being passed to a lambda expression without explicitly naming the parameter. Lambda expressions are a concise way of writing anonymous functions. Many lambda expressions have only one parameter when this is true the compiler can determine the parameter type by context. Thus when using it with single parameter lambda expressions you do not need to declare the type.,org.openrewrite:rewrite-kotlin:8.64.0-20251021.195831-50 +org.openrewrite.kotlin.cleanup.RemoveLambdaArgumentParentheses,Remove method invocation parentheses around single lambda argument,For example convert `1.let({ it + 1 })` to `1.let { it + 1 }`.,org.openrewrite:rewrite-kotlin:8.64.0-20251021.195831-50 +org.openrewrite.kotlin.cleanup.RemoveTrailingComma,Remove trailing comma in Kotlin,Remove trailing commas in variable parameter and class property lists.,org.openrewrite:rewrite-kotlin:8.64.0-20251021.195831-50 +org.openrewrite.kotlin.cleanup.RemoveTrailingSemicolon,Remove unnecessary trailing semicolon,Some Java programmers may mistakenly add semicolons at the end when writing Kotlin code but in reality they are not necessary.,org.openrewrite:rewrite-kotlin:8.64.0-20251021.195831-50 +org.openrewrite.kotlin.cleanup.ReplaceCharToIntWithCode,Replace `Char#toInt()` with `Char#code`,Replace the usage of the deprecated `Char#toInt()` with `Char#code`. Please ensure that your Kotlin version is 1.5 or later to support the `Char#code` property. Note that the current implementation does not perform a Kotlin version check.,org.openrewrite:rewrite-kotlin:8.64.0-20251021.195831-50 +org.openrewrite.kotlin.cleanup.UnnecessaryTypeParentheses,Remove unnecessary parentheses on Kotlin types,In Kotlin it's possible to add redundant nested parentheses in type definitions. This recipe is designed to remove those unnecessary parentheses.,org.openrewrite:rewrite-kotlin:8.64.0-20251021.195831-50 +org.openrewrite.kotlin.format.AutoFormat,Format Kotlin code,Format Kotlin code using a standard comprehensive set of Kotlin formatting recipes.,org.openrewrite:rewrite-kotlin:8.64.0-20251021.195831-50 +org.openrewrite.maven.AddAnnotationProcessor,Add an annotation processor to `maven-compiler-plugin`,Add an annotation processor to the maven compiler plugin. Will not do anything if it already exists. Also doesn't add anything when no other annotation processors are defined yet. (Perhaps `ChangePluginConfiguration` can be used).,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.AddCommentToMavenDependency,Add a comment to a `Maven` dependency,Adds a comment as the first element in a `Maven` dependency.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.AddParentPom,Add Maven parent,Add a parent pom to a Maven pom.xml. Does nothing if a parent pom is already present.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.AddPlugin,Add Maven plugin,Add the specified Maven plugin to the pom.xml.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.AddPluginDependency,Add Maven plugin dependencies,Adds the specified dependencies to a Maven plugin. Will not add the plugin if it does not already exist in the pom.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.AddProfile,Add Maven profile,Add a maven profile to a `pom.xml` file.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.AddProperty,Add Maven project property,Add a new property to the Maven project property. Prefers to add the property to the parent if the project has multiple modules.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.AddRepository,Add repository,Adds a new Maven Repository or updates a matching repository.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ChangeDependencyClassifier,Change Maven dependency classifier,Add or alter the classifier of the specified dependency.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ChangeDependencyGroupIdAndArtifactId,Change Maven dependency,Change a Maven dependency coordinates. The `newGroupId` or `newArtifactId` **MUST** be different from before. Matching `` coordinates are also updated if a `newVersion` or `versionPattern` is provided.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ChangeDependencyScope,Change Maven dependency scope,Add or alter the scope of the specified dependency.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ChangeManagedDependencyGroupIdAndArtifactId,Change Maven managed dependency groupId artifactId and optionally the version,Change the groupId artifactId and optionally the version of a specified Maven managed dependency.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ChangePackaging,Set Maven project packaging,Sets the packaging type of Maven projects. Either adds the packaging tag if it is missing or changes its context if present.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ChangeParentPom,Change Maven parent,Change the parent pom of a Maven pom.xml by matching the existing parent via groupId and artifactId and updating it to a new groupId artifactId version and optional relativePath. Also updates the project to retain dependency management and properties previously inherited from the old parent that are no longer provided by the new parent. Removes redundant dependency versions already managed by the new parent.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ChangePluginConfiguration,Change Maven plugin configuration,Apply the specified configuration to a Maven plugin. Will not add the plugin if it does not already exist in the pom.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ChangePluginDependencies,Change Maven plugin dependencies,Applies the specified dependencies to a Maven plugin. Will not add the plugin if it does not already exist in the pom.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ChangePluginExecutions,Change Maven plugin executions,Apply the specified executions to a Maven plugin. Will not add the plugin if it does not already exist in the pom.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ChangePluginGroupIdAndArtifactId,Change Maven plugin group and artifact ID,Change the groupId and/or the artifactId of a specified Maven plugin. Optionally update the plugin version. This recipe does not perform any validation and assumes all values passed are valid.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ChangeProjectVersion,Change Maven Project Version,Change the project version of a Maven pom.xml. Identifies the project to be changed by its groupId and artifactId. If the version is defined as a property this recipe will only change the property value if the property exists within the same pom.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ChangePropertyValue,Change Maven project property value,Changes the specified Maven project property value leaving the key intact.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.EnableDevelocityBuildCache,Enable Develocity build cache,Add Develocity build cache configuration to any `.mvn/` Develocity configuration file that lack existing configuration.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ExcludeDependency,Exclude Maven dependency,Exclude specified dependency from any dependency that transitively includes it.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ManagedToRuntimeDependencies,Convert managed dependencies to runtime dependencies,This recipe processes Maven POMs converting all `` entries into runtime scoped `` entries. Import scoped BOMs (like jackson-bom) are left unmodified in ``. Some style guidelines prefer that `` be used only for BOMs. This maintain that style while avoiding introducing new symbols onto the compile classpath unintentionally.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ModernizeObsoletePoms,Modernize obsolete Maven poms,Very old Maven poms are no longer supported by current versions of Maven. This recipe updates poms with `3` to `4.0.0` of the Maven pom schema. This does not attempt to upgrade old dependencies or plugins and is best regarded as the starting point of a migration rather than an end-point.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.OrderPomElements,Order POM elements,Order POM elements according to the [recommended](https://maven.apache.org/developers/conventions/code.html#pom-code-convention) order.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.RemoveDependency,Remove Maven dependency,Removes a single dependency from the section of the pom.xml.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.RemoveDuplicateDependencies,Remove duplicate Maven dependencies,Removes duplicated dependencies in the `` and `` sections of the `pom.xml`.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.RemoveDuplicatePluginDeclarations,Remove duplicate plugin declarations,Maven 4 rejects duplicate plugin declarations (same groupId and artifactId) with an error. This recipe removes duplicate plugin declarations keeping only the first occurrence.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.RemoveExclusion,Remove exclusion,Remove any matching exclusion from any matching dependency.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.RemoveManagedDependency,Remove Maven managed dependency,Removes a single managed dependency from the section of the pom.xml.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.RemovePlugin,Remove Maven plugin,Remove the specified Maven plugin from the POM.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.RemovePluginDependency,Remove Maven plugin dependency,Removes a dependency from the section of a plugin in the pom.xml.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.RemoveProperty,Remove Maven project property,Removes the specified Maven project property from the pom.xml.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.RemoveRedundantDependencyVersions,Remove redundant explicit dependency and plugin versions,Remove explicitly-specified dependency/plugin versions when a parent POM's `dependencyManagement`/`pluginManagement` specifies the version.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.RemoveRedundantProperties,Remove redundant properties,Remove properties when a parent POM specifies the same property.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.RemoveRepository,Remove repository,Removes a matching Maven repository.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.RenamePropertyKey,Rename Maven property key,Rename the specified Maven project property key leaving the value unchanged.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.UpdateMavenProjectPropertyJavaVersion,Update Maven Java project properties,The Java version is determined by several project properties including: * `java.version` * `jdk.version` * `javaVersion` * `jdkVersion` * `maven.compiler.source` * `maven.compiler.target` * `maven.compiler.release` * `release.version` If none of these properties are in use and the maven compiler plugin is not otherwise configured adds the `maven.compiler.release` property.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.UpdateScmFromGitOrigin,Update SCM with Git origin,Updates or adds the Maven `` tag based on the Git remote origin. By default only existing Source Control Management (SCM) sections are updated. Set `addIfMissing` to `true` to also add missing SCM sections.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.UpgradeParentVersion,Upgrade Maven parent project version,Set the parent pom version number according to a [version selector](https://docs.openrewrite.org/reference/dependency-version-selectors) or to a specific version number.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.UpgradePluginVersion,Upgrade Maven plugin version,Upgrade the version of a plugin using Node Semver advanced range selectors allowing more precise control over version updates to patch or minor releases.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.UseMavenCompilerPluginReleaseConfiguration,Use Maven compiler plugin release configuration,Replaces any explicit `source` or `target` configuration (if present) on the `maven-compiler-plugin` with `release` and updates the `release` value if needed. Will not downgrade the Java version if the current version is higher.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.UseParentInference,Use Maven 4 parent inference,Maven 4.1.0 supports automatic parent version inference when using a relative path. This recipe simplifies parent declarations by using the shorthand `` form when the parent is in the default location (`..`) removing the explicit `` `` `` and `` elements. Maven automatically infers these values from the parent POM.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.cleanup.DependencyManagementDependencyRequiresVersion,Dependency management dependencies should have a version,If they don't have a version they can't possibly affect dependency resolution anywhere and can be safely removed.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.cleanup.ExplicitPluginGroupId,Add explicit `groupId` to Maven plugins,Add the default `org.apache.maven.plugins` to plugins for clarity.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.cleanup.ExplicitPluginVersion,Add explicit plugin versions,Add explicit plugin versions to POMs for reproducibility as [MNG-4173](https://issues.apache.org/jira/browse/MNG-4173) removes automatic version resolution for POM plugins.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.plugin.DependencyPluginGoalResolveSources,Migrate to `maven-dependency-plugin` goal `resolve-sources`,Migrate from `sources` to `resolve-sources` for the `maven-dependency-plugin`.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.DependencyInsight,Maven dependency insight,Find direct and transitive dependencies matching a group artifact and scope. Results include dependencies that either directly match or transitively include a matching dependency.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.DoesNotIncludeDependency,Does not include Maven dependency,A precondition which returns false if visiting a Maven pom which includes the specified dependency in the classpath of some scope. For compatibility with multimodule projects this should most often be applied as a precondition.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.EffectiveDependencies,Effective dependencies,Emit the data of binary dependency relationships.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.EffectiveManagedDependencies,Effective managed dependencies,Emit the data of binary dependency relationships.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.EffectiveMavenRepositories,List effective Maven repositories,Lists the Maven repositories that would be used for dependency resolution in order of precedence. This includes Maven repositories defined in the Maven settings file (and those contributed by active profiles) as determined when the LST was produced.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.FindDependency,Find Maven dependency,Finds first-order dependency uses i.e. dependencies that are defined directly in a project.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.FindManagedDependency,Find Maven dependency management entry,Finds first-order dependency management entries i.e. dependencies that are defined directly in a project.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.FindMavenProject,Find Maven projects,Maven projects are `pom.xml` files with a `MavenResolutionResult` marker.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.FindMavenSettings,Find effective maven settings,List the effective maven settings file for the current project.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.FindPlugin,Find Maven plugin,Finds a Maven plugin within a pom.xml.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.FindProperties,Find Maven project properties,Finds the specified Maven project properties within a pom.xml.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.FindRepositoryOrder,Maven repository order,Determine the order in which dependencies will be resolved for each `pom.xml` based on its defined repositories and effective `settings.xml`.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.FindScm,Find SCM tag,Finds any `` tag directly inside the `` root of a Maven pom.xml file.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.ParentPomInsight,Maven parent insight,Find Maven parents matching a `groupId` and `artifactId`.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.security.UseHttpsForRepositories,Use HTTPS for repositories,Use HTTPS for repository URLs.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.utilities.PrintMavenAsDot,Print Maven dependency hierarchy in DOT format,The DOT language format is specified [here](https://graphviz.org/doc/info/lang.html).,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.AddDependency,Add Maven dependency,Add a Maven dependency to a `pom.xml` file in the correct scope based on where it is used.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.AddDevelocityMavenExtension,Add the Develocity Maven extension,To integrate the Develocity Maven extension into Maven projects ensure that the `develocity-maven-extension` is added to the `.mvn/extensions.xml` file if not already present. Additionally configure the extension by adding the `.mvn/develocity.xml` configuration file.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.AddManagedDependency,Add managed Maven dependency,Add a managed Maven dependency to a `pom.xml` file.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.AddRuntimeConfig,Add a configuration option for the Maven runtime,Add a new configuration option for the Maven runtime if not already present.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.IncrementProjectVersion,Increment Maven project version,Increase Maven project version by incrementing either the major minor or patch version as defined by [semver](https://semver.org/). Other versioning schemes are not supported.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ManageDependencies,Manage dependencies,Make existing dependencies managed by moving their version to be specified in the dependencyManagement section of the POM.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.RemoveUnusedProperties,Remove unused properties,Detect and remove Maven property declarations which do not have any usage within the project.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.UpdateMavenWrapper,Update Maven wrapper,Update the version of Maven used in an existing Maven wrapper.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.UpgradeDependencyVersion,Upgrade Maven dependency version,Upgrade the version of a dependency by specifying a group and (optionally) an artifact using Node Semver advanced range selectors allowing more precise control over version updates to patch or minor releases.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.UpgradeTransitiveDependencyVersion,Upgrade transitive Maven dependencies,Upgrades the version of a transitive dependency in a Maven pom file. Leaves direct dependencies unmodified. Can be paired with the regular Upgrade Dependency Version recipe to upgrade a dependency everywhere regardless of whether it is direct or transitive.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.ModuleHasDependency,Module has dependency,Searches for Maven modules that have a dependency matching the specified groupId and artifactId. Places a `SearchResult` marker on all sources within a module with a matching dependency. This recipe is intended to be used as a precondition for other recipes. For example this could be used to limit the application of a spring boot migration to only projects that use spring-boot-starter limiting unnecessary upgrading. If the search result you want is instead just the build.gradle(.kts) file applying the plugin use the `FindDependency` recipe instead.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.search.ModuleHasPlugin,Module has plugin,Searches for Maven modules that have a plugin matching the specified groupId and artifactId. Places a `SearchResult` marker on all sources within a module with a matching plugin. This recipe is intended to be used as a precondition for other recipes. For example this could be used to limit the application of a spring boot migration to only projects that apply the spring boot plugin limiting unnecessary upgrading. If the search result you want is instead just the build.gradle(.kts) file applying the plugin use the `FindPlugins` recipe instead.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.BestPractices,Apache Maven best practices,Applies best practices to Maven POMs.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.cleanup.PrefixlessExpressions,Drop prefixless expressions in POM,MNG-7404 drops support for prefixless in POMs. This recipe will add the `project.` prefix where missing.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.MigrateToMaven4,Migrate to Maven 4,Migrates Maven POMs from Maven 3 to Maven 4 addressing breaking changes and deprecations. This recipe updates property expressions lifecycle phases removes duplicate plugin declarations and replaces removed properties to ensure compatibility with Maven 4.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ReplaceRemovedRootDirectoryProperties,Replace removed root directory properties,Maven 4 removed support for deprecated root directory properties. This recipe replaces `${executionRootDirectory}` with `${session.rootDirectory}` and `${multiModuleProjectDirectory}` with `${project.rootDirectory}`.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ReplaceDeprecatedLifecyclePhases,Replace deprecated lifecycle phases,Maven 4 deprecated all `pre-*` and `post-*` lifecycle phases in favor of the `before:` and `after:` syntax. This recipe updates plugin phase declarations to use the new syntax including `pre-clean` → `before:clean` `pre-site` → `before:site` `pre-integration-test` → `before:integration-test` and their `post-*` equivalents.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.UpgradeToModelVersion410,Upgrade to Maven model version 4.1.0,Upgrades Maven POMs from model version 4.0.0 to 4.1.0 enabling new Maven 4 features like `` `bom` packaging and automatic version inference. This recipe updates the `` element `xmlns` namespace and `xsi:schemaLocation` from 4.0.0 to 4.1.0.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.maven.ReplaceModulesWithSubprojects,Replace modules with subprojects,Maven 4 model version 4.1.0 deprecates the `` element in favor of `` to eliminate confusion with Java's Platform Module System (JPMS). This recipe renames `` to `` and `` children to ``.,org.openrewrite:rewrite-maven:8.64.0-20251021.195831-50 +org.openrewrite.properties.AddProperty,Add a new property,Adds a new property to a property file. Attempts to place the new property in alphabetical order by the property keys. Whitespace before and after the `=` must be included in the property and value.,org.openrewrite:rewrite-properties:8.64.0-20251021.195831-50 +org.openrewrite.properties.AddPropertyComment,Add comment before property key,Add a new comment before a property key if not already present optionally commenting out the property.,org.openrewrite:rewrite-properties:8.64.0-20251021.195831-50 +org.openrewrite.properties.ChangePropertyKey,Change property key,Change a property key leaving the value intact.,org.openrewrite:rewrite-properties:8.64.0-20251021.195831-50 +org.openrewrite.properties.ChangePropertyValue,Change property value,Change a property value leaving the key intact.,org.openrewrite:rewrite-properties:8.64.0-20251021.195831-50 +org.openrewrite.properties.DeleteProperty,Delete property by key,Deletes key/value pairs from properties files as well as any comments that immediately precede the key/value pair. Comments separated by two or more newlines from the deleted key/value pair are preserved.,org.openrewrite:rewrite-properties:8.64.0-20251021.195831-50 +org.openrewrite.properties.search.FindProperties,Find property,Finds occurrences of a property key.,org.openrewrite:rewrite-properties:8.64.0-20251021.195831-50 +org.openrewrite.properties.CreatePropertiesFile,Create Properties file,Create a new Properties file.,org.openrewrite:rewrite-properties:8.64.0-20251021.195831-50 +org.openrewrite.python.ChangeMethodName,Change method name,Renames a method.,org.openrewrite:rewrite-python:1.44.0-20251021.183636-7 +org.openrewrite.python.format.PythonSpaces,Formats spaces in Python code,Standardizes spaces in Python code. Currently limited to formatting method arguments.,org.openrewrite:rewrite-python:1.44.0-20251021.183636-7 +org.openrewrite.toml.ChangeKey,Change TOML key,Change a TOML key while leaving the value intact.,org.openrewrite:rewrite-toml:8.64.0-20251021.195831-50 +org.openrewrite.toml.ChangeTableRowValue,Change TOML table row value,Change a value in a TOML table row when the identifying property matches the specified matcher.,org.openrewrite:rewrite-toml:8.64.0-20251021.195831-50 +org.openrewrite.toml.ChangeValue,Change TOML value,Change the value of a TOML key.,org.openrewrite:rewrite-toml:8.64.0-20251021.195831-50 +org.openrewrite.toml.DeleteKey,Delete TOML key,Delete a TOML key-value pair.,org.openrewrite:rewrite-toml:8.64.0-20251021.195831-50 +org.openrewrite.toml.DeleteTable,Delete TOML table,Delete a TOML table.,org.openrewrite:rewrite-toml:8.64.0-20251021.195831-50 +org.openrewrite.toml.DeleteTableRow,Delete TOML table row,Delete a TOML table row when one of its values matches the specified matcher.,org.openrewrite:rewrite-toml:8.64.0-20251021.195831-50 +org.openrewrite.toml.FindKey,Find TOML keys,Find TOML keys matching a path expression.,org.openrewrite:rewrite-toml:8.64.0-20251021.195831-50 +org.openrewrite.toml.MergeTableRow,Merge TOML table row,Merge a TOML row into an array table. If a row with the same identifying property exists merge the values. Otherwise insert a new row.,org.openrewrite:rewrite-toml:8.64.0-20251021.195831-50 +org.openrewrite.toml.ReplaceTableRow,Replace TOML table row,Replace a TOML table row with new content. If a row with the same identifying property exists replace it entirely.,org.openrewrite:rewrite-toml:8.64.0-20251021.195831-50 +org.openrewrite.toml.CreateTomlFile,Create TOML file,Create a new TOML file.,org.openrewrite:rewrite-toml:8.64.0-20251021.195831-50 +org.openrewrite.xml.AddCommentToXmlTag,Add a comment to an XML tag,Adds a comment as the first element in an XML tag.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.AddOrUpdateChildTag,Add or update child tag,Adds or updates a child element below the parent(s) matching the provided `parentXPath` expression. If a child with the same name already exists it will be replaced by default. Otherwise a new child will be added. This ensures idempotent behaviour.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.AddTagAttribute,Add new XML attribute for an Element,Add new XML attribute with value on a specified element.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.ChangeNamespaceValue,Change XML attribute of a specific resource version,Alters XML Attribute value within specified element of a specific resource versions.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.ChangeTagAttribute,Change XML attribute,Alters XML attribute value on a specified element.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.ChangeTagName,Change XML tag name,Alters the name of XML tags matching the provided expression.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.ChangeTagValue,Change XML tag value,Alters the value of XML tags matching the provided expression. When regex is enabled the replacement happens only for text nodes provided the pattern matches.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.RemoveEmptyXmlTags,Remove empty XML Tag,Removes XML tags that do not have attributes or children including self closing tags.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.RemoveTrailingWhitespace,Remove trailing whitespace,Remove any extra trailing whitespace from the end of each line.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.RemoveXmlTag,Remove XML tag,Removes XML tags matching the provided expression.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.XsltTransformation,XSLT transformation,Apply the specified XSLT transformation on matching files. Note that there are no format matching guarantees when running this recipe.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.format.AutoFormat,Format XML,Indents XML using the most common indentation size and tabs or space choice in use in the file.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.format.LineBreaks,Blank lines,Add line breaks at appropriate places between XML syntax elements.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.format.NormalizeFormat,Normalize format,Move whitespace to the outermost LST element possible.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.format.NormalizeLineBreaks,Normalize line breaks,Consistently use either Windows style (CRLF) or Linux style (LF) line breaks. If no `GeneralFormatStyle` is specified this will use whichever style of line endings are more common.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.format.NormalizeTabsOrSpaces,Normalize to tabs or spaces,Consistently use either tabs or spaces in indentation.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.format.TabsAndIndents,Tabs and indents,Format tabs and indents in XML code.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.search.DoesNotUseNamespaceUri,Find files without Namespace URI,Find XML root elements that do not have a specific Namespace URI optionally restricting the search by an XPath expression.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.search.FindNamespacePrefix,Find XML namespace prefixes,Find XML namespace prefixes optionally restricting the search by a XPath expression.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.search.FindTags,Find XML tags,Find XML tags by XPath expression.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.search.HasNamespaceUri,Find XML namespace URIs,Find XML namespace URIs optionally restricting the search by a XPath expression.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.security.AddOwaspDateBoundSuppressions,Add date bounds to OWASP suppressions,Adds an expiration date to all OWASP suppressions in order to ensure that they are periodically reviewed. For use with the OWASP `dependency-check` tool. More details: https://jeremylong.github.io/DependencyCheck/general/suppression.html.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.security.IsOwaspSuppressionsFile,Find OWASP vulnerability suppression XML files,These files are used to suppress false positives in OWASP [Dependency Check](https://jeremylong.github.io/DependencyCheck).,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.security.RemoveOwaspSuppressions,Remove out-of-date OWASP suppressions,Remove all OWASP suppressions with a suppression end date in the past as these are no longer valid. For use with the OWASP `dependency-check` tool. More details on OWASP suppression files can be found [here](https://jeremylong.github.io/DependencyCheck/general/suppression.html).,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.security.UpdateOwaspSuppressionDate,Update OWASP suppression date bounds,Updates the expiration date for OWASP suppressions having a matching cve tag. For use with the OWASP `dependency-check` tool. More details: https://jeremylong.github.io/DependencyCheck/general/suppression.html.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.CreateXmlFile,Create XML file,Create a new XML file.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.xml.style.AutodetectDebug,XML style Auto-detection debug,Runs XML Autodetect and records the results in data tables and search markers. A debugging tool for figuring out why XML documents get styled the way they do.,org.openrewrite:rewrite-xml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.AppendToSequence,Append to sequence,Append item to YAML sequence.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.ChangeKey,Change key,Change a YAML mapping entry key while leaving the value intact.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.ChangePropertyKey,Change property key,Change a YAML property key while leaving the value intact. Expects dot notation for nested YAML mappings similar to how Spring Boot interprets `application.yml` files.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.ChangePropertyValue,Change YAML property,Change a YAML property. Expects dot notation for nested YAML mappings similar to how Spring Boot interprets `application.yml` files.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.ChangeValue,Change value,Change a YAML mapping entry value while leaving the key intact.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.CoalesceProperties,Coalesce YAML properties,Simplify nested map hierarchies into their simplest dot separated property form similar to how Spring Boot interprets `application.yml` files.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.CommentOutProperty,Comment out property,Comment out a YAML property and add a comment in front.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.DeleteKey,Delete key,Delete a YAML mapping entry key.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.DeleteProperty,Delete property,Delete a YAML property. Nested YAML mappings are interpreted as dot separated property names i.e. as Spring Boot interprets application.yml files like `a.b.c.d` or `a.b.c:d`.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.MergeYaml,Merge YAML snippet,Merge a YAML snippet with an existing YAML document.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.UnfoldProperties,Unfold YAML properties,Transforms dot-separated property keys in YAML files into nested map hierarchies to enhance clarity and readability or for compatibility with tools expecting structured YAML.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.cleanup.RemoveUnused,Remove unused YAML,Remove YAML mappings and sequence keys that have no value.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.format.Indents,YAML indent,Format tabs and indents in YAML.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.search.FindKey,Find YAML entries,Find YAML entries that match the specified [JsonPath](https://docs.openrewrite.org/reference/jsonpath-and-jsonpathmatcher-reference) expression.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.search.FindProperty,Find YAML properties,Find YAML properties that match the specified `propertyKey`. Expects dot notation for nested YAML mappings similar to how Spring Boot interprets `application.yml` files.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.CopyValue,Copy YAML value,Copies a YAML value from one key to another. The existing key/value pair remains unaffected by this change. Attempts to merge the copied value into the new key if it already exists. Attempts to create the new key if it does not exist.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.yaml.CreateYamlFile,Create YAML file,Create a new YAML file.,org.openrewrite:rewrite-yaml:8.64.0-20251021.195831-50 +org.openrewrite.analysis.controlflow.ControlFlowVisualization,Control flow visualization,Visualize the control flow of a Java program.,org.openrewrite.meta:rewrite-analysis:2.28.0-20251021.182012-13 +org.openrewrite.analysis.search.FindMethods,Find method usages,Find method usages by pattern.,org.openrewrite.meta:rewrite-analysis:2.28.0-20251021.182012-13 +org.openrewrite.analysis.search.UriCreatedWithHttpScheme,URIs created with an HTTP scheme,This is a sample recipe demonstrating a simple application of local data flow analysis.,org.openrewrite.meta:rewrite-analysis:2.28.0-20251021.182012-13 +org.openrewrite.analysis.search.FindFlowBetweenMethods,Finds flow between two methods,Takes two patterns for the start/end methods to find flow between.,org.openrewrite.meta:rewrite-analysis:2.28.0-20251021.182012-13 +io.moderne.ai.FindCommentsLanguage,Find comments' language distribution,Finds all comments and uses AI to predict which language the comment is in.,org.openrewrite.recipe:rewrite-ai-search:0.32.0-20251021.170816-12 +io.moderne.ai.ListAllMethodsUsed,List all methods used,List all methods used in any Java source file.,org.openrewrite.recipe:rewrite-ai-search:0.32.0-20251021.170816-12 +io.moderne.ai.SpellCheckCommentsInFrench,Fix mis-encoded comments in French,Use spellchecker to fix mis-encoded French comments in comments JavaDocs properties or XML files. Mis-encoded comments will contain either '?' or '�'.,org.openrewrite.recipe:rewrite-ai-search:0.32.0-20251021.170816-12 +io.moderne.ai.research.GetCodeEmbedding,Get embeddings for code snippets in code,This recipe calls an AI model to get an embedding for either classes or methods which can then be used for downstream tasks.,org.openrewrite.recipe:rewrite-ai-search:0.32.0-20251021.170816-12 +io.moderne.ai.research.FindCodeThatResembles,Find method invocations that resemble a pattern,This recipe uses two phase AI approach to find a method invocation that resembles a search string.,org.openrewrite.recipe:rewrite-ai-search:0.32.0-20251021.170816-12 +io.moderne.ai.research.GetRecommendations,Get recommendations,This recipe calls an AI model to get recommendations for modernizing the code base by looking at a sample of method declarations.,org.openrewrite.recipe:rewrite-ai-search:0.32.0-20251021.170816-12 +io.moderne.ai.FixMisencodedCommentsInFrench,Fix mis-encoded French comments javadocs and pom.xml comments,Fixes mis-encoded French comments in your code javadocs and in your pom.xml files. Mis-encoded comments contain a ? or � character.,org.openrewrite.recipe:rewrite-ai-search:0.32.0-20251021.170816-12 +org.openrewrite.FindCallGraph,Find call graph,Produces a data table where each row represents a method call.,org.openrewrite.recipe:rewrite-all:1.23.0-20251021.181733-12 +org.openrewrite.FindDuplicateSourceFiles,Find duplicate source files,Record the presence of LSTs with duplicate paths indicating that the same file was parsed more than once.,org.openrewrite.recipe:rewrite-all:1.23.0-20251021.181733-12 +org.openrewrite.LanguageComposition,Language composition report,Counts the number of lines of the various kinds of source code and data formats parsed by OpenRewrite. Comments are not included in line counts. This recipe emits its results as two data tables making no changes to any source file. One data table is per-file the other is per-repository.,org.openrewrite.recipe:rewrite-all:1.23.0-20251021.181733-12 +org.openrewrite.android.ChangeAndroidSdkVersion,Change Android SDK version,Change `compileSdk` `compileSdkVersion` `targetSdk` and `targetSdkVersion` in an Android Gradle build file to the argument version.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.UpgradeAndroidGradlePluginVersion,Upgrade Android Gradle Plugin (AGP) version,Upgrade Android Gradle Plugin (AGP) version and update the Gradle Wrapper version. Compatible versions are published in the [AGP release notes](https://developer.android.com/build/releases/gradle-plugin).,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.MigrateToAndroidGradlePlugin_8_1,Migrate to Android Gradle Plugin 8.1,Recipes to migrate to Android Gradle Plugin version 8.1.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.MigrateToAndroidGradlePlugin_7_4,Migrate to Android Gradle Plugin 7.4,Recipes to migrate to Android Gradle Plugin version 7.4.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.MigrateToAndroidGradlePlugin_7_3,Migrate to Android Gradle Plugin 7.3,Recipes to migrate to Android Gradle Plugin version 7.3.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.MigrateToAndroidGradlePlugin_8_3,Migrate to Android Gradle Plugin 8.3,Recipes to migrate to Android Gradle Plugin version 8.3.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.MigrateToAndroidGradlePlugin_8_6,Migrate to Android Gradle Plugin 8.6,Recipes to migrate to Android Gradle Plugin version 8.6.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.MigrateToAndroidGradlePlugin_8_5,Migrate to Android Gradle Plugin 8.5,Recipes to migrate to Android Gradle Plugin version 8.5.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.UpgradeToAndroidSDK33,Upgrade to Android SDK 33,Recipes to upgrade to Android SDK version 33.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.MigrateToAndroidGradlePlugin_8_0,Migrate to Android Gradle Plugin 8.0,Recipes to migrate to Android Gradle Plugin version 8.0.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.MigrateToAndroidGradlePlugin_7_2,Migrate to Android Gradle Plugin 7.2,Recipes to migrate to Android Gradle Plugin version 7.2.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.UpgradeToAndroidSDK34,Upgrade to Android SDK 34,Recipes to upgrade to Android SDK version 34.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.MigrateToAndroidGradlePlugin_8_4,Migrate to Android Gradle Plugin 8.4,Recipes to migrate to Android Gradle Plugin version 8.4.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.MigrateToAndroidGradlePlugin_8_2,Migrate to Android Gradle Plugin 8.2,Recipes to migrate to Android Gradle Plugin version 8.2.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.MigrateToAndroidGradlePlugin_8_7,Migrate to Android Gradle Plugin 8.7,Recipes to migrate to Android Gradle Plugin version 8.7.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.android.UpgradeToAndroidSDK35,Upgrade to Android SDK 35,Recipes to upgrade to Android SDK version 35.,org.openrewrite.recipe:rewrite-android:0.14.0-20251021.170507-11 +org.openrewrite.apache.commons.codec.ApacheBase64ToJavaBase64,Prefer `java.util.Base64`,Prefer the Java standard library's `java.util.Base64` over third-party usage of apache's `apache.commons.codec.binary.Base64`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.io.ApacheCommonsFileUtilsRecipes,`ApacheCommonsFileUtils` Refaster recipes,Refaster template recipes for `org.openrewrite.apache.commons.io.ApacheCommonsFileUtils`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.io.ApacheCommonsFileUtilsRecipes$GetFileRecipe,Replace `FileUtils.getFile(String...)` with JDK provided API,Replace Apache Commons `FileUtils.getFile(String... name)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.io.ApacheCommonsFileUtilsRecipes$WriteStringToFileRecipe,Replace `FileUtils.writeStringToFile(File String)` with JDK provided API,Replace Apache Commons `FileUtils.writeStringToFile(File file String data)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.io.ApacheFileUtilsToJavaFiles,Prefer `java.nio.file.Files`,Prefer the Java standard library's `java.nio.file.Files` over third-party usage of apache's `apache.commons.io.FileUtils`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.io.ApacheIOUtilsUseExplicitCharset,Use IOUtils method that include their charset encoding,Use `IOUtils` method invocations that include the charset encoding instead of using the deprecated versions that do not include a charset encoding. (e.g. converts `IOUtils.readLines(inputStream)` to `IOUtils.readLines(inputStream StandardCharsets.UTF_8)`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes,`ApacheCommonsStringUtils` Refaster recipes,Refaster template recipes for `org.openrewrite.apache.commons.lang.ApacheCommonsStringUtils`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$AbbreviateRecipe,Replace `StringUtils.abbreviate(String int)` with JDK provided API,Replace Apache Commons `StringUtils.abbreviate(String str int maxWidth)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$CapitalizeRecipe,Replace `StringUtils.capitalize(String)` with JDK provided API,Replace Apache Commons `StringUtils.capitalize(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$DefaultStringFallbackRecipe,Replace `StringUtils.defaultString(String String)` with JDK provided API,Replace Apache Commons `StringUtils.defaultString(String str String nullDefault)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$DefaultStringRecipe,Replace `StringUtils.defaultString(String)` with JDK provided API,Replace Apache Commons `StringUtils.defaultString(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$DeleteWhitespaceRecipe,Replace `StringUtils.deleteWhitespace(String)` with JDK provided API,Replace Apache Commons `StringUtils.deleteWhitespace(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$EqualsIgnoreCaseRecipe,Replace `StringUtils.equalsIgnoreCase(CharSequence CharSequence)` with JDK provided API,Replace Apache Commons `StringUtils.equalsIgnoreCase(CharSequence cs1 CharSequence cs2)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$EqualsRecipe,Replace `StringUtils.equals(CharSequence CharSequence)` with JDK provided API,Replace Apache Commons `StringUtils.equals(CharSequence cs1 CharSequence cs2)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$LowercaseRecipe,Replace `StringUtils.lowerCase(String)` with JDK provided API,Replace Apache Commons `StringUtils.lowerCase(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$RemoveEndRecipe,Replace `StringUtils.removeEnd(String String)` with JDK provided API,Replace Apache Commons `StringUtils.removeEnd(String str String remove)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$RemoveRedundantNullCheckWithIsNotBlankRecipe,Remove redundant null check when using `StringUtils.isNotBlank(String)`,Remove redundant null check when using `StringUtils.isNotBlank(String)` as it already handles null values.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$ReplaceRecipe,Replace `StringUtils.replace(String String String)` with JDK provided API,Replace Apache Commons `StringUtils.replace(String text String searchString String replacement)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$ReverseRecipe,Replace `StringUtils.reverse(String)` with JDK provided API,Replace Apache Commons `StringUtils.reverse(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$SplitRecipe,Replace `StringUtils.split(String)` with JDK provided API,Replace Apache Commons `StringUtils.split(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$StringJoinSeparatorIterableCharSequenceRecipe,Replace `StringUtils.join(Iterable String)` with JDK provided API,Replace Apache Commons `StringUtils.join(Iterable iterable String separator)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$StripRecipe,Replace `StringUtils.strip(String)` with JDK provided API,Replace Apache Commons `StringUtils.strip(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$TrimRecipe,Replace `StringUtils.trim(String)` with JDK provided API,Replace Apache Commons `StringUtils.trim(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$TrimToEmptyRecipe,Replace `StringUtils.trimToEmpty(String)` with JDK provided API,Replace Apache Commons `StringUtils.trimToEmpty(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$TrimToNullRecipe,Replace `StringUtils.trimToNull(String)` with JDK provided API,Replace Apache Commons `StringUtils.trimToNull(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.ApacheCommonsStringUtilsRecipes$UppercaseRecipe,Replace `StringUtils.upperCase(String)` with JDK internals,Replace Apache Commons `StringUtils.upperCase(String str)` with JDK internals.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.IsNotEmptyToJdk,Replace any StringUtils#isEmpty(String) and #isNotEmpty(String),Replace any `StringUtils#isEmpty(String)` and `#isNotEmpty(String)` with `s == null || s.isEmpty()` and `s != null && !s.isEmpty()`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient4.MigrateDefaultHttpClient,Migrates deprecated `DefaultHttpClient`,Since `DefaultHttpClient` is deprecated we need to change it to the `CloseableHttpClient`. It only covers the default scenario with no custom `HttpParams` or `ConnectionManager`. Of note: the `DefaultHttpClient` [does not support TLS 1.2](https://find-sec-bugs.github.io/bugs.htm#DEFAULT_HTTP_CLIENT). References: - [Find Sec Bugs](https://find-sec-bugs.github.io/bugs.htm#DEFAULT_HTTP_CLIENT) - [IBM Support Pages](https://www.ibm.com/support/pages/im-using-apache-httpclient-make-outbound-call-my-web-application-running-websphere-application-server-traditional-and-im-getting-ssl-handshake-error-how-can-i-debug),org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.AddTimeUnitArgument,Adds a TimeUnit argument to the matched method invocations,In Apache Http Client 5.x migration an extra TimeUnit argument is required in the timeout and duration methods. Previously in 4.x all these methods were implicitly having the timeout or duration expressed in milliseconds but in 5.x the unit of the timeout or duration is required. So by default this recipe adds `TimeUnit.MILLISECONDS` it is possible to specify this as a parameter. Since all affected methods of the Apache Http Client 5.x migration only have one integer/long argument the recipe applies with matched method invocations of exactly one parameter.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.ChangeArgumentToTimeValue,Changes an argument to a `TimeValue` for matched method invocations,In Apache Http Client 5.x migration some methods that previously took a single long argument have changed to take a `TimeValue`. Previously in 4.x all these methods were implicitly having the value expressed in milliseconds. By default this recipe uses `TimeUnit.MILLISECONDS` for the `TimeUnit` when creating a `TimeValue`. It is possible to specify this as a parameter. Since all affected methods of the Apache Http Client 5.x migration only have one long argument the recipe applies with matched method invocations of exactly one parameter.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.InputBufferReadAddOffsetAndLengthArguments,Adds offset and length arguments to the read method of SharedInputBuffer,In Apache Http Client 5.x migration the shortened form of the `read(byte[])` has been removed.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.MigrateAuthScope,Replaces `AuthScope.ANY`,Replace removed constant `org.apache.http.auth.AuthScope.AuthScope.ANY` with `new org.apache.hc.client5.http.auth.AuthScope(null -1)`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.MigrateRequestConfig,Migrate `RequestConfig` to httpclient5,Migrate `RequestConfig` to httpclient5.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.MigrateSSLConnectionSocketFactory,Migrate deprecated `SSLConnectionSocketFactory` to `DefaultClientTlsStrategy`,Migrates usage of the deprecated `org.apache.http.conn.ssl.SSLConnectionSocketFactory` to `org.apache.hc.client5.http.ssl.DefaultClientTlsStrategy` with proper connection manager setup.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.MigrateStringEntityStringCharsetConstructor,Replace `new StringEntity(String String)` with `new StringEntity(String Charset)`,Replace `new StringEntity(String String)` with `new StringEntity(String Charset)` to eliminate literal usage for charset parameters.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.NewRequestLine,Replaces deprecated `HttpRequestBase::getRequestLine()`,`HttpRequestBase::getStatusLine()` was deprecated in 4.x so we replace it with `new RequestLine(HttpRequest)`. Ideally we will try to simply method chains for `getMethod` `getUri` and `getProtocolVersion` but there are some scenarios where `RequestLine` object is assigned or used directly and we need to instantiate the object.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.NewStatusLine,Replaces deprecated `HttpResponse::getStatusLine()`,`HttpResponse::getStatusLine()` was deprecated in 4.x so we replace it for `new StatusLine(HttpResponse)`. Ideally we will try to simplify method chains for `getStatusCode` `getProtocolVersion` and `getReasonPhrase` but there are some scenarios where the `StatusLine` object is assigned or used directly and we need to instantiate the object.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.OutputBufferWriteAddOffsetAndLengthArguments,Adds offset and length arguments to the write method of SharedOutputBuffer,In Apache Http Client 5.x migration the shortened form of the `write(byte[])` has been removed.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.RemoveByteBufferAllocators,Remove ByteBufferAllocator implementations,In Apache Http Client 5.x migration both implementations of `ByteBufferAllocator` have been removed. This recipe will remove usage of said classes in favour of direct static calls to `ByteBuffer`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.UsernamePasswordCredentials,Migrate `UsernamePasswordCredentials` to httpclient5,Change the password argument going into `UsernamePasswordCredentials` to be a `char[]`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes,`MavenSharedStringUtils` Refaster recipes,Refaster template recipes for `org.openrewrite.apache.maven.shared.MavenSharedStringUtils`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes$AbbreviateRecipe,Replace `StringUtils.abbreviate(String int)` with JDK provided API,Replace Maven Shared `StringUtils.abbreviate(String str int maxWidth)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes$CapitaliseRecipe,Replace `StringUtils.capitalise(String)` with JDK provided API,Replace Maven Shared `StringUtils.capitalise(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes$DefaultStringFallbackRecipe,Replace `StringUtils.defaultString(Object String)` with JDK provided API,Replace Maven Shared `StringUtils.defaultString(Object obj String nullDefault)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes$DefaultStringRecipe,Replace `StringUtils.defaultString(Object)` with JDK provided API,Replace Maven Shared `StringUtils.defaultString(Object obj)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes$DeleteWhitespaceRecipe,Replace `StringUtils.deleteWhitespace(String)` with JDK provided API,Replace Maven Shared `StringUtils.deleteWhitespace(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes$EqualsIgnoreCaseRecipe,Replace `StringUtils.equalsIgnoreCase(String String)` with JDK provided API,Replace Maven Shared `StringUtils.equalsIgnoreCase(String str1 String str2)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes$EqualsRecipe,Replace `StringUtils.equals(String String)` with JDK provided API,Replace Maven Shared `StringUtils.equals(String str1 String str2)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes$LowercaseRecipe,Replace `StringUtils.lowerCase(String)` with JDK provided API,Replace Maven Shared `StringUtils.lowerCase(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes$ReplaceRecipe,Replace `StringUtils.replace(String String String)` with JDK provided API,Replace Maven Shared `StringUtils.replace(String text String searchString String replacement)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes$ReverseRecipe,Replace `StringUtils.reverse(String)` with JDK provided API,Replace Maven Shared `StringUtils.reverse(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes$SplitRecipe,Replace `StringUtils.split(String)` with JDK provided API,Replace Maven Shared `StringUtils.split(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes$StripRecipe,Replace `StringUtils.strip(String)` with JDK provided API,Replace Maven Shared `StringUtils.strip(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes$TrimRecipe,Replace `StringUtils.trim(String)` with JDK provided API,Replace Maven Shared `StringUtils.trim(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.maven.shared.MavenSharedStringUtilsRecipes$UppercaseRecipe,Replace `StringUtils.upperCase(String)` with JDK provided API,Replace Maven Shared `StringUtils.upperCase(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.poi.ReplaceSetBoldweightWithSetBold,Replace `Font.setBoldweight(short)` with `Font.setBold(boolean)`,Replace `Font.setBoldweight(short)` or equivalent with `Font.setBold(boolean)`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.poi.ReplaceSetCellType,Apache POI use `Cell.setCellType(CellType)`,`Cell.setCellType()` can be configured with either an integer or a the `CellType` enumeration. It is clearer and less error-prone to use the `CellType` enumeration so this recipe converts all `setCellType()` calls to use it.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.AbstractLogEnabledToSlf4j,Migrate from Plexus `AbstractLogEnabled` to SLF4J,Introduce a SLF4J `Logger` field and replace calls to `getLogger()` with calls to the field.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusFileUtilsRecipes,`PlexusFileUtils` Refaster recipes,Refaster template recipes for `org.openrewrite.codehaus.plexus.PlexusFileUtils`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusFileUtilsRecipes$DeleteDirectoryFileRecipe,Replace `FileUtils.deleteDirectory(File)` with JDK provided API,Replace Plexus `FileUtils.deleteDirectory(File directory)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusFileUtilsRecipes$DeleteDirectoryStringRecipe,Replace `FileUtils.deleteDirectory(String)` with JDK provided API,Replace Plexus `FileUtils.deleteDirectory(String directory)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusFileUtilsRecipes$FileExistsStringRecipe,Replace `FileUtils.fileExists(String)` with JDK provided API,Replace Plexus `FileUtils.fileExists(String fileName)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusFileUtilsRecipes$GetFileRecipe,Replace `FileUtils.getFile(String)` with JDK provided API,Replace Plexus `FileUtils.getFile(String fileName)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes,`PlexusStringUtils` Refaster recipes,Refaster template recipes for `org.openrewrite.codehaus.plexus.PlexusStringUtils`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes$AbbreviateRecipe,Replace `StringUtils.abbreviate(String int)` with JDK provided API,Replace Plexus `StringUtils.abbreviate(String str int maxWidth)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes$CapitaliseRecipe,Replace `StringUtils.capitalise(String)` with JDK provided API,Replace Plexus `StringUtils.capitalise(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes$DefaultStringFallbackRecipe,Replace `StringUtils.defaultString(Object String)` with JDK provided API,Replace Plexus `StringUtils.defaultString(Object obj String nullDefault)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes$DefaultStringRecipe,Replace `StringUtils.defaultString(Object)` with JDK provided API,Replace Plexus `StringUtils.defaultString(Object obj)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes$DeleteWhitespaceRecipe,Replace `StringUtils.deleteWhitespace(String)` with JDK provided API,Replace Plexus `StringUtils.deleteWhitespace(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes$EqualsIgnoreCaseRecipe,Replace `StringUtils.equalsIgnoreCase(String String)` with JDK provided API,Replace Plexus `StringUtils.equalsIgnoreCase(String str1 String str2)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes$EqualsRecipe,Replace `StringUtils.equals(String String)` with JDK provided API,Replace Plexus `StringUtils.equals(String str1 String str2)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes$LowercaseRecipe,Replace `StringUtils.lowerCase(String)` with JDK provided API,Replace Plexus `StringUtils.lowerCase(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes$ReplaceRecipe,Replace `StringUtils.replace(String String String)` with JDK provided API,Replace Plexus `StringUtils.replace(String text String searchString String replacement)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes$ReverseRecipe,Replace `StringUtils.reverse(String)` with JDK provided API,Replace Plexus `StringUtils.reverse(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes$SplitRecipe,Replace `StringUtils.split(String)` with JDK provided API,Replace Plexus `StringUtils.split(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes$StripRecipe,Replace `StringUtils.strip(String)` with JDK provided API,Replace Plexus `StringUtils.strip(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes$TrimRecipe,Replace `StringUtils.trim(String)` with JDK provided API,Replace Plexus `StringUtils.trim(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.codehaus.plexus.PlexusStringUtilsRecipes$UppercaseRecipe,Replace `StringUtils.upperCase(String)` with JDK provided API,Replace Plexus `StringUtils.upperCase(String str)` with JDK provided API.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.UpgradeApacheHttpClient_5,Migrate to ApacheHttpClient 5.x,Migrate applications to the latest Apache HttpClient 5.x release. This recipe will modify an application's build files make changes to deprecated/preferred APIs and migrate configuration settings that have changes between versions.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.UpgradeApacheHttpClientDependencies,Migrate from org.apache.httpcomponents to ApacheHttpClient 5.x dependencies,Adopt `org.apache.httpcomponents.client5:httpclient5` from `org.apache.httpcomponents`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.UpgradeApacheHttpCoreNioDependencies,Migrate from httpcore-nio to ApacheHttpClient 5.x core dependency,Adopt `org.apache.httpcomponents.core5:httpcore5` from `org.apache.httpcomponents:httpcore-nio`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.UpgradeApacheHttpCore_5_NioInputBuffers,Migrate Apache HttpCore Nio Input Buffer classes to Apache HttpCore 5.x,Mapping of specifically `*InputBuffer` classes of Apache HttpCore 5.x from Apache HttpCore Nio 4.4.x.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.UpgradeApacheHttpCore_5_NioOutputBuffers,Migrate Apache HttpCore Nio Output Buffer classes to Apache HttpCore 5.x,Mapping of specifically `*OutputBuffer` classes of Apache HttpCore 5.x from Apache HttpCore Nio 4.4.x.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.UpgradeApacheHttpCore_5_NioUtilMapping,Migrate to Apache HttpCore Nio Util Classes to Apache HttpCore 5.x,Mapping of all the compatible utility classes of Apache HttpCore 5.x from Apache HttpCore Nio 4.4.x.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.UpgradeApacheHttpCore_5_NioClassMapping,Migrate to Apache HttpCore Nio Classes to Apache HttpCore 5.x,Mapping of all the compatible classes of Apache HttpCore 5.x from Apache HttpCore Nio 4.4.x.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.UpgradeApacheHttpClient_5_ClassMapping,Migrate to ApacheHttpClient 5.x Classes Namespace from 4.x,Mapping of all the compatible classes of ApacheHttpClient 5.x from 4.x.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.UpgradeApacheHttpClient_5_DeprecatedMethods,Migrate to ApacheHttpClient 5.x deprecated methods from 4.x,Migrates deprecated methods to their equivalent ones in 5.x.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.UpgradeApacheHttpClient_5_TimeUnit,Adds `TimeUnit` to timeouts and duration methods,Apache HttpClient 5.x Timeout and duration methods need an extra the TimeUnit argument. This recipe uses milliseconds as a default unit.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.StatusLine,Migrate to ApacheHttpClient 5.x deprecated methods from 4.x,Migrates deprecated methods to their equivalent ones in 5.x.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.CredentialsStoreSetCredentials,Migrate `setCredentials` to ApacheHttpClient 5.x `CredentialsStore`,Migrates `BasicCredentialsProvider` methods`setCredentials` to the new `CredentialsStore` interface.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient5.CredentialsStoreClear,Migrate `clear` to ApacheHttpClient 5.x `CredentialsStore`,Migrates `BasicCredentialsProvider` methods`clear` to the new `CredentialsStore` interface.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.math.UpgradeApacheCommonsMath_2_3,Migrates to Apache Commons Math 3.x,Migrate applications to the latest Apache Commons Math 3.x release. This recipe modifies application's build files make changes to deprecated/preferred APIs and migrates configuration settings that have changes between versions.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.io.RelocateApacheCommonsIo,Relocate `org.apache.commons:commons-io` to `commons-io:commons-io`,The deployment of `org.apache.commons:commons-io` [was a publishing mistake around 2012](https://issues.sonatype.org/browse/MVNCENTRAL-244) which was corrected by changing the deployment GAV to be located under `commons-io:commons-io`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.io.UseSystemLineSeparator,Prefer `System.lineSeparator()`,Prefer the Java standard library's `System.lineSeparator()` over third-party usage of apache's `IOUtils.LINE_SEPARATOR`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.io.UseStandardCharsets,Prefer `java.nio.charset.StandardCharsets`,Prefer the Java standard library's `java.nio.charset.StandardCharsets` over third-party usage of apache's `org.apache.commons.io.Charsets`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.poi.UpgradeApachePoi_3_17,Migrates to Apache POI 3.17,Migrates to the last Apache POI 3.x release. This recipe modifies build files and makes changes to deprecated/preferred APIs that have changed between versions.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient4.UpgradeApacheHttpClient_4_5,Migrates to ApacheHttpClient 4.5.x,Migrate applications to the latest Apache HttpClient 4.5.x release. This recipe modifies application's build files make changes to deprecated/preferred APIs and migrates configuration settings that have changes between versions.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.httpclient4.MappingDeprecatedClasses,Maps deprecated classes from Apache HttpClient 4.5.x to suggested replacements,Uses new classes/methods instead of the deprecated ones.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.UpgradeApacheCommonsLang_2_3,Migrates to Apache Commons Lang 3.x,Migrate applications to the latest Apache Commons Lang 3.x release. This recipe modifies application's build files and changes the package as per [the migration release notes](https://commons.apache.org/proper/commons-lang/article3_0.html).,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang.WordUtilsToCommonsText,Migrate `WordUtils` to Apache Commons Text,Migrate `org.apache.commons.lang.WordUtils` to `org.apache.commons.text.WordUtils` and add the Commons Text dependency.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.lang3.UseStandardCharsets,Prefer `java.nio.charset.StandardCharsets`,Prefer the Java standard library's `java.nio.charset.StandardCharsets` over `org.apache.commons.lang3.CharEncoding`.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +org.openrewrite.apache.commons.collections.UpgradeApacheCommonsCollections_3_4,Migrates to Apache Commons Collections 4.x,Migrate applications to the latest Apache Commons Collections 4.x release. This recipe modifies application's build files make changes to deprecated/preferred APIs and migrates configuration settings that have changes between versions.,org.openrewrite.recipe:rewrite-apache:2.19.0-20251021.171357-14 +io.moderne.azul.EliminateUnusedClasses,Eliminate unused classes,Deprecate and later delete classes that are unused as detected by Azul Intelligence Cloud.,org.openrewrite.recipe:rewrite-azul:0.7.0 +io.moderne.azul.search.FindReachableMethods,Find reachable methods,Find all methods defined in the repository's source code that are reachable.,org.openrewrite.recipe:rewrite-azul:0.7.0 +org.openrewrite.circleci.InstallOrb,Install an orb,Install a CircleCI [orb](https://circleci.com/docs/2.0/orb-intro/) if it is not already installed.,org.openrewrite.recipe:rewrite-circleci:3.9.0-20251021.180340-12 +org.openrewrite.circleci.UpdateImage,Update CircleCI image,See the list of [pre-built CircleCI images](https://circleci.com/docs/2.0/circleci-images/).,org.openrewrite.recipe:rewrite-circleci:3.9.0-20251021.180340-12 +org.openrewrite.codemods.ApplyCodemod,Applies a codemod to all source files,Applies a codemod represented by an NPM package to all source files.,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.Biome,Biome recommendations,Run [Biome](https://biomejs.dev/) recommended settings on your projects.,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.ESLint,Lint source code with ESLint,Run [ESLint](https://eslint.org/) across the code to fix common static analysis issues in the code. This requires the code to have an existing ESLint configuration.,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.Putout,Run Putout,Run [Putout](https://github.com/coderaiser/putout) on your projects.,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.ReactI18Next,React i18next internationalization,Automatically internationalizes React applications by extracting hardcoded strings and replacing them with [react-i18next](https://react.i18next.com) translation calls. Handles JSX text attributes and template literals with variables. Creates and updates a translation JSON file with extracted strings.,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.UI5,Lint UI5 projects with UI5 linter,Runs the [UI5 Linter](https://github.com/SAP/ui5-linter) a static code analysis tool for UI5 projects. It checks JavaScript TypeScript XML JSON and other files in your project and reports findings.,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.All,Combination of all deprecations,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#all).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.SxProp,Update the usage of the `sx` prop to be compatible with `@pigment-css/react`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#sx-prop).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.SystemProps,Remove system props and add them to the `sx` prop,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#system-props).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ThemeV,Update the theme creation from `@mui/system@v5` to be compatible with `@pigment-css/react`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#theme-v6).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.Styled,Updates the usage of `styled` from `@mui/system@v5` to be compatible with` @pigment-css/react`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#styled).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.GridVProps,Updates the usage of the `@mui/material/Grid2` `@mui/system/Grid` and `@mui/joy/Grid` components to their updated APIs.,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#grid-v2-props).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.AdapterV,Converts components to use the v4 adapter module,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#adapter-v4).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.AutocompleteRenameCloseicon,Renames `closeIcon` prop to `closeButtonIcon`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#autocomplete-rename-closeicon).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.AutocompleteRenameOption,Renames `option` prop to `getOptionLabel`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#autocomplete-rename-option).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.AvatarCircleCircular,Updates `circle` prop to `variant="circular"`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#avatar-circle-circular).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.BadgeOverlapValue,Updates `overlap` prop to `variant="dot"`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#badge-overlap-value).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.BaseHookImports,Converts base imports to use React hooks,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#base-hook-imports).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.BaseRemoveComponentProp,Removes `component` prop from base components,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#base-remove-component-prop).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.BaseRemoveUnstyledSuffix,Removes `Unstyled` suffix from base components,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#base-remove-unstyled-suffix).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.BaseRenameComponentsToSlots,Renames base components to slots,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#base-rename-components-to-slots).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.BaseUseNamedExports,Updates base imports to use named exports,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#base-use-named-exports).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.BoxBorderradiusValues,Updates `borderRadius` prop values,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#box-borderradius-values).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.BoxRenameCss,Renames CSS properties for Box component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#box-rename-css).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.BoxRenameGap,Renames `gap` prop to `spacing`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#box-rename-gap).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.BoxSxProp,Converts `sx` prop to `sx` style prop,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#box-sx-prop).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ButtonColorProp,Renames `color` prop to `colorOverride`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#button-color-prop).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ChipVariantProp,Updates `variant` prop for Chip component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#chip-variant-prop).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.CircularprogressVariant,Updates `variant` prop for CircularProgress component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#circularprogress-variant).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.CollapseRenameCollapsedheight,Renames `collapsedHeight` prop to `transitionCollapsedHeight`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#collapse-rename-collapsedheight).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ComponentRenameProp,Renames `component` prop to `as`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#component-rename-prop).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.CoreStylesImport,Updates import paths for core styles,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#core-styles-import).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.CreateTheme,Updates createMuiTheme usage,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#create-theme).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.DatePickersMovedToX,Moves date pickers to `@mui/x-date-picker`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#date-pickers-moved-to-x).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.DialogProps,Updates props for Dialog component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#dialog-props).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.DialogTitleProps,Updates props for DialogTitle component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#dialog-title-props).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.EmotionPrependCache,Prepends emotion cache,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#emotion-prepend-cache).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ExpansionPanelComponent,Converts ExpansionPanel to use ExpansionPanel component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#expansion-panel-component).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.FabVariant,Updates `variant` prop for Fab component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#fab-variant).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.FadeRenameAlpha,Renames `alpha` prop to `opacity`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#fade-rename-alpha).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.GridJustifyJustifycontent,Updates `justify` prop to `justifyContent` for Grid component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#grid-justify-justifycontent).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.GridListComponent,Converts GridList to use Grid component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#grid-list-component).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.HiddenDownProps,Updates `down` prop for Hidden component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#hidden-down-props).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.IconButtonSize,Updates `size` prop for IconButton component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#icon-button-size).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.JoyAvatarRemoveImgprops,Removes `imgProps` prop from Avatar component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#joy-avatar-remove-imgProps).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.JoyRenameClassnamePrefix,Renames `Mui` classname prefix,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#joy-rename-classname-prefix).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.JoyRenameComponentsToSlots,Renames components to slots,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#joy-rename-components-to-slots).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.JoyRenameRowProp,Renames `row` prop to `flexDirection="row"`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#joy-rename-row-prop).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.JoyTextFieldToInput,Renames `TextField` to `Input`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#joy-text-field-to-input).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.JssToStyled,Converts JSS styles to styled-components,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#jss-to-styled).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.JssToTssReact,Converts JSS to TypeScript in React components,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#jss-to-tss-react).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.LinkUnderlineHover,Updates link underline on hover,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#link-underline-hover).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.MaterialUiStyles,Updates usage of `@mui/styles`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#material-ui-styles).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.MaterialUiTypes,Updates usage of `@mui/types`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#material-ui-types).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ModalProps,Updates props for Modal component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#modal-props).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.MovedLabModules,Moves lab modules to `@mui/material`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#moved-lab-modules).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.MuiReplace,Replaces `@mui` imports with `@mui/material`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#mui-replace).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.OptimalImports,Optimizes imports,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#optimal-imports).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.PaginationRoundCircular,Updates `circular` prop to `variant="circular"`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#pagination-round-circular).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.PresetSafe,Ensures presets are safe to use,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#preset-safe).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.RenameCssVariables,Renames CSS variables,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#rename-css-variables).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.RootRef,Converts `rootRef` to `ref`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#root-ref).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.SkeletonVariant,Updates `variant` prop for Skeleton component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#skeleton-variant).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.StyledEngineProvider,Updates usage of styled engine provider,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#styled-engine-provider).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.TableProps,Updates props for Table component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#table-props).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.TabsScrollButtons,Updates scroll buttons for Tabs component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#tabs-scroll-buttons).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.TextareaMinmaxRows,Updates `minRows` and `maxRows` props for TextareaAutosize component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#textarea-minmax-rows).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ThemeAugment,Adds `DefaultTheme` module augmentation to typescript projects.,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#theme-augment).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ThemeBreakpointsWidth,Updates `width` values for theme breakpoints,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#theme-breakpoints-width).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ThemeBreakpoints,Updates theme breakpoints,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#theme-breakpoints).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ThemeOptions,Updates theme options,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#theme-options).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ThemePaletteMode,Updates theme palette mode,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#theme-palette-mode).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ThemeProvider,Updates usage of ThemeProvider,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#theme-provider).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ThemeSpacing,Updates theme spacing,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#theme-spacing).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ThemeTypographyRound,Updates `round` values for theme typography,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#theme-typography-round).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.TopLevelImports,Converts all `@mui/material` submodule imports to the root module,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#top-level-imports).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.Transitions,Updates usage of transitions,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#transitions).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.TreeViewMovedToX,Moves tree view to `@mui/x-tree-view`,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#tree-view-moved-to-x).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.UseAutocomplete,Updates usage of useAutocomplete,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#use-autocomplete).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.UseTransitionprops,Updates usage of useTransitionProps,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#use-transitionprops).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.VariantProp,Updates `variant` prop usage,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#variant-prop).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.WithMobileDialog,Updates withMobileDialog higher-order component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#with-mobile-dialog).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.WithWidth,Updates withWidth higher-order component,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#with-width).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.migrate.mui.ThemeSpacingApi,Updates theme spacing API,See Material UI codemod projects for more [details](https://github.com/mui/material-ui/tree/master/packages/mui-codemod#theme-spacing-api).,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.RecommendedESLintStyling,Recommended ESLint Styling,Collection of stylistic ESLint rules that are recommended by the [ESLint Style.](https://eslint.style/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.ArrayBracketNewline,Enforce linebreaks after opening and before closing array brackets,Enforce linebreaks after opening and before closing array brackets See [rule details](https://eslint.style/rules/default/array-bracket-newline) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.ArrayBracketSpacing,Enforce consistent spacing inside array brackets,Enforce consistent spacing inside array brackets See [rule details](https://eslint.style/rules/default/array-bracket-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.ArrayElementNewline,Enforce line breaks after each array element,Enforce line breaks after each array element See [rule details](https://eslint.style/rules/default/array-element-newline) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.ArrowParens,Require parentheses around arrow function arguments,Require parentheses around arrow function arguments See [rule details](https://eslint.style/rules/default/arrow-parens) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.ArrowSpacing,Enforce consistent spacing before and after the arrow in arrow functions,Enforce consistent spacing before and after the arrow in arrow functions See [rule details](https://eslint.style/rules/default/arrow-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.BlockSpacing,Disallow or enforce spaces inside of blocks after opening block and before closing block,Disallow or enforce spaces inside of blocks after opening block and before closing block See [rule details](https://eslint.style/rules/default/block-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.BraceStyle,Enforce consistent brace style for blocks,Enforce consistent brace style for blocks See [rule details](https://eslint.style/rules/default/brace-style) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.CommaDangle,Require or disallow trailing commas,Require or disallow trailing commas See [rule details](https://eslint.style/rules/default/comma-dangle) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.CommaSpacing,Enforce consistent spacing before and after commas,Enforce consistent spacing before and after commas See [rule details](https://eslint.style/rules/default/comma-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.CommaStyle,Enforce consistent comma style,Enforce consistent comma style See [rule details](https://eslint.style/rules/default/comma-style) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.ComputedPropertySpacing,Enforce consistent spacing inside computed property brackets,Enforce consistent spacing inside computed property brackets See [rule details](https://eslint.style/rules/default/computed-property-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.DotLocation,Enforce consistent newlines before and after dots,Enforce consistent newlines before and after dots See [rule details](https://eslint.style/rules/default/dot-location) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.EolLast,Require or disallow newline at the end of files,Require or disallow newline at the end of files See [rule details](https://eslint.style/rules/default/eol-last) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.FuncCallSpacing,Require or disallow spacing between function identifiers and their invocations. Alias of `function-call-spacing`.,Require or disallow spacing between function identifiers and their invocations. Alias of `function-call-spacing`. See [rule details](https://eslint.style/rules/default/func-call-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.FunctionCallArgumentNewline,Enforce line breaks between arguments of a function call,Enforce line breaks between arguments of a function call See [rule details](https://eslint.style/rules/default/function-call-argument-newline) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.FunctionCallSpacing,Require or disallow spacing between function identifiers and their invocations,Require or disallow spacing between function identifiers and their invocations See [rule details](https://eslint.style/rules/default/function-call-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.FunctionParenNewline,Enforce consistent line breaks inside function parentheses,Enforce consistent line breaks inside function parentheses See [rule details](https://eslint.style/rules/default/function-paren-newline) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.GeneratorStarSpacing,Enforce consistent spacing around `*` operators in generator functions,Enforce consistent spacing around `*` operators in generator functions See [rule details](https://eslint.style/rules/default/generator-star-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.ImplicitArrowLinebreak,Enforce the location of arrow function bodies,Enforce the location of arrow function bodies See [rule details](https://eslint.style/rules/default/implicit-arrow-linebreak) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.Indent,Enforce consistent indentation,Enforce consistent indentation See [rule details](https://eslint.style/rules/default/indent) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.IndentBinaryOps,Indentation for binary operators,Indentation for binary operators See [rule details](https://eslint.style/rules/default/indent-binary-ops) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxClosingBracketLocation,Enforce closing bracket location in JSX,Enforce closing bracket location in JSX See [rule details](https://eslint.style/rules/default/jsx-closing-bracket-location) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxClosingTagLocation,Enforce closing tag location for multiline JSX,Enforce closing tag location for multiline JSX See [rule details](https://eslint.style/rules/default/jsx-closing-tag-location) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxCurlyBracePresence,Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes,Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes See [rule details](https://eslint.style/rules/default/jsx-curly-brace-presence) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxCurlyNewline,Enforce consistent linebreaks in curly braces in JSX attributes and expressions,Enforce consistent linebreaks in curly braces in JSX attributes and expressions See [rule details](https://eslint.style/rules/default/jsx-curly-newline) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxCurlySpacing,Enforce or disallow spaces inside of curly braces in JSX attributes and expressions,Enforce or disallow spaces inside of curly braces in JSX attributes and expressions See [rule details](https://eslint.style/rules/default/jsx-curly-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxEqualsSpacing,Enforce or disallow spaces around equal signs in JSX attributes,Enforce or disallow spaces around equal signs in JSX attributes See [rule details](https://eslint.style/rules/default/jsx-equals-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxFirstPropNewLine,Enforce proper position of the first property in JSX,Enforce proper position of the first property in JSX See [rule details](https://eslint.style/rules/default/jsx-first-prop-new-line) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxIndent,Enforce JSX indentation,Enforce JSX indentation See [rule details](https://eslint.style/rules/default/jsx-indent) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxIndentProps,Enforce props indentation in JSX,Enforce props indentation in JSX See [rule details](https://eslint.style/rules/default/jsx-indent-props) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxMaxPropsPerLine,Enforce maximum of props on a single line in JSX,Enforce maximum of props on a single line in JSX See [rule details](https://eslint.style/rules/default/jsx-max-props-per-line) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxNewline,Require or prevent a new line after jsx elements and expressions.,Require or prevent a new line after jsx elements and expressions. See [rule details](https://eslint.style/rules/default/jsx-newline) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxOneExpressionPerLine,Require one JSX element per line,Require one JSX element per line See [rule details](https://eslint.style/rules/default/jsx-one-expression-per-line) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxPascalCase,Enforce PascalCase for user-defined JSX components,Enforce PascalCase for user-defined JSX components See [rule details](https://eslint.style/rules/default/jsx-pascal-case) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxPropsNoMultiSpaces,Disallow multiple spaces between inline JSX props,Disallow multiple spaces between inline JSX props See [rule details](https://eslint.style/rules/default/jsx-props-no-multi-spaces) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxQuotes,Enforce the consistent use of either double or single quotes in JSX attributes,Enforce the consistent use of either double or single quotes in JSX attributes See [rule details](https://eslint.style/rules/default/jsx-quotes) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxSelfClosingComp,Disallow extra closing tags for components without children,Disallow extra closing tags for components without children See [rule details](https://eslint.style/rules/default/jsx-self-closing-comp) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxSortProps,Enforce props alphabetical sorting,Enforce props alphabetical sorting See [rule details](https://eslint.style/rules/default/jsx-sort-props) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxTagSpacing,Enforce whitespace in and around the JSX opening and closing brackets,Enforce whitespace in and around the JSX opening and closing brackets See [rule details](https://eslint.style/rules/default/jsx-tag-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.JsxWrapMultilines,Disallow missing parentheses around multiline JSX,Disallow missing parentheses around multiline JSX See [rule details](https://eslint.style/rules/default/jsx-wrap-multilines) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.KeySpacing,Enforce consistent spacing between keys and values in object literal properties,Enforce consistent spacing between keys and values in object literal properties See [rule details](https://eslint.style/rules/default/key-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.KeywordSpacing,Enforce consistent spacing before and after keywords,Enforce consistent spacing before and after keywords See [rule details](https://eslint.style/rules/default/keyword-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.LinebreakStyle,Enforce consistent linebreak style,Enforce consistent linebreak style See [rule details](https://eslint.style/rules/default/linebreak-style) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.LinesAroundComment,Require empty lines around comments,Require empty lines around comments See [rule details](https://eslint.style/rules/default/lines-around-comment) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.LinesBetweenClassMembers,Require or disallow an empty line between class members,Require or disallow an empty line between class members See [rule details](https://eslint.style/rules/default/lines-between-class-members) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.MemberDelimiterStyle,Require a specific member delimiter style for interfaces and type literals,Require a specific member delimiter style for interfaces and type literals See [rule details](https://eslint.style/rules/default/member-delimiter-style) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.MultilineTernary,Enforce newlines between operands of ternary expressions,Enforce newlines between operands of ternary expressions See [rule details](https://eslint.style/rules/default/multiline-ternary) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.NewParens,Enforce or disallow parentheses when invoking a constructor with no arguments,Enforce or disallow parentheses when invoking a constructor with no arguments See [rule details](https://eslint.style/rules/default/new-parens) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.NewlinePerChainedCall,Require a newline after each call in a method chain,Require a newline after each call in a method chain See [rule details](https://eslint.style/rules/default/newline-per-chained-call) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.NoConfusingArrow,Disallow arrow functions where they could be confused with comparisons,Disallow arrow functions where they could be confused with comparisons See [rule details](https://eslint.style/rules/default/no-confusing-arrow) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.NoExtraParens,Disallow unnecessary parentheses,Disallow unnecessary parentheses See [rule details](https://eslint.style/rules/default/no-extra-parens) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.NoExtraSemi,Disallow unnecessary semicolons,Disallow unnecessary semicolons See [rule details](https://eslint.style/rules/default/no-extra-semi) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.NoFloatingDecimal,Disallow leading or trailing decimal points in numeric literals,Disallow leading or trailing decimal points in numeric literals See [rule details](https://eslint.style/rules/default/no-floating-decimal) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.NoMultiSpaces,Disallow multiple spaces,Disallow multiple spaces See [rule details](https://eslint.style/rules/default/no-multi-spaces) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.NoMultipleEmptyLines,Disallow multiple empty lines,Disallow multiple empty lines See [rule details](https://eslint.style/rules/default/no-multiple-empty-lines) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.NoTrailingSpaces,Disallow trailing whitespace at the end of lines,Disallow trailing whitespace at the end of lines See [rule details](https://eslint.style/rules/default/no-trailing-spaces) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.NoWhitespaceBeforeProperty,Disallow whitespace before properties,Disallow whitespace before properties See [rule details](https://eslint.style/rules/default/no-whitespace-before-property) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.NonblockStatementBodyPosition,Enforce the location of single-line statements,Enforce the location of single-line statements See [rule details](https://eslint.style/rules/default/nonblock-statement-body-position) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.ObjectCurlyNewline,Enforce consistent line breaks after opening and before closing braces,Enforce consistent line breaks after opening and before closing braces See [rule details](https://eslint.style/rules/default/object-curly-newline) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.ObjectCurlySpacing,Enforce consistent spacing inside braces,Enforce consistent spacing inside braces See [rule details](https://eslint.style/rules/default/object-curly-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.ObjectPropertyNewline,Enforce placing object properties on separate lines,Enforce placing object properties on separate lines See [rule details](https://eslint.style/rules/default/object-property-newline) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.OneVarDeclarationPerLine,Require or disallow newlines around variable declarations,Require or disallow newlines around variable declarations See [rule details](https://eslint.style/rules/default/one-var-declaration-per-line) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.OperatorLinebreak,Enforce consistent linebreak style for operators,Enforce consistent linebreak style for operators See [rule details](https://eslint.style/rules/default/operator-linebreak) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.PaddedBlocks,Require or disallow padding within blocks,Require or disallow padding within blocks See [rule details](https://eslint.style/rules/default/padded-blocks) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.PaddingLineBetweenStatements,Require or disallow padding lines between statements,Require or disallow padding lines between statements See [rule details](https://eslint.style/rules/default/padding-line-between-statements) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.QuoteProps,Require quotes around object literal property names,Require quotes around object literal property names See [rule details](https://eslint.style/rules/default/quote-props) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.Quotes,Enforce the consistent use of either backticks double or single quotes,Enforce the consistent use of either backticks double or single quotes See [rule details](https://eslint.style/rules/default/quotes) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.RestSpreadSpacing,Enforce spacing between rest and spread operators and their expressions,Enforce spacing between rest and spread operators and their expressions See [rule details](https://eslint.style/rules/default/rest-spread-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.Semi,Require or disallow semicolons instead of ASI,Require or disallow semicolons instead of ASI See [rule details](https://eslint.style/rules/default/semi) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.SemiSpacing,Enforce consistent spacing before and after semicolons,Enforce consistent spacing before and after semicolons See [rule details](https://eslint.style/rules/default/semi-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.SemiStyle,Enforce location of semicolons,Enforce location of semicolons See [rule details](https://eslint.style/rules/default/semi-style) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.SpaceBeforeBlocks,Enforce consistent spacing before blocks,Enforce consistent spacing before blocks See [rule details](https://eslint.style/rules/default/space-before-blocks) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.SpaceBeforeFunctionParen,Enforce consistent spacing before `function` definition opening parenthesis,Enforce consistent spacing before `function` definition opening parenthesis See [rule details](https://eslint.style/rules/default/space-before-function-paren) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.SpaceInParens,Enforce consistent spacing inside parentheses,Enforce consistent spacing inside parentheses See [rule details](https://eslint.style/rules/default/space-in-parens) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.SpaceInfixOps,Require spacing around infix operators,Require spacing around infix operators See [rule details](https://eslint.style/rules/default/space-infix-ops) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.SpaceUnaryOps,Enforce consistent spacing before or after unary operators,Enforce consistent spacing before or after unary operators See [rule details](https://eslint.style/rules/default/space-unary-ops) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.SpacedComment,Enforce consistent spacing after the `//` or `/*` in a comment,Enforce consistent spacing after the `//` or `/*` in a comment See [rule details](https://eslint.style/rules/default/spaced-comment) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.SwitchColonSpacing,Enforce spacing around colons of switch statements,Enforce spacing around colons of switch statements See [rule details](https://eslint.style/rules/default/switch-colon-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.TemplateCurlySpacing,Require or disallow spacing around embedded expressions of template strings,Require or disallow spacing around embedded expressions of template strings See [rule details](https://eslint.style/rules/default/template-curly-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.TemplateTagSpacing,Require or disallow spacing between template tags and their literals,Require or disallow spacing between template tags and their literals See [rule details](https://eslint.style/rules/default/template-tag-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.TypeAnnotationSpacing,Require consistent spacing around type annotations,Require consistent spacing around type annotations See [rule details](https://eslint.style/rules/default/type-annotation-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.TypeGenericSpacing,Enforces consistent spacing inside TypeScript type generics,Enforces consistent spacing inside TypeScript type generics See [rule details](https://eslint.style/rules/default/type-generic-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.TypeNamedTupleSpacing,Expect space before the type declaration in the named tuple,Expect space before the type declaration in the named tuple See [rule details](https://eslint.style/rules/default/type-named-tuple-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.WrapIife,Require parentheses around immediate `function` invocations,Require parentheses around immediate `function` invocations See [rule details](https://eslint.style/rules/default/wrap-iife) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.WrapRegex,Require parenthesis around regex literals,Require parenthesis around regex literals See [rule details](https://eslint.style/rules/default/wrap-regex) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.format.YieldStarSpacing,Require or disallow spacing around the `*` in `yield*` expressions,Require or disallow spacing around the `*` in `yield*` expressions See [rule details](https://eslint.style/rules/default/yield-star-spacing) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.RecommendedsvelteCodeCleanup,Recommended svelte code cleanup,Collection of cleanup ESLint rules from [eslint-plugin-svelte](https://github.com/sveltejs/eslint-plugin-svelte). ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.NoDynamicSlotName,disallow dynamic slot name,disallow dynamic slot name See rule details for [svelte/no-dynamic-slot-name](https://sveltejs.github.io/eslint-plugin-svelte/rules/no-dynamic-slot-name/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.RequireStoreReactiveAccess,disallow to use of the store itself as an operand. Need to use $ prefix or get function.,disallow to use of the store itself as an operand. Need to use $ prefix or get function. See rule details for [svelte/require-store-reactive-access](https://sveltejs.github.io/eslint-plugin-svelte/rules/require-store-reactive-access/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.NoUselessMustaches,disallow unnecessary mustache interpolations,disallow unnecessary mustache interpolations See rule details for [svelte/no-useless-mustaches](https://sveltejs.github.io/eslint-plugin-svelte/rules/no-useless-mustaches/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.FirstAttributeLinebreak,enforce the location of first attribute,enforce the location of first attribute See rule details for [svelte/first-attribute-linebreak](https://sveltejs.github.io/eslint-plugin-svelte/rules/first-attribute-linebreak/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.HtmlClosingBracketSpacing,require or disallow a space before tag's closing brackets,require or disallow a space before tag's closing brackets See rule details for [svelte/html-closing-bracket-spacing](https://sveltejs.github.io/eslint-plugin-svelte/rules/html-closing-bracket-spacing/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.HtmlQuotes,enforce quotes style of HTML attributes,enforce quotes style of HTML attributes See rule details for [svelte/html-quotes](https://sveltejs.github.io/eslint-plugin-svelte/rules/html-quotes/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.HtmlSelfClosing,enforce self-closing style,enforce self-closing style See rule details for [svelte/html-self-closing](https://sveltejs.github.io/eslint-plugin-svelte/rules/html-self-closing/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.Indent,enforce consistent indentation,enforce consistent indentation See rule details for [svelte/indent](https://sveltejs.github.io/eslint-plugin-svelte/rules/indent/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.MaxAttributesPerLine,enforce the maximum number of attributes per line,enforce the maximum number of attributes per line See rule details for [svelte/max-attributes-per-line](https://sveltejs.github.io/eslint-plugin-svelte/rules/max-attributes-per-line/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.MustacheSpacing,enforce unified spacing in mustache,enforce unified spacing in mustache See rule details for [svelte/mustache-spacing](https://sveltejs.github.io/eslint-plugin-svelte/rules/mustache-spacing/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.NoSpacesAroundEqualSignsInAttribute,disallow spaces around equal signs in attribute,disallow spaces around equal signs in attribute See rule details for [svelte/no-spaces-around-equal-signs-in-attribute](https://sveltejs.github.io/eslint-plugin-svelte/rules/no-spaces-around-equal-signs-in-attribute/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.PreferClassDirective,require class directives instead of ternary expressions,require class directives instead of ternary expressions See rule details for [svelte/prefer-class-directive](https://sveltejs.github.io/eslint-plugin-svelte/rules/prefer-class-directive/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.PreferStyleDirective,require style directives instead of style attribute,require style directives instead of style attribute See rule details for [svelte/prefer-style-directive](https://sveltejs.github.io/eslint-plugin-svelte/rules/prefer-style-directive/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.ShorthandAttribute,enforce use of shorthand syntax in attribute,enforce use of shorthand syntax in attribute See rule details for [svelte/shorthand-attribute](https://sveltejs.github.io/eslint-plugin-svelte/rules/shorthand-attribute/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.ShorthandDirective,enforce use of shorthand syntax in directives,enforce use of shorthand syntax in directives See rule details for [svelte/shorthand-directive](https://sveltejs.github.io/eslint-plugin-svelte/rules/shorthand-directive/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.SortAttributes,enforce order of attributes,enforce order of attributes See rule details for [svelte/sort-attributes](https://sveltejs.github.io/eslint-plugin-svelte/rules/sort-attributes/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.svelte.SpacedHtmlComment,enforce consistent spacing after the in a HTML comment,enforce consistent spacing after the in a HTML comment See rule details for [svelte/spaced-html-comment](https://sveltejs.github.io/eslint-plugin-svelte/rules/spaced-html-comment/) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.RecommendedVueCodeCleanup,Recommended vue code cleanup,Collection of cleanup ESLint rules from [eslint-plugin-vue](https://eslint.vuejs.org/). ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.AttributesOrder,Enforce order of attributes,Enforce order of attributes See rule details for [vue/attributes-order](https://eslint.vuejs.org/rules/attributes-order.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.ComponentTagsOrder,Enforce order of component top-level elements,Enforce order of component top-level elements See rule details for [vue/component-tags-order](https://eslint.vuejs.org/rules/component-tags-order.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.OrderInComponents,Enforce order of properties in components,Enforce order of properties in components See rule details for [vue/order-in-components](https://eslint.vuejs.org/rules/order-in-components.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.ThisInTemplate,Disallow usage of this in template,Disallow usage of this in template See rule details for [vue/this-in-template](https://eslint.vuejs.org/rules/this-in-template.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.BlockOrder,Enforce order of component top-level elements,Enforce order of component top-level elements See rule details for [vue/block-order](https://eslint.vuejs.org/rules/block-order.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.BlockTagNewline,Enforce line breaks after opening and before closing block-level tags,Enforce line breaks after opening and before closing block-level tags See rule details for [vue/block-tag-newline](https://eslint.vuejs.org/rules/block-tag-newline.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.ComponentNameInTemplateCasing,Enforce specific casing for the component naming style in template,Enforce specific casing for the component naming style in template See rule details for [vue/component-name-in-template-casing](https://eslint.vuejs.org/rules/component-name-in-template-casing.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.ComponentOptionsNameCasing,Enforce the casing of component name in components options,Enforce the casing of component name in components options See rule details for [vue/component-options-name-casing](https://eslint.vuejs.org/rules/component-options-name-casing.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.DefineMacrosOrder,Enforce order of defineEmits and defineProps compiler macros,Enforce order of defineEmits and defineProps compiler macros See rule details for [vue/define-macros-order](https://eslint.vuejs.org/rules/define-macros-order.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.HtmlCommentContentNewline,Enforce unified line brake in HTML comments,Enforce unified line brake in HTML comments See rule details for [vue/html-comment-content-newline](https://eslint.vuejs.org/rules/html-comment-content-newline.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.HtmlCommentContentSpacing,Enforce unified spacing in HTML comments,Enforce unified spacing in HTML comments See rule details for [vue/html-comment-content-spacing](https://eslint.vuejs.org/rules/html-comment-content-spacing.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.HtmlCommentIndent,Enforce consistent indentation in HTML comments,Enforce consistent indentation in HTML comments See rule details for [vue/html-comment-indent](https://eslint.vuejs.org/rules/html-comment-indent.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.NewLineBetweenMultiLineProperty,Enforce new lines between multi-line properties in Vue components,Enforce new lines between multi-line properties in Vue components See rule details for [vue/new-line-between-multi-line-property](https://eslint.vuejs.org/rules/new-line-between-multi-line-property.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.NextTickStyle,Enforce Promise or callback style in nextTick,Enforce Promise or callback style in nextTick See rule details for [vue/next-tick-style](https://eslint.vuejs.org/rules/next-tick-style.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.NoRequiredPropWithDefault,Enforce props with default values to be optional,Enforce props with default values to be optional See rule details for [vue/no-required-prop-with-default](https://eslint.vuejs.org/rules/no-required-prop-with-default.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.NoUnsupportedFeatures,Disallow unsupported Vue.js syntax on the specified version,Disallow unsupported Vue.js syntax on the specified version See rule details for [vue/no-unsupported-features](https://eslint.vuejs.org/rules/no-unsupported-features.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.NoUselessMustaches,Disallow unnecessary mustache interpolations,Disallow unnecessary mustache interpolations See rule details for [vue/no-useless-mustaches](https://eslint.vuejs.org/rules/no-useless-mustaches.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.NoUselessVBind,Disallow unnecessary v-bind directives,Disallow unnecessary v-bind directives See rule details for [vue/no-useless-v-bind](https://eslint.vuejs.org/rules/no-useless-v-bind.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.PaddingLineBetweenBlocks,Require or disallow padding lines between blocks,Require or disallow padding lines between blocks See rule details for [vue/padding-line-between-blocks](https://eslint.vuejs.org/rules/padding-line-between-blocks.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.PaddingLineBetweenTags,Require or disallow newlines between sibling tags in template,Require or disallow newlines between sibling tags in template See rule details for [vue/padding-line-between-tags](https://eslint.vuejs.org/rules/padding-line-between-tags.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.PaddingLinesInComponentDefinition,Require or disallow padding lines in component definition,Require or disallow padding lines in component definition See rule details for [vue/padding-lines-in-component-definition](https://eslint.vuejs.org/rules/padding-lines-in-component-definition.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.PreferDefineOptions,Enforce use of defineOptions instead of default export.,Enforce use of defineOptions instead of default export. See rule details for [vue/prefer-define-options](https://eslint.vuejs.org/rules/prefer-define-options.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.PreferSeparateStaticClass,Require static class names in template to be in a separate class attribute,Require static class names in template to be in a separate class attribute See rule details for [vue/prefer-separate-static-class](https://eslint.vuejs.org/rules/prefer-separate-static-class.html) ,org.openrewrite.recipe:rewrite-codemods:0.21.0-20251021.180900-12 +org.openrewrite.codemods.cleanup.vue.ScriptIndent,Enforce consistent indentation in `