RxJava2AdapterRules

SUGGESTION

Simplification

View source code on GitHub

Suppression

Disable all rules by adding -XepOpt:Refaster:NamePattern=^(?!RxJava2AdapterRules\$).* as compiler argument.

Table of contents

1. CompletableAsRxJava2AdapterCompletableToMono
2. FlowableAsRxJava2AdapterFlowableToFlux
3. FluxAsRxJava2AdapterFluxToFlowable
4. FluxAsRxJava2AdapterFluxToObservable
5. MaybeAsRxJava2AdapterMaybeToMono
6. MonoAsRxJava2AdapterMonoToCompletable
7. MonoAsRxJava2AdapterMonoToFlowable
8. MonoAsRxJava2AdapterMonoToMaybe
9. MonoAsRxJava2AdapterMonoToSingle
10. ObservableToFlowableAsRxJava2AdapterFlowableToFlux
11. SingleAsRxJava2AdapterSingleToMono

CompletableAsRxJava2AdapterCompletableToMono

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("CompletableAsRxJava2AdapterCompletableToMono") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!RxJava2AdapterRules\$CompletableAsRxJava2AdapterCompletableToMono).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Mono<Void>> testCompletableAsRxJava2AdapterCompletableToMono() {
   return ImmutableSet.of(
-      RxJava2Adapter.completableToMono(Completable.complete()),
-      Completable.never().to(RxJava2Adapter::completableToMono));
+      Completable.complete().as(RxJava2Adapter::completableToMono),
+      Completable.never().as(RxJava2Adapter::completableToMono));
 }

FlowableAsRxJava2AdapterFlowableToFlux

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("FlowableAsRxJava2AdapterFlowableToFlux") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!RxJava2AdapterRules\$FlowableAsRxJava2AdapterFlowableToFlux).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Flux<Integer>> testFlowableAsRxJava2AdapterFlowableToFlux() {
   return ImmutableSet.of(
-      Flux.from(Flowable.just(1)),
-      Flowable.just(2).to(Flux::from),
-      Flowable.just(3).as(Flux::from),
-      RxJava2Adapter.flowableToFlux(Flowable.just(4)),
-      Flowable.just(5).to(RxJava2Adapter::flowableToFlux));
+      Flowable.just(1).as(RxJava2Adapter::flowableToFlux),
+      Flowable.just(2).as(RxJava2Adapter::flowableToFlux),
+      Flowable.just(3).as(RxJava2Adapter::flowableToFlux),
+      Flowable.just(4).as(RxJava2Adapter::flowableToFlux),
+      Flowable.just(5).as(RxJava2Adapter::flowableToFlux));
 }

FluxAsRxJava2AdapterFluxToFlowable

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("FluxAsRxJava2AdapterFluxToFlowable") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!RxJava2AdapterRules\$FluxAsRxJava2AdapterFluxToFlowable).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Flowable<String>> testFluxAsRxJava2AdapterFluxToFlowable() {
   return ImmutableSet.of(
-      Flowable.fromPublisher(Flux.just("foo")),
-      Flux.just("bar").as(Flowable::fromPublisher),
-      RxJava2Adapter.fluxToFlowable(Flux.just("baz")));
+      Flux.just("foo").as(RxJava2Adapter::fluxToFlowable),
+      Flux.just("bar").as(RxJava2Adapter::fluxToFlowable),
+      Flux.just("baz").as(RxJava2Adapter::fluxToFlowable));
 }

FluxAsRxJava2AdapterFluxToObservable

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("FluxAsRxJava2AdapterFluxToObservable") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!RxJava2AdapterRules\$FluxAsRxJava2AdapterFluxToObservable).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Observable<Integer>> testFluxAsRxJava2AdapterFluxToObservable() {
   return ImmutableSet.of(
-      Observable.fromPublisher(Flux.just(1)),
-      Flux.just(2).as(Observable::fromPublisher),
-      RxJava2Adapter.fluxToObservable(Flux.just(3)));
+      Flux.just(1).as(RxJava2Adapter::fluxToObservable),
+      Flux.just(2).as(RxJava2Adapter::fluxToObservable),
+      Flux.just(3).as(RxJava2Adapter::fluxToObservable));
 }

MaybeAsRxJava2AdapterMaybeToMono

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("MaybeAsRxJava2AdapterMaybeToMono") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!RxJava2AdapterRules\$MaybeAsRxJava2AdapterMaybeToMono).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Mono<String>> testMaybeAsRxJava2AdapterMaybeToMono() {
   return ImmutableSet.of(
-      RxJava2Adapter.maybeToMono(Maybe.just("foo")),
-      Maybe.just("bar").to(RxJava2Adapter::maybeToMono));
+      Maybe.just("foo").as(RxJava2Adapter::maybeToMono),
+      Maybe.just("bar").as(RxJava2Adapter::maybeToMono));
 }

