IntelliJ suggested style changes.

AppliedDuality · AppliedDuality · commit 227e51455fbd · 2013-12-01T17:12:18.000-08:00
diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala
@@ -166,21 +166,21 @@ class RxScalaDemo extends JUnitSuite {
   @Test def testTwoSubscriptionsToOneInterval() {
     val o = Observable.interval(100 millis).take(8)
     o.subscribe(
-      i => println(s"${i}a (on thread #${Thread.currentThread().getId()})")
+      i => println(s"${i}a (on thread #${Thread.currentThread().getId})")
     )
     o.subscribe(
-      i => println(s"${i}b (on thread #${Thread.currentThread().getId()})")
+      i => println(s"${i}b (on thread #${Thread.currentThread().getId})")
     )
     waitFor(o)
   }
 
   @Test def schedulersExample() {
     val o = Observable.interval(100 millis).take(8)
     o.observeOn(NewThreadScheduler()).subscribe(
-      i => println(s"${i}a (on thread #${Thread.currentThread().getId()})")
+      i => println(s"${i}a (on thread #${Thread.currentThread().getId})")
     )
     o.observeOn(NewThreadScheduler()).subscribe(
-      i => println(s"${i}b (on thread #${Thread.currentThread().getId()})")
+      i => println(s"${i}b (on thread #${Thread.currentThread().getId})")
     )
     waitFor(o)
   }
@@ -356,13 +356,13 @@ class RxScalaDemo extends JUnitSuite {
   }
 
   def square(x: Int): Int = {
-    println(s"$x*$x is being calculated on thread ${Thread.currentThread().getId()}")
+    println(s"$x*$x is being calculated on thread ${Thread.currentThread().getId}")
     Thread.sleep(100) // calculating a square is heavy work :)
     x*x
   }
 
   def work(o1: Observable[Int]): Observable[String] = {
-    println(s"map() is being called on thread ${Thread.currentThread().getId()}")
+    println(s"map() is being called on thread ${Thread.currentThread().getId}")
     o1.map(i => s"The square of $i is ${square(i)}")
   }
 
diff --git a/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala b/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/TestSchedulerExample.scala
@@ -28,7 +28,7 @@ class TestSchedulerExample extends JUnitSuite {
 
     scheduler.advanceTimeTo(2 seconds)
 
-    val inOrdr = inOrder(observer);
+    val inOrdr = inOrder(observer)
     inOrdr.verify(observer, times(1)).onNext(0L)
     inOrdr.verify(observer, times(1)).onNext(1L)
     inOrdr.verify(observer, never).onNext(2L)
@@ -37,7 +37,7 @@ class TestSchedulerExample extends JUnitSuite {
 
     verify(observer, never).onNext(2L)
     
-    sub.unsubscribe();
+    sub.unsubscribe()
 
     scheduler.advanceTimeTo(4 seconds)
     
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Scheduler.scala
@@ -215,7 +215,7 @@ trait Scheduler {
 
 object Scheduler {
   private [scala] def apply(scheduler: rx.Scheduler): Scheduler = {
-    return new Scheduler() {
+    new Scheduler() {
        val asJavaScheduler = scheduler
     }
   }
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/subscriptions/BooleanSubscription.scala
@@ -32,7 +32,7 @@ object BooleanSubscription {
   def apply(u: => Unit): BooleanSubscription = {
     new BooleanSubscription(new rx.subscriptions.BooleanSubscription {
       override def unsubscribe(): Unit = {
-        if(!super.isUnsubscribed()) {
+        if(!super.isUnsubscribed) {
             u
             super.unsubscribe()
         }
diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala
@@ -189,25 +189,25 @@ class CompletenessTest extends JUnitSuite {
   }
   
   @Ignore // because spams output
-  @Test def printJavaInstanceMethods: Unit = {
+  @Test def printJavaInstanceMethods(): Unit = {
     printMethodSet("Instance methods of rx.Observable", 
                    typeOf[rx.Observable[_]])
   }
   
   @Ignore // because spams output
-  @Test def printScalaInstanceMethods: Unit = {
+  @Test def printScalaInstanceMethods(): Unit = {
     printMethodSet("Instance methods of rx.lang.scala.Observable", 
                    typeOf[rx.lang.scala.Observable[_]])
   }
   
   @Ignore // because spams output
-  @Test def printJavaStaticMethods: Unit = {
+  @Test def printJavaStaticMethods(): Unit = {
     printMethodSet("Static methods of rx.Observable", 
                    typeOf[rx.Observable[_]].typeSymbol.companionSymbol.typeSignature)
   }
   
   @Ignore // because spams output
-  @Test def printScalaCompanionMethods: Unit = {
+  @Test def printScalaCompanionMethods(): Unit = {
     printMethodSet("Companion methods of rx.lang.scala.Observable",
                    typeOf[rx.lang.scala.Observable.type])
   }
@@ -227,7 +227,7 @@ class CompletenessTest extends JUnitSuite {
   }
 
   @Ignore // because spams output
-  @Test def printDefaultMethodCorrespondence: Unit = {
+  @Test def printDefaultMethodCorrespondence(): Unit = {
     println("\nDefault Method Correspondence")
     println(  "-----------------------------\n")
     val c = SortedMap(defaultMethodCorrespondence.toSeq : _*)
@@ -238,7 +238,7 @@ class CompletenessTest extends JUnitSuite {
   }
   
   @Ignore // because spams output
-  @Test def printCorrectedMethodCorrespondence: Unit = {
+  @Test def printCorrectedMethodCorrespondence(): Unit = {
     println("\nCorrected Method Correspondence")
     println(  "-------------------------------\n")
     val c = SortedMap(correspondence.toSeq : _*)
@@ -262,7 +262,7 @@ class CompletenessTest extends JUnitSuite {
     println(s"$status: $bad out of ${bad+good} methods were not found in $tp")
   }
   
-  @Test def checkScalaMethodPresenceVerbose: Unit = {
+  @Test def checkScalaMethodPresenceVerbose(): Unit = {
     println("\nTesting that all mentioned Scala methods exist")
     println(  "----------------------------------------------\n")
     
@@ -289,14 +289,14 @@ class CompletenessTest extends JUnitSuite {
       (javaM, if (actualMethods.contains(scalaM) || scalaM.charAt(0) == '[') scalaM else "[**TODO: missing**]")
   }
    
-  @Test def checkJavaMethodPresence: Unit = {
+  @Test def checkJavaMethodPresence(): Unit = {
     println("\nTesting that all mentioned Java methods exist")
     println(  "---------------------------------------------\n")
     checkMethodPresence(correspondence.keys, typeOf[rx.Observable[_]])
   }
   
   @Ignore // because we prefer the verbose version
-  @Test def checkScalaMethodPresence: Unit = {
+  @Test def checkScalaMethodPresence(): Unit = {
     checkMethodPresence(correspondence.values, typeOf[rx.lang.scala.Observable[_]])
   }
   
@@ -347,8 +347,8 @@ Note:
     (for (((javaName, scalaCol), pairs) <- ps.groupBy(groupingKey(_)).toList.sortBy(_._1._1)) yield {
       "| " + formatJavaCol(javaName, pairs.map(_._1)) + " | " + formatScalaCol(scalaCol) + " |"
     }).foreach(println(_))
-    println(s"\nThis table was generated on ${Calendar.getInstance().getTime()}.")
-    println(s"**Do not edit**. Instead, edit `${getClass().getCanonicalName()}`.")
+    println(s"\nThis table was generated on ${Calendar.getInstance().getTime}.")
+    println(s"**Do not edit**. Instead, edit `${getClass.getCanonicalName}`.")
   }
   
 }
diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/ObservableTest.scala
@@ -37,14 +37,14 @@ class ObservableTests extends JUnitSuite {
   // If this changes (i.e. it suppresses errors and returns default) then Scala's firstOrElse
   // should be changed accordingly.
   @Test def testJavaFirstOrDefault() {
-    assertEquals(1, rx.Observable.from(1, 2).firstOrDefault(10).toBlockingObservable().single)
-    assertEquals(10, rx.Observable.empty().firstOrDefault(10).toBlockingObservable().single)
+    assertEquals(1, rx.Observable.from(1, 2).firstOrDefault(10).toBlockingObservable.single)
+    assertEquals(10, rx.Observable.empty().firstOrDefault(10).toBlockingObservable.single)
     val msg = "msg6251"
     var receivedMsg = "none"
     try {
-      rx.Observable.error(new Exception(msg)).firstOrDefault(10).toBlockingObservable().single
+      rx.Observable.error(new Exception(msg)).firstOrDefault(10).toBlockingObservable.single
     } catch {
-      case e: Exception => receivedMsg = e.getCause().getMessage()
+      case e: Exception => receivedMsg = e.getCause.getMessage
     }
     assertEquals(receivedMsg, msg)
   }
@@ -62,7 +62,7 @@ class ObservableTests extends JUnitSuite {
     try {
       Observable[Int](new Exception(msg)).firstOrElse(10).toBlockingObservable.single
     } catch {
-      case e: Exception => receivedMsg = e.getCause().getMessage()
+      case e: Exception => receivedMsg = e.getCause.getMessage
     }
     assertEquals(receivedMsg, msg)
   }
diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subjects/SubjectTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/subjects/SubjectTests.scala
@@ -3,8 +3,8 @@ import org.junit.Test
 import rx.lang.scala.subjects._
 import org.mockito.InOrder
 import rx.lang.scala._
-import org.mockito.Matchers._;
-import org.mockito.Mockito._;
+import org.mockito.Matchers._
+import org.mockito.Mockito._
 
 import org.junit.Assert._
 import org.junit.Test

Original file line number	Diff line number	Diff line change
`@@ -166,21 +166,21 @@ class RxScalaDemo extends JUnitSuite {`
`166`	`166`	`@Test def testTwoSubscriptionsToOneInterval() {`
`167`	`167`	`val o = Observable.interval(100 millis).take(8)`
`168`	`168`	`o.subscribe(`
`169`		`- i => println(s"${i}a (on thread #${Thread.currentThread().getId()})")`
	`169`	`+ i => println(s"${i}a (on thread #${Thread.currentThread().getId})")`
`170`	`170`	`)`
`171`	`171`	`o.subscribe(`
`172`		`- i => println(s"${i}b (on thread #${Thread.currentThread().getId()})")`
	`172`	`+ i => println(s"${i}b (on thread #${Thread.currentThread().getId})")`
`173`	`173`	`)`
`174`	`174`	`waitFor(o)`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`@Test def schedulersExample() {`
`178`	`178`	`val o = Observable.interval(100 millis).take(8)`
`179`	`179`	`o.observeOn(NewThreadScheduler()).subscribe(`
`180`		`- i => println(s"${i}a (on thread #${Thread.currentThread().getId()})")`
	`180`	`+ i => println(s"${i}a (on thread #${Thread.currentThread().getId})")`
`181`	`181`	`)`
`182`	`182`	`o.observeOn(NewThreadScheduler()).subscribe(`
`183`		`- i => println(s"${i}b (on thread #${Thread.currentThread().getId()})")`
	`183`	`+ i => println(s"${i}b (on thread #${Thread.currentThread().getId})")`
`184`	`184`	`)`
`185`	`185`	`waitFor(o)`
`186`	`186`	`}`
`@@ -356,13 +356,13 @@ class RxScalaDemo extends JUnitSuite {`
`356`	`356`	`}`
`357`	`357`
`358`	`358`	`def square(x: Int): Int = {`
`359`		`- println(s"$x*$x is being calculated on thread ${Thread.currentThread().getId()}")`
	`359`	`+ println(s"$x*$x is being calculated on thread ${Thread.currentThread().getId}")`
`360`	`360`	`Thread.sleep(100) // calculating a square is heavy work :)`
`361`	`361`	`x*x`
`362`	`362`	`}`
`363`	`363`
`364`	`364`	`def work(o1: Observable[Int]): Observable[String] = {`
`365`		`- println(s"map() is being called on thread ${Thread.currentThread().getId()}")`
	`365`	`+ println(s"map() is being called on thread ${Thread.currentThread().getId}")`
`366`	`366`	`o1.map(i => s"The square of $i is ${square(i)}")`
`367`	`367`	`}`
`368`	`368`
Original file line number	Diff line number	Diff line change
`@@ -215,7 +215,7 @@ trait Scheduler {`
`215`	`215`
`216`	`216`	`object Scheduler {`
`217`	`217`	`private [scala] def apply(scheduler: rx.Scheduler): Scheduler = {`
`218`		`- return new Scheduler() {`
	`218`	`+ new Scheduler() {`
`219`	`219`	`val asJavaScheduler = scheduler`
`220`	`220`	`}`
`221`	`221`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ object BooleanSubscription {`
`32`	`32`	`def apply(u: => Unit): BooleanSubscription = {`
`33`	`33`	`new BooleanSubscription(new rx.subscriptions.BooleanSubscription {`
`34`	`34`	`override def unsubscribe(): Unit = {`
`35`		`- if(!super.isUnsubscribed()) {`
	`35`	`+ if(!super.isUnsubscribed) {`
`36`	`36`	`u`
`37`	`37`	`super.unsubscribe()`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -189,25 +189,25 @@ class CompletenessTest extends JUnitSuite {`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`@Ignore // because spams output`
`192`		`- @Test def printJavaInstanceMethods: Unit = {`
	`192`	`+ @Test def printJavaInstanceMethods(): Unit = {`
`193`	`193`	`printMethodSet("Instance methods of rx.Observable",`
`194`	`194`	`typeOf[rx.Observable[_]])`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`@Ignore // because spams output`
`198`		`- @Test def printScalaInstanceMethods: Unit = {`
	`198`	`+ @Test def printScalaInstanceMethods(): Unit = {`
`199`	`199`	`printMethodSet("Instance methods of rx.lang.scala.Observable",`
`200`	`200`	`typeOf[rx.lang.scala.Observable[_]])`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`@Ignore // because spams output`
`204`		`- @Test def printJavaStaticMethods: Unit = {`
	`204`	`+ @Test def printJavaStaticMethods(): Unit = {`
`205`	`205`	`printMethodSet("Static methods of rx.Observable",`
`206`	`206`	`typeOf[rx.Observable[_]].typeSymbol.companionSymbol.typeSignature)`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`@Ignore // because spams output`
`210`		`- @Test def printScalaCompanionMethods: Unit = {`
	`210`	`+ @Test def printScalaCompanionMethods(): Unit = {`
`211`	`211`	`printMethodSet("Companion methods of rx.lang.scala.Observable",`
`212`	`212`	`typeOf[rx.lang.scala.Observable.type])`
`213`	`213`	`}`
`@@ -227,7 +227,7 @@ class CompletenessTest extends JUnitSuite {`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`@Ignore // because spams output`
`230`		`- @Test def printDefaultMethodCorrespondence: Unit = {`
	`230`	`+ @Test def printDefaultMethodCorrespondence(): Unit = {`
`231`	`231`	`println("\nDefault Method Correspondence")`
`232`	`232`	`println( "-----------------------------\n")`
`233`	`233`	`val c = SortedMap(defaultMethodCorrespondence.toSeq : _*)`
`@@ -238,7 +238,7 @@ class CompletenessTest extends JUnitSuite {`
`238`	`238`	`}`
`239`	`239`
`240`	`240`	`@Ignore // because spams output`
`241`		`- @Test def printCorrectedMethodCorrespondence: Unit = {`
	`241`	`+ @Test def printCorrectedMethodCorrespondence(): Unit = {`
`242`	`242`	`println("\nCorrected Method Correspondence")`
`243`	`243`	`println( "-------------------------------\n")`
`244`	`244`	`val c = SortedMap(correspondence.toSeq : _*)`
`@@ -262,7 +262,7 @@ class CompletenessTest extends JUnitSuite {`
`262`	`262`	`println(s"$status: $bad out of ${bad+good} methods were not found in $tp")`
`263`	`263`	`}`
`264`	`264`
`265`		`- @Test def checkScalaMethodPresenceVerbose: Unit = {`
	`265`	`+ @Test def checkScalaMethodPresenceVerbose(): Unit = {`
`266`	`266`	`println("\nTesting that all mentioned Scala methods exist")`
`267`	`267`	`println( "----------------------------------------------\n")`
`268`	`268`
`@@ -289,14 +289,14 @@ class CompletenessTest extends JUnitSuite {`
`289`	`289`	`(javaM, if (actualMethods.contains(scalaM) \|\| scalaM.charAt(0) == '[') scalaM else "[TODO: missing]")`
`290`	`290`	`}`
`291`	`291`
`292`		`- @Test def checkJavaMethodPresence: Unit = {`
	`292`	`+ @Test def checkJavaMethodPresence(): Unit = {`
`293`	`293`	`println("\nTesting that all mentioned Java methods exist")`
`294`	`294`	`println( "---------------------------------------------\n")`
`295`	`295`	`checkMethodPresence(correspondence.keys, typeOf[rx.Observable[_]])`
`296`	`296`	`}`
`297`	`297`
`298`	`298`	`@Ignore // because we prefer the verbose version`
`299`		`- @Test def checkScalaMethodPresence: Unit = {`
	`299`	`+ @Test def checkScalaMethodPresence(): Unit = {`
`300`	`300`	`checkMethodPresence(correspondence.values, typeOf[rx.lang.scala.Observable[_]])`
`301`	`301`	`}`
`302`	`302`
`@@ -347,8 +347,8 @@ Note:`
`347`	`347`	`(for (((javaName, scalaCol), pairs) <- ps.groupBy(groupingKey(_)).toList.sortBy(_._1._1)) yield {`
`348`	`348`	`"\| " + formatJavaCol(javaName, pairs.map(_._1)) + " \| " + formatScalaCol(scalaCol) + " \|"`
`349`	`349`	`}).foreach(println(_))`
`350`		`- println(s"\nThis table was generated on ${Calendar.getInstance().getTime()}.")`
`351`		- println(s"Do not edit. Instead, edit `${getClass().getCanonicalName()}`.")
	`350`	`+ println(s"\nThis table was generated on ${Calendar.getInstance().getTime}.")`
	`351`	+ println(s"Do not edit. Instead, edit `${getClass.getCanonicalName}`.")
`352`	`352`	`}`
`353`	`353`
`354`	`354`	`}`