Skip to main content

8.45.0 release (2025-02-08)

Total recipe count: 3041

info

This changelog only shows what recipes have been added, removed, or changed. OpenRewrite may do releases that do not include these types of changes. To see these changes, please go to the releases page.

New Artifacts​

  • rewrite-rewrite

New Recipes​

static final class AssertThatStringContains {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(String string, CharSequence substring) {
        return assertThat(string.contains(substring)).isTrue();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractStringAssert<?> after(String string, CharSequence substring) {
        return assertThat(string).contains(substring);
    }
}

.

static final class AssertThatStringDoesNotContain {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(String string, CharSequence substring) {
        return assertThat(string.contains(substring)).isFalse();
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractStringAssert<?> after(String string, CharSequence substring) {
        return assertThat(string).doesNotContain(substring);
    }
}

.

static final class AssertThatThrownByIOExceptionRootCauseHasMessage {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatThrownByIOException")
    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
        return assertThatIOException().isThrownBy(throwingCallable).havingRootCause().withMessage(message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
        return assertThatThrownBy(throwingCallable).isInstanceOf(IOException.class).rootCause().hasMessage(message);
    }
}

.

static final class AssertThatThrownByIllegalArgumentExceptionRootCauseHasMessage {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatThrownByIllegalArgumentException")
    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
        return assertThatIllegalArgumentException().isThrownBy(throwingCallable).havingRootCause().withMessage(message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
        return assertThatThrownBy(throwingCallable).isInstanceOf(IllegalArgumentException.class).rootCause().hasMessage(message);
    }
}

.

static final class AssertThatThrownByIllegalStateExceptionRootCauseHasMessage {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatThrownByIllegalStateException")
    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
        return assertThatIllegalStateException().isThrownBy(throwingCallable).havingRootCause().withMessage(message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
        return assertThatThrownBy(throwingCallable).isInstanceOf(IllegalStateException.class).rootCause().hasMessage(message);
    }
}

.

static final class AssertThatThrownByNullPointerExceptionRootCauseHasMessage {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatThrownByNullPointerException")
    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
        return assertThatNullPointerException().isThrownBy(throwingCallable).havingRootCause().withMessage(message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message) {
        return assertThatThrownBy(throwingCallable).isInstanceOf(NullPointerException.class).rootCause().hasMessage(message);
    }
}

.

static final class AssertThatThrownByRootCauseHasMessage {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatThrownByAsInstanceOfThrowable")
    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, Class<? extends Throwable> exceptionType, String message) {
        return assertThatExceptionOfType(exceptionType).isThrownBy(throwingCallable).havingRootCause().withMessage(message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, Class<? extends Throwable> exceptionType, String message) {
        return assertThatThrownBy(throwingCallable).isInstanceOf(exceptionType).rootCause().hasMessage(message);
    }
}

.

static final class AssertThatBooleanArrayContainsExactly {
    
    @BeforeTemplate
    void before(boolean[] actual, boolean[] expected) {
        assertArrayEquals(expected, actual);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(boolean[] actual, boolean[] expected) {
        assertThat(actual).containsExactly(expected);
    }
}

.

static final class AssertThatBooleanArrayWithFailMessageContainsExactly {
    