MonoAsRxJava2AdapterMonoToCompletable

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("MonoAsRxJava2AdapterMonoToCompletable") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!RxJava2AdapterRules\$MonoAsRxJava2AdapterMonoToCompletable).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Completable> testMonoAsRxJava2AdapterMonoToCompletable() {
   return ImmutableSet.of(
-      Completable.fromPublisher(Mono.empty()),
-      Mono.just(1).as(Completable::fromPublisher),
-      RxJava2Adapter.monoToCompletable(Mono.just(2)));
+      Mono.empty().as(RxJava2Adapter::monoToCompletable),
+      Mono.just(1).as(RxJava2Adapter::monoToCompletable),
+      Mono.just(2).as(RxJava2Adapter::monoToCompletable));
 }

MonoAsRxJava2AdapterMonoToFlowable

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("MonoAsRxJava2AdapterMonoToFlowable") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!RxJava2AdapterRules\$MonoAsRxJava2AdapterMonoToFlowable).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Flowable<Integer>> testMonoAsRxJava2AdapterMonoToFlowable() {
   return ImmutableSet.of(
-      Flowable.fromPublisher(Mono.just(1)),
-      Mono.just(2).as(Flowable::fromPublisher),
-      RxJava2Adapter.monoToFlowable(Mono.just(3)));
+      Mono.just(1).as(RxJava2Adapter::monoToFlowable),
+      Mono.just(2).as(RxJava2Adapter::monoToFlowable),
+      Mono.just(3).as(RxJava2Adapter::monoToFlowable));
 }

MonoAsRxJava2AdapterMonoToMaybe

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("MonoAsRxJava2AdapterMonoToMaybe") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!RxJava2AdapterRules\$MonoAsRxJava2AdapterMonoToMaybe).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 Maybe<String> testMonoAsRxJava2AdapterMonoToMaybe() {
-  return RxJava2Adapter.monoToMaybe(Mono.just("foo"));
+  return Mono.just("foo").as(RxJava2Adapter::monoToMaybe);
 }

MonoAsRxJava2AdapterMonoToSingle

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("MonoAsRxJava2AdapterMonoToSingle") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!RxJava2AdapterRules\$MonoAsRxJava2AdapterMonoToSingle).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Single<Integer>> testMonoAsRxJava2AdapterMonoToSingle() {
   return ImmutableSet.of(
-      Single.fromPublisher(Mono.just(1)),
-      Mono.just(2).as(Single::fromPublisher),
-      RxJava2Adapter.monoToSingle(Mono.just(3)));
+      Mono.just(1).as(RxJava2Adapter::monoToSingle),
+      Mono.just(2).as(RxJava2Adapter::monoToSingle),
+      Mono.just(3).as(RxJava2Adapter::monoToSingle));
 }

ObservableToFlowableAsRxJava2AdapterFlowableToFlux

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("ObservableToFlowableAsRxJava2AdapterFlowableToFlux") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!RxJava2AdapterRules\$ObservableToFlowableAsRxJava2AdapterFlowableToFlux).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Flux<String>> testObservableToFlowableAsRxJava2AdapterFlowableToFlux() {
   return ImmutableSet.of(
-      RxJava2Adapter.observableToFlux(Observable.just("foo"), BackpressureStrategy.BUFFER),
+      Observable.just("foo")
+          .toFlowable(BackpressureStrategy.BUFFER)
+          .as(RxJava2Adapter::flowableToFlux),
       Observable.just("bar")
-          .as(obs -> RxJava2Adapter.observableToFlux(obs, BackpressureStrategy.DROP)),
+          .toFlowable(BackpressureStrategy.DROP)
+          .as(RxJava2Adapter::flowableToFlux),
       Observable.just("baz")
-          .to(obs -> RxJava2Adapter.observableToFlux(obs, BackpressureStrategy.ERROR)));
+          .toFlowable(BackpressureStrategy.ERROR)
+          .as(RxJava2Adapter::flowableToFlux));
 }

SingleAsRxJava2AdapterSingleToMono

SUGGESTION

Simplification

Suppression

Suppress false positives by adding the suppression annotation @SuppressWarnings("SingleAsRxJava2AdapterSingleToMono") to the enclosing element.

Disable this rule by adding -XepOpt:Refaster:NamePattern=^(?!RxJava2AdapterRules\$SingleAsRxJava2AdapterSingleToMono).* as compiler argument.

Samples

Shows the difference in example code before and after the Refaster rule is applied.

 ImmutableSet<Mono<Integer>> testSingleAsRxJava2AdapterSingleToMono() {
   return ImmutableSet.of(
-      RxJava2Adapter.singleToMono(Single.just(1)),
-      Single.just(2).to(RxJava2Adapter::singleToMono));
+      Single.just(1).as(RxJava2Adapter::singleToMono),
+      Single.just(2).as(RxJava2Adapter::singleToMono));
 }