Encapsulate some sealed traits in object, for easier qualified imports

Daenyth · Daenyth · commit df99d86f88fa · 2017-04-28T06:34:50.000-04:00
diff --git a/opentak/src/main/scala/com/github/daenyth/opentak/protocol/PlaytakCodec.scala b/opentak/src/main/scala/com/github/daenyth/opentak/protocol/PlaytakCodec.scala
@@ -1,6 +1,6 @@
 package com.github.daenyth.opentak.protocol
 
-import com.github.daenyth.taklib._
+import com.github.daenyth.taklib.{GameEndResult, Stone}
 
 object PlaytakCodec {
 
@@ -47,6 +47,7 @@ object PlaytakCodec {
           import s._
           s"Game Start $gameNumber $size $whitePlayerusername vs $blackPlayerusername $yourColor"
         case Place(gameNumber, playStone) =>
+          import Stone._
           val stoneType = playStone.stone match {
             case _: Capstone => "C"
             case _: StandingStone => "W"
@@ -61,6 +62,7 @@ object PlaytakCodec {
         case UpdateTime(gameNumber, whiteTime, blackTime) =>
           s"Game#$gameNumber Time $whiteTime $blackTime"
         case o: GameOver =>
+          import GameEndResult._
           val result = o.result match {
             case RoadWin(player) => player.fold("0-R", "R-0")
             case DoubleRoad => "R-R" // Not actually supported by playtak or default rules, but different result sets can treat it differently.
diff --git a/taklib/src/main/scala/com/github/daenyth/taklib/Board.scala b/taklib/src/main/scala/com/github/daenyth/taklib/Board.scala
@@ -2,6 +2,7 @@ package com.github.daenyth.taklib
 
 import com.github.daenyth.taklib.Board._
 import com.github.daenyth.taklib.Implicits.RichBoolean
+import com.github.daenyth.taklib.Stone._
 
 import scala.annotation.tailrec
 import scala.collection.immutable.IndexedSeq
@@ -239,6 +240,9 @@ sealed trait Stone {
   val owner: Player
   val isRoadStone: Boolean
 }
-case class Capstone(owner: Player) extends Stone { val isRoadStone = true }
-case class StandingStone(owner: Player) extends Stone { val isRoadStone = false }
-case class FlatStone(owner: Player) extends Stone { val isRoadStone = true }
+case object Stone {
+  case class Capstone(owner: Player) extends Stone { val isRoadStone = true }
+  case class StandingStone(owner: Player) extends Stone { val isRoadStone = false }
+  case class FlatStone(owner: Player) extends Stone { val isRoadStone = true }
+}
+
diff --git a/taklib/src/main/scala/com/github/daenyth/taklib/Game.scala b/taklib/src/main/scala/com/github/daenyth/taklib/Game.scala
@@ -1,5 +1,6 @@
 package com.github.daenyth.taklib
 
+import com.github.daenyth.taklib.GameEndResult._
 import com.github.daenyth.taklib.Implicits.RichBoolean
 import com.github.daenyth.taklib.RuleSet.GameRule
 
@@ -16,6 +17,7 @@ import scalaz.syntax.order._
 import scalaz.syntax.semigroup._
 import scalaz.{Equal, NonEmptyList, Semigroup, \/}
 
+sealed trait GameEndResult
 object GameEndResult {
   implicit val gerInstance: Semigroup[GameEndResult] with Equal[GameEndResult] =
     new Semigroup[GameEndResult] with Equal[GameEndResult] {
@@ -43,15 +45,15 @@ object GameEndResult {
         case _ => false
       }
     }
+
+  sealed trait RoadResult extends GameEndResult
+  sealed trait FlatResult extends GameEndResult
+  case class RoadWin(player: Player) extends RoadResult
+  case class FlatWin(player: Player) extends FlatResult
+  case class WinByResignation(player: Player) extends GameEndResult
+  case object DoubleRoad extends RoadResult
+  case object Draw extends FlatResult
 }
-sealed trait GameEndResult
-sealed trait RoadResult extends GameEndResult
-sealed trait FlatResult extends GameEndResult
-case class RoadWin(player: Player) extends RoadResult
-case class FlatWin(player: Player) extends FlatResult
-case class WinByResignation(player: Player) extends GameEndResult
-case object DoubleRoad extends RoadResult
-case object Draw extends FlatResult
 
 object RuleSet {
   type GameRule = (Game, TurnAction) => Option[InvalidMove]
@@ -63,10 +65,11 @@ trait RuleSet {
     @tailrec
     def go(rules: List[GameRule]): Option[InvalidMove] = rules match {
       case Nil => None
-      case rule :: rs => rule(game, action) match {
-        case s: Some[_] => s
-        case None => go(rs)
-      }
+      case rule :: rs =>
+        rule(game, action) match {
+          case s: Some[_] => s
+          case None => go(rs)
+        }
     }
     go(rules)
   }
@@ -204,15 +207,16 @@ class Game private (val size: Int,
 
   def takeTurn(action: TurnAction): MoveResult[Game] =
     rules.check(this, action).getOrElse {
-      currentBoard.applyAction(nextPlayer, action).flatMap { nextState =>
-        val newHistory = (action, nextState) <:: history
-        val game = new Game(size, turnNumber + 1, rules, newHistory)
-        game.winner match {
-          case Some(gameEnd) => GameOver(gameEnd, game)
-          case None => OkMove(game)
+        currentBoard.applyAction(nextPlayer, action).flatMap { nextState =>
+          val newHistory = (action, nextState) <:: history
+          val game = new Game(size, turnNumber + 1, rules, newHistory)
+          game.winner match {
+            case Some(gameEnd) => GameOver(gameEnd, game)
+            case None => OkMove(game)
+          }
         }
       }
-    }.noteInvalid(action)
+      .noteInvalid(action)
 
   def undo: MoveResult[Game] =
     history.tail.toNel.map { prev =>
@@ -242,11 +246,12 @@ class Game private (val size: Int,
       } yield UnDiEdge(idx, n)
       Graph.from(xs, edges)
     }
-    val roadStones: Vector[(BoardIndex, Player)] = currentBoard.stacksWithIndex.flatMap { case (idx, stack) =>
-      stack.top match {
-        case Some(stone) if stone.isRoadStone => Vector(idx -> stone.owner)
-        case _ => Vector.empty
-      }
+    val roadStones: Vector[(BoardIndex, Player)] = currentBoard.stacksWithIndex.flatMap {
+      case (idx, stack) =>
+        stack.top match {
+          case Some(stone) if stone.isRoadStone => Vector(idx -> stone.owner)
+          case _ => Vector.empty
+        }
     }
     val (whiteRoadStones, blackRoadStones) = roadStones.partition { _._2 == White }
     val whiteIndexes = whiteRoadStones.map(_._1)
@@ -276,6 +281,7 @@ class Game private (val size: Int,
   }
 
   private def flatWin: Option[FlatResult] = {
+    import Stone._
     val allStacks = currentBoard.boardPositions.flatten.toList
     @tailrec
     def go(stacks: List[Stack],
diff --git a/taklib/src/main/scala/com/github/daenyth/taklib/Move.scala b/taklib/src/main/scala/com/github/daenyth/taklib/Move.scala
@@ -35,13 +35,13 @@ sealed trait PlayStone extends TurnAction {
   def stone: Player => Stone
 }
 case class PlayFlat(at: BoardIndex) extends PlayStone {
-  val stone = FlatStone.apply _
+  val stone = Stone.FlatStone.apply _
 }
 case class PlayStanding(at: BoardIndex) extends PlayStone {
-  val stone = StandingStone.apply _
+  val stone = Stone.StandingStone.apply _
 }
 case class PlayCapstone(at: BoardIndex) extends PlayStone {
-  val stone = Capstone.apply _
+  val stone = Stone.Capstone.apply _
 }
 case class Move(from: BoardIndex,
                 direction: MoveDirection,
diff --git a/taklib/src/main/scala/com/github/daenyth/taklib/PtnParser.scala b/taklib/src/main/scala/com/github/daenyth/taklib/PtnParser.scala
@@ -1,12 +1,13 @@
 package com.github.daenyth.taklib
 
+import com.github.daenyth.taklib.GameEndResult._
 import com.github.daenyth.taklib.Implicits.RichParsing
 
 import scala.collection.immutable.VectorBuilder
 import scala.util.parsing.combinator.RegexParsers
-import scalaz.{-\/, \/, \/-}
 import scalaz.std.vector._
 import scalaz.syntax.foldable._
+import scalaz.{-\/, \/, \/-}
 
 object PtnParser extends RegexParsers with RichParsing {
 
diff --git a/taklib/src/main/scala/com/github/daenyth/taklib/TpsParser.scala b/taklib/src/main/scala/com/github/daenyth/taklib/TpsParser.scala
@@ -1,6 +1,7 @@
 package com.github.daenyth.taklib
 
 import com.github.daenyth.taklib.Implicits.RichParsing
+import com.github.daenyth.taklib.Stone._
 
 import scala.annotation.tailrec
 import scala.util.Try
diff --git a/taklib/src/test/scala/com/github/daenyth/taklib/GameTest.scala b/taklib/src/test/scala/com/github/daenyth/taklib/GameTest.scala
@@ -1,13 +1,14 @@
 package com.github.daenyth.taklib
 
+import com.github.daenyth.taklib.GameEndResult._
 import org.scalacheck.{Arbitrary, Gen}
 import org.scalatest.{FlatSpec, Matchers, OptionValues}
 import org.typelevel.scalatest.DisjunctionValues
 
 import scalaz.\/
 import scalaz.scalacheck.ScalazProperties
-import scalaz.syntax.traverse._
 import scalaz.std.vector._
+import scalaz.syntax.traverse._
 
 object GameTest {
   implicit val arbRoad: Arbitrary[RoadWin] = Arbitrary { Gen.oneOf(White, Black).map(RoadWin) }
diff --git a/taklib/src/test/scala/com/github/daenyth/taklib/MoveTest.scala b/taklib/src/test/scala/com/github/daenyth/taklib/MoveTest.scala
@@ -1,5 +1,6 @@
 package com.github.daenyth.taklib
 
+import com.github.daenyth.taklib.Stone._
 import org.scalatest.{FlatSpec, Matchers}
 
 class MoveTest extends FlatSpec with Matchers with MoveResultValues {
diff --git a/taklib/src/test/scala/com/github/daenyth/taklib/PtnParserTest.scala b/taklib/src/test/scala/com/github/daenyth/taklib/PtnParserTest.scala
@@ -1,5 +1,6 @@
 package com.github.daenyth.taklib
 
+import com.github.daenyth.taklib.GameEndResult._
 import com.github.daenyth.taklib.PtnParser.PtnHeaders
 import org.scalatest.{FlatSpec, Matchers}
 import org.typelevel.scalatest.DisjunctionValues

Original file line number	Diff line number	Diff line change
`@@ -35,13 +35,13 @@ sealed trait PlayStone extends TurnAction {`
`35`	`35`	`def stone: Player => Stone`
`36`	`36`	`}`
`37`	`37`	`case class PlayFlat(at: BoardIndex) extends PlayStone {`
`38`		`- val stone = FlatStone.apply _`
	`38`	`+ val stone = Stone.FlatStone.apply _`
`39`	`39`	`}`
`40`	`40`	`case class PlayStanding(at: BoardIndex) extends PlayStone {`
`41`		`- val stone = StandingStone.apply _`
	`41`	`+ val stone = Stone.StandingStone.apply _`
`42`	`42`	`}`
`43`	`43`	`case class PlayCapstone(at: BoardIndex) extends PlayStone {`
`44`		`- val stone = Capstone.apply _`
	`44`	`+ val stone = Stone.Capstone.apply _`
`45`	`45`	`}`
`46`	`46`	`case class Move(from: BoardIndex,`
`47`	`47`	`direction: MoveDirection,`