    @BeforeTemplate
    void before(boolean[] actual, String message, boolean[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(boolean[] actual, String message, boolean[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatBooleanArrayWithFailMessageSupplierContainsExactly {
    
    @BeforeTemplate
    void before(boolean[] actual, Supplier<String> message, boolean[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(boolean[] actual, Supplier<String> message, boolean[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatByteArrayContainsExactly {
    
    @BeforeTemplate
    void before(byte[] actual, byte[] expected) {
        assertArrayEquals(expected, actual);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(byte[] actual, byte[] expected) {
        assertThat(actual).containsExactly(expected);
    }
}

.

static final class AssertThatByteArrayWithFailMessageContainsExactly {
    
    @BeforeTemplate
    void before(byte[] actual, String message, byte[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(byte[] actual, String message, byte[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatByteArrayWithFailMessageSupplierContainsExactly {
    
    @BeforeTemplate
    void before(byte[] actual, Supplier<String> message, byte[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(byte[] actual, Supplier<String> message, byte[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatCharArrayContainsExactly {
    
    @BeforeTemplate
    void before(char[] actual, char[] expected) {
        assertArrayEquals(expected, actual);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(char[] actual, char[] expected) {
        assertThat(actual).containsExactly(expected);
    }
}

.

static final class AssertThatCharArrayWithFailMessageContainsExactly {
    
    @BeforeTemplate
    void before(char[] actual, String message, char[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(char[] actual, String message, char[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatCharArrayWithFailMessageSupplierContainsExactly {
    
    @BeforeTemplate
    void before(char[] actual, Supplier<String> message, char[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(char[] actual, Supplier<String> message, char[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatDoubleArrayContainsExactly {
    
    @BeforeTemplate
    void before(double[] actual, double[] expected) {
        assertArrayEquals(expected, actual);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(double[] actual, double[] expected) {
        assertThat(actual).containsExactly(expected);
    }
}

.

static final class AssertThatDoubleArrayContainsExactlyWithOffset {
    
    @BeforeTemplate
    void before(double[] actual, double[] expected, double delta) {
        assertArrayEquals(expected, actual, delta);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(double[] actual, double[] expected, double delta) {
        assertThat(actual).containsExactly(expected, offset(delta));
    }
}

.

static final class AssertThatDoubleArrayWithFailMessageContainsExactly {
    
    @BeforeTemplate
    void before(double[] actual, String message, double[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(double[] actual, String message, double[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatDoubleArrayWithFailMessageContainsExactlyWithOffset {
    
    @BeforeTemplate
    void before(double[] actual, String message, double[] expected, double delta) {
        assertArrayEquals(expected, actual, delta, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(double[] actual, String message, double[] expected, double delta) {
        assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
    }
}

.

static final class AssertThatDoubleArrayWithFailMessageSupplierContainsExactly {
    
    @BeforeTemplate
    void before(double[] actual, Supplier<String> message, double[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(double[] actual, Supplier<String> message, double[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatDoubleArrayWithFailMessageSupplierContainsExactlyWithOffset {
    
    @BeforeTemplate
    void before(double[] actual, Supplier<String> messageSupplier, double[] expected, double delta) {
        assertArrayEquals(expected, actual, delta, messageSupplier);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(double[] actual, Supplier<String> messageSupplier, double[] expected, double delta) {
        assertThat(actual).withFailMessage(messageSupplier).containsExactly(expected, offset(delta));
    }
}

.

static final class AssertThatFloatArrayContainsExactly {
    
    @BeforeTemplate
    void before(float[] actual, float[] expected) {
        assertArrayEquals(expected, actual);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(float[] actual, float[] expected) {
        assertThat(actual).containsExactly(expected);
    }
}

.

static final class AssertThatFloatArrayContainsExactlyWithOffset {
    
    @BeforeTemplate
    void before(float[] actual, float[] expected, float delta) {
        assertArrayEquals(expected, actual, delta);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(float[] actual, float[] expected, float delta) {
        assertThat(actual).containsExactly(expected, offset(delta));
    }
}

.

static final class AssertThatFloatArrayWithFailMessageContainsExactly {
    
    @BeforeTemplate
    void before(float[] actual, String message, float[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(float[] actual, String message, float[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatFloatArrayWithFailMessageContainsExactlyWithOffset {
    
    @BeforeTemplate
    void before(float[] actual, String message, float[] expected, float delta) {
        assertArrayEquals(expected, actual, delta, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(float[] actual, String message, float[] expected, float delta) {
        assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
    }
}

.

static final class AssertThatFloatArrayWithFailMessageSupplierContainsExactly {
    
    @BeforeTemplate
    void before(float[] actual, Supplier<String> message, float[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(float[] actual, Supplier<String> message, float[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatFloatArrayWithFailMessageSupplierContainsExactlyWithOffset {
    
    @BeforeTemplate
    void before(float[] actual, Supplier<String> message, float[] expected, float delta) {
        assertArrayEquals(expected, actual, delta, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(float[] actual, Supplier<String> message, float[] expected, float delta) {
        assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
    }
}

.

static final class AssertThatIntArrayContainsExactly {
    
    @BeforeTemplate
    void before(int[] actual, int[] expected) {
        assertArrayEquals(expected, actual);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(int[] actual, int[] expected) {
        assertThat(actual).containsExactly(expected);
    }
}

.

static final class AssertThatIntArrayWithFailMessageContainsExactly {
    
    @BeforeTemplate
    void before(int[] actual, String message, int[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(int[] actual, String message, int[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatIntArrayWithFailMessageSupplierContainsExactly {
    
    @BeforeTemplate
    void before(int[] actual, Supplier<String> message, int[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(int[] actual, Supplier<String> message, int[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatLongArrayContainsExactly {
    
    @BeforeTemplate
    void before(long[] actual, long[] expected) {
        assertArrayEquals(expected, actual);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(long[] actual, long[] expected) {
        assertThat(actual).containsExactly(expected);
    }
}

.

static final class AssertThatLongArrayWithFailMessageContainsExactly {
    
    @BeforeTemplate
    void before(long[] actual, String message, long[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(long[] actual, String message, long[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatLongArrayWithFailMessageSupplierContainsExactly {
    
    @BeforeTemplate
    void before(long[] actual, Supplier<String> message, long[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(long[] actual, Supplier<String> message, long[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatObjectArrayContainsExactly {
    
    @BeforeTemplate
    void before(Object[] actual, Object[] expected) {
        assertArrayEquals(expected, actual);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Object[] actual, Object[] expected) {
        assertThat(actual).containsExactly(expected);
    }
}

.

static final class AssertThatObjectArrayWithFailMessageContainsExactly {
    
    @BeforeTemplate
    void before(Object[] actual, String message, Object[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Object[] actual, String message, Object[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatObjectArrayWithFailMessageSupplierContainsExactly {
    
    @BeforeTemplate
    void before(Object[] actual, Supplier<String> message, Object[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Object[] actual, Supplier<String> message, Object[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatShortArrayContainsExactly {
    
    @BeforeTemplate
    void before(short[] actual, short[] expected) {
        assertArrayEquals(expected, actual);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(short[] actual, short[] expected) {
        assertThat(actual).containsExactly(expected);
    }
}

.

static final class AssertThatShortArrayWithFailMessageContainsExactly {
    
    @BeforeTemplate
    void before(short[] actual, String message, short[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(short[] actual, String message, short[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertThatShortArrayWithFailMessageSupplierContainsExactly {
    
    @BeforeTemplate
    void before(short[] actual, Supplier<String> message, short[] expected) {
        assertArrayEquals(expected, actual, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(short[] actual, Supplier<String> message, short[] expected) {
        assertThat(actual).withFailMessage(message).containsExactly(expected);
    }
}

.

static final class AssertEqualDoubleArraysWithDelta {
    
    @BeforeTemplate
    void before(double[] actual, double[] expected, double delta) {
        assertEquals(actual, expected, delta);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(double[] actual, double[] expected, double delta) {
        assertThat(actual).containsExactly(expected, offset(delta));
    }
}

.

static final class AssertEqualDoubleArraysWithDeltaWithMessage {
    
    @BeforeTemplate
    void before(double[] actual, String message, double[] expected, double delta) {
        assertEquals(actual, expected, delta, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(double[] actual, String message, double[] expected, double delta) {
        assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
    }
}

.

static final class AssertEqualFloatArraysWithDelta {
    
    @BeforeTemplate
    void before(float[] actual, float[] expected, float delta) {
        assertEquals(actual, expected, delta);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(float[] actual, float[] expected, float delta) {
        assertThat(actual).containsExactly(expected, offset(delta));
    }
}

.

static final class AssertEqualFloatArraysWithDeltaWithMessage {
    
    @BeforeTemplate
    void before(float[] actual, String message, float[] expected, float delta) {
        assertEquals(actual, expected, delta, message);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(float[] actual, String message, float[] expected, float delta) {
        assertThat(actual).withFailMessage(message).containsExactly(expected, offset(delta));
    }
}

.

Removed Recipes​

  • io.moderne.ai.SpellCheckCommentsInFrenchPomXml: Use spellchecker to fix mis-encoded French comments in pom.xml files. Mis-encoded comments will contain either '?' or '�'.
  • org.openrewrite.codemods.migrate.nextjs.v14_0.UseViewportExport: This codemod migrates certain viewport metadata to viewport export. See documentation for more information.
  • org.openrewrite.codemods.migrate.nextjs.v6.UrlToWithRouter: Transforms the deprecated automatically injected url property on top level pages to using withRouter and the router property it injects. Read more here: https://nextjs.org/docs/messages/url-deprecated See documentation for more information.
  • org.openrewrite.codemods.migrate.nextjs.v8.WithAmpToConfig: Transforms the withAmp HOC into Next.js 9 page configuration. See documentation for more information.
  • org.openrewrite.java.camel.migrate.ChangePropertyValue: Apache Camel API migration from version 3.20 or higher to 4.0. Removal of deprecated APIs, which could be part of the application.properties.
  • tech.picnic.errorprone.refasterrules.AssertJStringRulesRecipes$AssertThatStringIsEmptyRecipe: Recipe created for the following Refaster template:
static final class AssertThatStringIsEmpty {

  @BeforeTemplate
  void before(String string) {
    assertThat(string.isEmpty()).isTrue();
  }

  @AfterTemplate
  @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
  void after(String string) {
    assertThat(string).isEmpty();
  }
}

.

  • tech.picnic.errorprone.refasterrules.AssertJStringRulesRecipes$AssertThatStringIsNotEmptyRecipe: Recipe created for the following Refaster template:
static final class AssertThatStringIsNotEmpty {

  @BeforeTemplate
  AbstractAssert<?, ?> before(String string) {
    return assertThat(string.isEmpty()).isFalse();
  }

  @AfterTemplate
  @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
  AbstractAssert<?, ?> after(String string) {
    return assertThat(string).isNotEmpty();
  }
}

.

  • tech.picnic.errorprone.refasterrules.AssertJThrowingCallableRulesRecipes$AssertThatThrownByRecipe: Recipe created for the following Refaster template:
static final class AssertThatThrownBy {

  @BeforeTemplate
  AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, Class<? extends Throwable> exceptionType) {
    return assertThatExceptionOfType(exceptionType).isThrownBy(throwingCallable);
  }

  @AfterTemplate
  @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
  AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, Class<? extends Throwable> exceptionType) {
    return assertThatThrownBy(throwingCallable).isInstanceOf(exceptionType);
  }
}

.

  • tech.picnic.errorprone.refasterrules.BugCheckerRulesRecipes$ConstantsFormatRecipe: Recipe created for the following Refaster template:
static final class ConstantsFormat {

  @BeforeTemplate
  String before(String value) {
    return String.format("\"%s\"", Convert.quote(value));
  }

  @AfterTemplate
  String after(String value) {
    return Constants.format(value);
  }
}

.

Changed Recipes​

  • org.openrewrite.FindParseFailures was changed:
    • Old Options:
      • maxSnippetLength: { type: Integer, required: false }
      • parserType: { type: String, required: false }
      • stackTrace: { type: String, required: false }
    • New Options:
      • createdAfter: { type: String, required: false }
      • maxSnippetLength: { type: Integer, required: false }
      • parserType: { type: String, required: false }
      • stackTrace: { type: String, required: false }
  • org.openrewrite.java.dependencies.DependencyList was changed:
    • Old Options:
      • includeTransitive: { type: boolean, required: true }
      • scope: { type: Scope, required: true }
    • New Options:
      • includeTransitive: { type: boolean, required: true }
      • scope: { type: Scope, required: true }
      • validateResolvable: { type: boolean, required: true }
  • org.openrewrite.yaml.MergeYaml was changed:
    • Old Options:
      • acceptTheirs: { type: Boolean, required: false }
      • filePattern: { type: String, required: false }
      • key: { type: String, required: true }
      • objectIdentifyingProperty: { type: String, required: false }
      • yaml: { type: String, required: true }
    • New Options:
      • acceptTheirs: { type: Boolean, required: false }
      • filePattern: { type: String, required: false }
      • insertBefore: { type: String, required: false }
      • key: { type: String, required: true }
      • objectIdentifyingProperty: { type: String, required: false }
      • yaml: { type: String, required: true }