Skip to main content

8.63.0 release (2025-10-11)

Total recipe count: 4900

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.

Corresponding CLI version​

  • Stable CLI version v3.48.8
  • Staging CLI version: v3.49.0

New Artifacts​

  • rewrite-spring-to-quarkus

New Recipes​

static final class AssertThatDoesNotExist {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(File actual) {
        return assertThat(actual.exists()).isFalse();
    }
    
    @AfterTemplate
    AbstractFileAssert<?> after(File actual) {
        return assertThat(actual).doesNotExist();
    }
}

.

static final class AssertThatExists {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(File actual) {
        return assertThat(actual.exists()).isTrue();
    }
    
    @AfterTemplate
    AbstractFileAssert<?> after(File actual) {
        return assertThat(actual).exists();
    }
}

.

static final class AssertThatHasFileName {
    
    @BeforeTemplate
    AbstractStringAssert<?> before(File actual, String fileName) {
        return assertThat(actual.getName()).isEqualTo(fileName);
    }
    
    @AfterTemplate
    AbstractFileAssert<?> after(File actual, String fileName) {
        return assertThat(actual).hasFileName(fileName);
    }
}

.

static final class AssertThatHasNoParent {
    
    @BeforeTemplate
    void before(File actual) {
        assertThat(actual.getParent()).isNull();
    }
    
    @AfterTemplate
    void after(File actual) {
        assertThat(actual).hasNoParent();
    }
}

.

static final class AssertThatHasParentFile {
    
    @BeforeTemplate
    AbstractFileAssert<?> before(File actual, File expected) {
        return assertThat(actual.getParentFile()).isEqualTo(expected);
    }
    
    @AfterTemplate
    AbstractFileAssert<?> after(File actual, File expected) {
        return assertThat(actual).hasParent(expected);
    }
}

.

static final class AssertThatHasParentString {
    
    @BeforeTemplate
    AbstractFileAssert<?> before(File actual, String expected) {
        return assertThat(actual.getParentFile()).hasFileName(expected);
    }
    
    @AfterTemplate
    AbstractFileAssert<?> after(File actual, String expected) {
        return assertThat(actual).hasParent(expected);
    }
}

.

static final class AssertThatIsAbsolute {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(File actual) {
        return assertThat(actual.isAbsolute()).isTrue();
    }
    
    @AfterTemplate
    AbstractFileAssert<?> after(File actual) {
        return assertThat(actual).isAbsolute();
    }
}

.

static final class AssertThatIsDirectory {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(File actual) {
        return assertThat(actual.isDirectory()).isTrue();
    }
    
    @AfterTemplate
    AbstractFileAssert<?> after(File actual) {
        return assertThat(actual).isDirectory();
    }
}

.

static final class AssertThatIsExecutable {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(File actual) {
        return assertThat(actual.canExecute()).isTrue();
    }
    
    @AfterTemplate
    AbstractFileAssert<?> after(File actual) {
        return assertThat(actual).isExecutable();
    }
}

.

static final class AssertThatIsFile {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(File actual) {
        return assertThat(actual.isFile()).isTrue();
    }
    
    @AfterTemplate
    AbstractFileAssert<?> after(File actual) {
        return assertThat(actual).isFile();
    }
}

.

static final class AssertThatIsReadable {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(File actual) {
        return assertThat(actual.canRead()).isTrue();
    }
    
    @AfterTemplate
    AbstractFileAssert<?> after(File actual) {
        return assertThat(actual).isReadable();
    }
}

.

static final class AssertThatIsRelative {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(File actual) {
        return assertThat(actual.isAbsolute()).isFalse();
    }
    
    @AfterTemplate
    AbstractFileAssert<?> after(File actual) {
        return assertThat(actual).isRelative();
    }
}

.

static final class AssertThatIsWritable {
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before(File actual) {
        return assertThat(actual.canWrite()).isTrue();
    }
    
    @AfterTemplate
    AbstractFileAssert<?> after(File actual) {
        return assertThat(actual).isWritable();
    }
}

.

static final class AssertThatAnyMatch<T> {
    
    @BeforeTemplate
    ListAssert<T> before(Stream<T> stream, Predicate<? super T> predicate) {
        return assertThat(stream).filteredOn(predicate).isNotEmpty();
    }
    
