define Listener classes as top level class and remove unused AnyRef instance

akka-docs/rst/scala/code/docs/event/LoggingDocSpec.scala

@@ -3,7 +3,7 @@
  */
 package docs.event
 
-import akka.actor.{ Actor, Props }
+import akka.actor.{ Actor, Props, DeadLetter }
 import akka.testkit.AkkaSpec
 
 object LoggingDocSpec {
@@ -112,6 +112,33 @@ object LoggingDocSpec {
   }
   //#my-source
 
+  object Listeners {
+    def println(s: Any) = ()
+
+    //#deadletters
+    import akka.actor.{ Actor, DeadLetter, Props }
+
+    class DeadLetterListener extends Actor {
+      def receive = {
+        case d: DeadLetter => println(d)
+      }
+    }
+    //#deadletters
+
+    //#superclass-subscription-eventstream
+    abstract class AllKindsOfMusic { def artist: String }
+    case class Jazz(artist: String) extends AllKindsOfMusic
+    case class Electronic(artist: String) extends AllKindsOfMusic
+
+    class Listener extends Actor {
+      def receive = {
+        case m: Jazz       => println(s"${self.path.name} is listening to: ${m.artist}")
+        case m: Electronic => println(s"${self.path.name} is listening to: ${m.artist}")
+      }
+    }
+    //#superclass-subscription-eventstream
+  }
+
 }
 
 class LoggingDocSpec extends AkkaSpec {
@@ -134,67 +161,44 @@ class LoggingDocSpec extends AkkaSpec {
   }
 
   "allow registration to dead letters" in {
-    new AnyRef {
+    import LoggingDocSpec.Listeners._
-      //#deadletters
+    //#deadletters
-      import akka.actor.{ Actor, DeadLetter, Props }
 
-      class Listener extends Actor {
+    val listener = system.actorOf(Props[DeadLetterListener])
-        def receive = {
+    system.eventStream.subscribe(listener, classOf[DeadLetter])
-          case d: DeadLetter => println(d)
+    //#deadletters
-        }
-      }
-
-      val listener = system.actorOf(Props[Listener])
-      system.eventStream.subscribe(listener, classOf[DeadLetter])
-      //#deadletters
-    }
   }
 
   "demonstrate superclass subscriptions on eventStream" in {
-    def println(s: String) = ()
+    import LoggingDocSpec.Listeners._
+    //#superclass-subscription-eventstream
 
-    new AnyRef {
+    val jazzListener = system.actorOf(Props[Listener])
-      //#superclass-subscription-eventstream
+    val musicListener = system.actorOf(Props[Listener])
-      abstract class AllKindsOfMusic { def artist: String }
+    system.eventStream.subscribe(jazzListener, classOf[Jazz])
-      case class Jazz(artist: String) extends AllKindsOfMusic
+    system.eventStream.subscribe(musicListener, classOf[AllKindsOfMusic])
-      case class Electronic(artist: String) extends AllKindsOfMusic
 
-      class Listener extends Actor {
+    // only musicListener gets this message, since it listens to *all* kinds of music:
-        def receive = {
+    system.eventStream.publish(Electronic("Parov Stelar"))
-          case m: Jazz       => println(s"${self.path.name} is listening to: ${m.artist}")
-          case m: Electronic => println(s"${self.path.name} is listening to: ${m.artist}")
-        }
-      }
 
-      val jazzListener = system.actorOf(Props[Listener])
+    // jazzListener and musicListener will be notified about Jazz:
-      val musicListener = system.actorOf(Props[Listener])
+    system.eventStream.publish(Jazz("Sonny Rollins"))
-      system.eventStream.subscribe(jazzListener, classOf[Jazz])
+    //#superclass-subscription-eventstream
-      system.eventStream.subscribe(musicListener, classOf[AllKindsOfMusic])
-
-      // only musicListener gets this message, since it listens to *all* kinds of music:
-      system.eventStream.publish(Electronic("Parov Stelar"))
-
-      // jazzListener and musicListener will be notified about Jazz:
-      system.eventStream.publish(Jazz("Sonny Rollins"))
-      //#superclass-subscription-eventstream
-    }
   }
 
   "allow registration to suppressed dead letters" in {
-    new AnyRef {
+    import akka.actor.Props
-      import akka.actor.Props
+    val listener = system.actorOf(Props[MyActor])
-      val listener = system.actorOf(Props[MyActor])
 
-      //#suppressed-deadletters
+    //#suppressed-deadletters
-      import akka.actor.SuppressedDeadLetter
+    import akka.actor.SuppressedDeadLetter
-      system.eventStream.subscribe(listener, classOf[SuppressedDeadLetter])
+    system.eventStream.subscribe(listener, classOf[SuppressedDeadLetter])
-      //#suppressed-deadletters
+    //#suppressed-deadletters
 
-      //#all-deadletters
+    //#all-deadletters
-      import akka.actor.AllDeadLetters
+    import akka.actor.AllDeadLetters
-      system.eventStream.subscribe(listener, classOf[AllDeadLetters])
+    system.eventStream.subscribe(listener, classOf[AllDeadLetters])
-      //#all-deadletters
+    //#all-deadletters
-    }
   }
 
   "demonstrate logging more arguments" in {