Merge pull request #3803 from neoranga55/fix-documentation-typos

1.x: Fix typos in documentation and some code

Author: akarnokd

build.gradle

@@ -23,7 +23,7 @@ javadoc {
     options {
         windowTitle = "RxJava Javadoc ${project.version}"
     }
-    // Clear the following options to make the docs consitent with the old format
+    // Clear the following options to make the docs consistent with the old format
     options.addStringOption('top').value = ''
     options.addStringOption('doctitle').value = ''
     options.addStringOption('header').value = ''

src/main/java/rx/Completable.java

@@ -752,7 +752,7 @@ static <T> T requireNonNull(T o) {
     }
 
     /**
-     * Returns a Completable instance that fires its onComplete event after the given delay ellapsed.
+     * Returns a Completable instance that fires its onComplete event after the given delay elapsed.
      * @param delay the delay time
      * @param unit the delay unit
      * @return the new Completable instance
@@ -762,7 +762,7 @@ public static Completable timer(long delay, TimeUnit unit) {
     }
 
     /**
-     * Returns a Completable instance that fires its onComplete event after the given delay ellapsed
+     * Returns a Completable instance that fires its onComplete event after the given delay elapsed
      * by using the supplied scheduler.
      * @param delay the delay time
      * @param unit the delay unit
@@ -1040,7 +1040,7 @@ public void onSubscribe(Subscription d) {
      * @param timeout the timeout value
      * @param unit the timeout unit
      * @return true if the this Completable instance completed normally within the time limit,
-     * false if the timeout ellapsed before this Completable terminated.
+     * false if the timeout elapsed before this Completable terminated.
      * @throws RuntimeException wrapping an InterruptedException if the current thread is interrupted
      */
     public final boolean await(long timeout, TimeUnit unit) {
@@ -1239,7 +1239,7 @@ public final Completable doOnCompleted(Action0 onCompleted) {
     }
 
     /**
-     * Returns a Completable which calls the giveon onUnsubscribe callback if the child subscriber cancels
+     * Returns a Completable which calls the given onUnsubscribe callback if the child subscriber cancels
      * the subscription.
      * @param onUnsubscribe the callback to call when the child subscriber cancels the subscription
      * @return the new Completable instance
@@ -1395,7 +1395,7 @@ public final <T> Observable<T> endWith(Observable<T> next) {
     }
 
     /**
-     * Returns a Completable instace that calls the given onAfterComplete callback after this
+     * Returns a Completable instance that calls the given onAfterComplete callback after this
      * Completable completes normally.
      * @param onAfterComplete the callback to call after this Completable emits an onComplete event.
      * @return the new Completable instance
@@ -1448,10 +1448,10 @@ public void onSubscribe(Subscription d) {
 
     /**
      * Subscribes to this Completable instance and blocks until it terminates or the specified timeout 
-     * ellapses, then returns null for normal termination or the emitted exception if any.
+     * elapses, then returns null for normal termination or the emitted exception if any.
      * @return the throwable if this terminated with an error, null otherwise
      * @throws RuntimeException that wraps an InterruptedException if the wait is interrupted or
-     * TimeoutException if the specified timeout ellapsed before it
+     * TimeoutException if the specified timeout elapsed before it
      */
     public final Throwable get(long timeout, TimeUnit unit) {
         requireNonNull(unit);
@@ -2128,7 +2128,7 @@ public void call(Subscriber<? super T> s) {
     }
 
     /**
-     * Convers this Completable into a Single which when this Completable completes normally,
+     * Converts this Completable into a Single which when this Completable completes normally,
      * calls the given supplier and emits its returned value through onSuccess.
      * @param completionValueFunc0 the value supplier called when this Completable completes normally
      * @return the new Single instance
@@ -2175,7 +2175,7 @@ public void onSubscribe(Subscription d) {
     }
 
     /**
-     * Convers this Completable into a Single which when this Completable completes normally,
+     * Converts this Completable into a Single which when this Completable completes normally,
      * emits the given value through onSuccess.
      * @param completionValue the value to emit when this Completable completes normally
      * @return the new Single instance

src/main/java/rx/Observable.java

@@ -102,7 +102,7 @@ public static <T> Observable<T> create(OnSubscribe<T> f) {
      * 
      * <p><b>Note:</b> the {@code SyncOnSubscribe} provides a generic way to fulfill data by iterating 
      * over a (potentially stateful) function (e.g. reading data off of a channel, a parser, ). If your 
-     * data comes directly from an asyrchronous/potentially concurrent source then consider using the 
+     * data comes directly from an asynchronous/potentially concurrent source then consider using the
      * {@link Observable#create(AsyncOnSubscribe) asynchronous overload}.
      * 
      * <p>
@@ -3052,7 +3052,7 @@ public static <T, Resource> Observable<T> using(
      * Constructs an Observable that creates a dependent resource object which is disposed of just before 
      * termination if you have set {@code disposeEagerly} to {@code true} and unsubscription does not occur
      * before termination. Otherwise resource disposal will occur on unsubscription.  Eager disposal is
-     * particularly appropriate for a synchronous Observable that resuses resources. {@code disposeAction} will
+     * particularly appropriate for a synchronous Observable that reuses resources. {@code disposeAction} will
      * only be called once per subscription.
      * <p>
      * <img width="640" height="400" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/using.png" alt="">
@@ -3094,7 +3094,7 @@ public static <T, Resource> Observable<T> using(
      * item emitted by each of those Observables; and so forth.
      * <p>
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@code onNext} as many times as
-     * the number of {@code onNext} invokations of the source Observable that emits the fewest items.
+     * the number of {@code onNext} invocations of the source Observable that emits the fewest items.
      * <p>
      * <img width="640" height="380" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/zip.png" alt="">
      * <dl>
@@ -3128,7 +3128,7 @@ public static <R> Observable<R> zip(Iterable<? extends Observable<?>> ws, FuncN<
      * function applied to the second item emitted by each of those Observables; and so forth.
      * <p>
      * The resulting {@code Observable<R>} returned from {@code zip} will invoke {@code onNext} as many times as
-     * the number of {@code onNext} invokations of the source Observable that emits the fewest items.
+     * the number of {@code onNext} invocations of the source Observable that emits the fewest items.
      * <p>
      * <img width="640" height="370" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/zip.o.png" alt="">
      * <dl>
@@ -3900,7 +3900,7 @@ public final <B> Observable<List<T>> buffer(Observable<B> boundary, int initialC
      * subscribe/unsubscribe behavior of all the {@link Subscriber}s.
      * <p>
      * When you call {@code cache}, it does not yet subscribe to the source Observable and so does not yet
-     * begin cacheing items. This only happens when the first Subscriber calls the resulting Observable's
+     * begin caching items. This only happens when the first Subscriber calls the resulting Observable's
      * {@code subscribe} method.
      * <p>
      * <em>Note:</em> You sacrifice the ability to unsubscribe from the origin when you use the {@code cache}
@@ -3943,7 +3943,7 @@ public final Observable<T> cache(int initialCapacity) {
      * subscribe/unsubscribe behavior of all the {@link Subscriber}s.
      * <p>
      * When you call {@code cache}, it does not yet subscribe to the source Observable and so does not yet
-     * begin cacheing items. This only happens when the first Subscriber calls the resulting Observable's
+     * begin caching items. This only happens when the first Subscriber calls the resulting Observable's
      * {@code subscribe} method.
      * <p>
      * <em>Note:</em> You sacrifice the ability to unsubscribe from the origin when you use the {@code cache}
@@ -4367,7 +4367,7 @@ public final Observable<T> switchIfEmpty(Observable<? extends T> alternate) {
     }
 
     /**
-     * Returns an Observable that delays the subscription to and emissions from the souce Observable via another
+     * Returns an Observable that delays the subscription to and emissions from the source Observable via another
      * Observable on a per-item basis.
      * <p>
      * <img width="640" height="450" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/delay.oo.png" alt="">
@@ -5357,7 +5357,7 @@ public final <R> Observable<R> concatMapEager(Func1<? super T, ? extends Observa
 
     /**
      * Returns an Observable that emits the single item at a specified index in a sequence of emissions from a
-     * source Observbable.
+     * source Observable.
      * <p>
      * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/elementAt.png" alt="">
      * <dl>
@@ -5821,7 +5821,7 @@ public final <R> Observable<R> flatMapIterable(Func1<? super T, ? extends Iterab
      * @param <U>
      *            the collection element type
      * @param <R>
-     *            the type of item emited by the resulting Observable
+     *            the type of item emitted by the resulting Observable
      * @param collectionSelector
      *            a function that returns an Iterable sequence of values for each item emitted by the source
      *            Observable
@@ -5851,7 +5851,7 @@ public final <U, R> Observable<R> flatMapIterable(Func1<? super T, ? extends Ite
      * @param <U>
      *            the collection element type
      * @param <R>
-     *            the type of item emited by the resulting Observable
+     *            the type of item emitted by the resulting Observable
      * @param collectionSelector
      *            a function that returns an Iterable sequence of values for each item emitted by the source
      *            Observable
@@ -6813,7 +6813,7 @@ public final Observable<T> reduce(Func2<T, T, T> accumulator) {
      * <p>
      * <img width="640" height="325" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/reduceSeed.png" alt="">
      * <p>
-     * This technique, which is called "reduce" here, is sometimec called "aggregate," "fold," "accumulate,"
+     * This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate,"
      * "compress," or "inject" in other programming contexts. Groovy, for instance, has an {@code inject} method
      * that does a similar operation on lists.
      * <dl>
@@ -10355,7 +10355,7 @@ public final Observable<Observable<T>> window(long timespan, long timeshift, Tim
      *            new window
      * @param unit
      *            the unit of time that applies to the {@code timespan} argument
-     * @return an Observable that emits connected, non-overlapping windows represending items emitted by the
+     * @return an Observable that emits connected, non-overlapping windows representing items emitted by the
      *         source Observable during fixed, consecutive durations
      * @see <a href="http://reactivex.io/documentation/operators/window.html">ReactiveX operators documentation: Window</a>
      */
@@ -10581,9 +10581,9 @@ private static class Holder {
         }
 
         /**
-         * Returns a singleton instance of NeverObservble (cast to the generic type).
+         * Returns a singleton instance of NeverObservable (cast to the generic type).
          * 
-         * @return
+         * @return singleton instance of NeverObservable (cast to the generic type)
          */
         @SuppressWarnings("unchecked")
         static <T> NeverObservable<T> instance() {

src/main/java/rx/Producer.java

@@ -21,7 +21,7 @@
  * backpressure).
  * 
  * <p>The request amount only affects calls to {@link Subscriber#onNext(Object)}; onError and onCompleted may appear without
- * requrests.
+ * requests.
  * 
  * <p>However, backpressure is somewhat optional in RxJava 1.x and Subscribers may not
  * receive a Producer via their {@link Subscriber#setProducer(Producer)} method and will run

src/main/java/rx/Single.java

@@ -1719,7 +1719,7 @@ public final Subscription subscribe(Subscriber<? super T> subscriber) {
             subscriber = new SafeSubscriber<T>(subscriber);
         }
 
-        // The code below is exactly the same an unsafeSubscribe but not used because it would add a sigificent depth to alreay huge call stacks.
+        // The code below is exactly the same an unsafeSubscribe but not used because it would add a significant depth to already huge call stacks.
         try {
             // allow the hook to intercept and/or decorate
             hook.onSubscribeStart(this, onSubscribe).call(subscriber);
@@ -2186,7 +2186,7 @@ public final Single<T> timeout(long timeout, TimeUnit timeUnit, Single<? extends
      *            the Single to use as the fallback in case of a timeout
      * @param scheduler
      *            the {@link Scheduler} to run the timeout timers on
-     * @return the source Single modified so that it will switch to the fallback Singlein case of a timeout
+     * @return the source Single modified so that it will switch to the fallback Single in case of a timeout
      * @see <a href="http://reactivex.io/documentation/operators/timeout.html">ReactiveX operators documentation: Timeout</a>
      */
     public final Single<T> timeout(long timeout, TimeUnit timeUnit, Single<? extends T> other, Scheduler scheduler) {
@@ -2630,7 +2630,7 @@ public static <T, Resource> Single<T> using(
      * Constructs an Single that creates a dependent resource object which is disposed of just before 
      * termination if you have set {@code disposeEagerly} to {@code true} and unsubscription does not occur
      * before termination. Otherwise resource disposal will occur on unsubscription.  Eager disposal is
-     * particularly appropriate for a synchronous Single that resuses resources. {@code disposeAction} will
+     * particularly appropriate for a synchronous Single that reuses resources. {@code disposeAction} will
      * only be called once per subscription.
      * <p>
      * <img width="640" height="400" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/using.png" alt="">

src/main/java/rx/Subscriber.java

@@ -193,9 +193,9 @@ public void setProducer(Producer p) {
             toRequest = requested;
             producer = p;
             if (subscriber != null) {
-                // middle operator ... we pass thru unless a request has been made
+                // middle operator ... we pass through unless a request has been made
                 if (toRequest == NOT_SET) {
-                    // we pass-thru to the next producer as nothing has been requested
+                    // we pass through to the next producer as nothing has been requested
                     passToSubscriber = true;
                 }
             }

src/main/java/rx/internal/operators/BackpressureUtils.java

@@ -246,10 +246,10 @@ static <T> void postCompleteDrain(AtomicLong requested, Queue<T> queue, Subscrib
              * in which we know the queue won't change anymore (i.e., done is always true
              * when looking at the classical algorithm and there is no error).
              * 
-             * Note that we don't check for cancellation or emptyness upfront for two reasons:
+             * Note that we don't check for cancellation or emptiness upfront for two reasons:
              * 1) if e != r, the loop will do this and we quit appropriately
              * 2) if e == r, then either there was no outstanding requests or we emitted the requested amount
-             *    and the execution simply falls to the e == r check below which checks for emptyness anyway.
+             *    and the execution simply falls to the e == r check below which checks for emptiness anyway.
              */
 
             while (e != r) {

src/main/java/rx/internal/operators/OnSubscribeGroupJoin.java

@@ -28,7 +28,7 @@
 import rx.subscriptions.*;
 
 /**
- * Corrrelates two sequences when they overlap and groups the results.
+ * Correlates two sequences when they overlap and groups the results.
  * 
  * @see <a href="http://msdn.microsoft.com/en-us/library/hh244235.aspx">MSDN: Observable.GroupJoin</a>
  * @param <T1> the left value type

src/main/java/rx/internal/operators/OperatorBufferWithTime.java

@@ -90,7 +90,7 @@ public Subscriber<? super T> call(final Subscriber<? super List<T>> child) {
         bsub.scheduleChunk();
         return bsub;
     }
-    /** Subscriber when the buffer chunking time and lenght differ. */
+    /** Subscriber when the buffer chunking time and length differ. */
     final class InexactSubscriber extends Subscriber<T> {
         final Subscriber<? super List<T>> child;
         final Worker inner;

src/main/java/rx/internal/operators/OperatorMerge.java

@@ -614,7 +614,7 @@ void emitLoop() {
                     }
 
                     /*
-                     * We need to read done before innerSubscribers because innerSubcribers are added
+                     * We need to read done before innerSubscribers because innerSubscribers are added
                      * before done is set to true. If it were the other way around, we could read an empty
                      * innerSubscribers, get paused and then read a done flag but an async producer
                      * might have added more subscribers between the two.