    @BeforeTemplate
    AbstractBooleanAssert<?> before2(Stream<T> stream, Predicate<? super T> predicate) {
        return Refaster.anyOf(assertThat(stream.anyMatch(predicate)).isTrue(), assertThat(stream.noneMatch(predicate)).isFalse());
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<T> after(Stream<T> stream, Predicate<? super T> predicate) {
        return assertThat(stream).anyMatch(predicate);
    }
}

.

static final class AssertThatCollection<T> {
    
    @BeforeTemplate
    ListAssert<T> before(Collection<T> collection) {
        return assertThat(collection.stream());
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractCollectionAssert<?, ?, T, ?> after(Collection<T> collection) {
        return assertThat(collection);
    }
}

.

static final class AssertThatFilteredOn<T> {
    
    @BeforeTemplate
    ListAssert<T> before(Stream<T> stream, Predicate<? super T> predicate) {
        return assertThat(stream.filter(predicate));
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<T> after(Stream<T> stream, Predicate<? super T> predicate) {
        return assertThat(stream).filteredOn(predicate);
    }
}

.

static final class AssertThatNoneMatch<T> {
    
    @BeforeTemplate
    void before(Stream<T> stream, Predicate<? super T> predicate) {
        assertThat(stream).filteredOn(predicate).isEmpty();
    }
    
    @BeforeTemplate
    void before2(Stream<T> stream, Predicate<? super T> predicate) {
        Refaster.anyOf(assertThat(stream.anyMatch(predicate)).isFalse(), assertThat(stream.noneMatch(predicate)).isTrue());
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    void after(Stream<T> stream, Predicate<? super T> predicate) {
        assertThat(stream).noneMatch(predicate);
    }
}

.

Removed Recipes​

  • org.openrewrite.java.jackson.UpgradeJackson_2_And_3_Base_Exceptions: Jackson 3 contains new base exceptions which were also backported to 2.x. This recipe will migrate usage to the new base exceptions to prepare for a 3.x upgrade.
  • tech.picnic.errorprone.refasterrules.PrimitiveRulesRecipes$BooleanHashCodeRecipe: Prefer Boolean#hashCode(boolean) over the Guava alternative.
  • tech.picnic.errorprone.refasterrules.PrimitiveRulesRecipes$ByteHashCodeRecipe: Prefer Byte#hashCode(byte) over the Guava alternative.
  • tech.picnic.errorprone.refasterrules.PrimitiveRulesRecipes$CharacterHashCodeRecipe: Prefer Character#hashCode(char) over the Guava alternative.
  • tech.picnic.errorprone.refasterrules.PrimitiveRulesRecipes$DoubleHashCodeRecipe: Prefer Double#hashCode(double) over the Guava alternative.
  • tech.picnic.errorprone.refasterrules.PrimitiveRulesRecipes$DoubleIsFiniteRecipe: Prefer Double#isFinite(double) over the Guava alternative.
  • tech.picnic.errorprone.refasterrules.PrimitiveRulesRecipes$FloatHashCodeRecipe: Prefer Float#hashCode(float) over the Guava alternative.
  • tech.picnic.errorprone.refasterrules.PrimitiveRulesRecipes$FloatIsFiniteRecipe: Prefer Float#isFinite(float) over the Guava alternative.
  • tech.picnic.errorprone.refasterrules.PrimitiveRulesRecipes$IntegerHashCodeRecipe: Prefer Integer#hashCode(int) over the Guava alternative.
  • tech.picnic.errorprone.refasterrules.PrimitiveRulesRecipes$LongHashCodeRecipe: Prefer Long#hashCode(long) over the Guava alternative.
  • tech.picnic.errorprone.refasterrules.PrimitiveRulesRecipes$ShortHashCodeRecipe: Prefer Short#hashCode(short) over the Guava alternative.
  • tech.picnic.errorprone.refasterrules.ReactorRulesRecipes$FluxEmptyRecipe: Prefer Flux#empty() over more contrived alternatives.
  • tech.picnic.errorprone.refasterrules.StreamRulesRecipes$EmptyStreamRecipe: Prefer Stream#empty() over less clear alternatives.

Changed Recipes​