7L7W Scala - Day 1

Board.scala

import org.specs.runner.JUnit4
import org.specs.runner._
import org.specs._
import org.junit.runner.RunWith
import org.specs.runner.JUnitSuiteRunner
import scala.collection.mutable.HashSet
  
@RunWith(classOf[JUnitSuiteRunner])
class BoardSpecTest extends Specification with JUnit {
  
  "A board with a line with three X" should {
    val board = new Board(new Line("X", "X", "X"),
                          new Line("O", "O", " "),
                          new Line("O", " ", " "))
    "be valid" in {
    	board.isValid mustEqual true;
    }

    "have X as winner" in {
    	board.isXWinner mustEqual true;
    }

    "have not O as winner" in {
    	board.isOWinner mustEqual false;
    }

    "don't have no winner" in {
    	board.isNoWinner mustEqual false;
    }
  }

  "A board with a column with three X" should {
    val board = new Board(new Line(" ", " ", "X"),
                          new Line("O", "O", "X"),
                          new Line("O", " ", "X"))
    "be valid" in {
    	board.isValid mustEqual true;
    }

    "have X as winner" in {
    	board.isXWinner mustEqual true;
    }

    "have not O as winner" in {
    	board.isOWinner mustEqual false;
    }

    "don't have no winner" in {
    	board.isNoWinner mustEqual false;
    }
  }

  "A board with a diagonal with three X" should {
    val board = new Board(new Line("X", " ", " "),
                          new Line("O", "X", "O"),
                          new Line("O", " ", "X"))
    "be valid" in {
    	board.isValid mustEqual true;
    }

    "have X as winner" in {
    	board.isXWinner mustEqual true;
    }

    "have not O as winner" in {
    	board.isOWinner mustEqual false;
    }

    "don't have no winner" in {
    	board.isNoWinner mustEqual false;
    }
  }

  "A board with a line with three O" should {
    val board = new Board(new Line("X", "X", " "),
                          new Line("O", "O", "O"),
                          new Line("X", " ", " "))
    "be valid" in {
    	board.isValid mustEqual true;
    }

    "have O as winner" in {
    	board.isOWinner mustEqual true;
    }

    "have not X as winner" in {
    	board.isXWinner mustEqual false;
    }

    "don't have no winner" in {
    	board.isNoWinner mustEqual false;
    }
  }

  "A board without a line with three O or three X" should {
    val board = new Board(new Line("X", "X", " "),
                          new Line("O", "O", " "),
                          new Line("X", " ", "O"))
    "be valid" in {
    	board.isValid mustEqual true;
    }

    "have not O as winner" in {
    	board.isOWinner mustEqual false;
    }

    "have not X as winner" in {
    	board.isXWinner mustEqual false;
    }

    "don't have no winner" in {
    	board.isNoWinner mustEqual true;
    }
  }
}

object BoardSpecMain {
  def main(args: Array[String]) {
    new BoardSpecTest().main(args)
  }
}
  
class Board(val rows : (Line, Line, Line)) {
  val columns = List(new Line(rows._1.values._1, rows._2.values._1, rows._3.values._1), 
		  		     new Line(rows._1.values._2, rows._2.values._2, rows._3.values._2),
		  		     new Line(rows._1.values._3, rows._2.values._3, rows._3.values._3))
  val diagonals = List(new Line(rows._1.values._1, rows._2.values._2, rows._3.values._3), 
		  		       new Line(rows._1.values._3, rows._2.values._2, rows._3.values._1))
  val lines =  rows._1 :: rows._2 :: rows._3 :: (columns ++ diagonals)
  
  def isValid() = (true /: columns) {_&&_.isValid}
  def isXWinner() = (false /: lines) {_||_.isXWinner}
  def isOWinner() = (false /: lines) {_||_.isOWinner}
  def isNoWinner() = (true /: lines) {_&&_.isNoWinner}
}

find.scala

// The Scala API
// http://www.scala-lang.org/api/current/index.html#package

// A comparison of Java and Scala
// http://blogs.oracle.com/sundararajan/entry/scala_for_java_programmers

// A discussion of val versus var
// http://stackoverflow.com/questions/1791408/what-is-the-difference-between-a-var-and-val-definition-in-scala

Line.scala

import org.specs.runner.JUnit4
import org.specs.runner._
import org.specs._
import org.junit.runner.RunWith
import org.specs.runner.JUnitSuiteRunner
import scala.collection.mutable.HashSet
  
@RunWith(classOf[JUnitSuiteRunner])
class LineSpecTest extends Specification with JUnit {
  
  "A line with three X" should {
	val line = new Line(("X", "X", "X"))
    "have valid elements" in {
      line.isValid mustEqual true;
    }
    "have X as winner" in {
     line.isXWinner mustEqual true;
    }
    "don't have O as winner" in {
     line.isOWinner mustEqual false;
    }
    "don't have no winner" in {
     line.isNoWinner mustEqual false;
    }
  }

  "A line with three O" should {
	val line = new Line(("O", "O", "O"))
    "have valid elements" in {
      line.isValid mustEqual true;
    }
    "have O as winner" in {
     line.isOWinner mustEqual true;
    }
    "don't have X as winner" in {
     line.isXWinner mustEqual false;
    }
    "don't have no winner" in {
     line.isNoWinner mustEqual false;
    }
  }

  "A line with three valid values" should {
	val line = new Line(("X", "O", " "))
    "have valid elements" in {
      line.isValid mustEqual true;
    }
    "don't have O as winner" in {
     line.isOWinner mustEqual false;
    }
    "don't have X as winner" in {
     line.isXWinner mustEqual false;
    }
    "have no winner" in {
     line.isNoWinner mustEqual true;
    }
  }

  "A line with a non valid values" should {
    "have invalid elements" in {
      val line = new Line(("F", "O", " "))
      line.isValid mustEqual false;
    }
  }
}

object LineSpecMain {
  def main(args: Array[String]) {
    new LineSpecTest().main(args)
  }
}
  
//class Line(val _1 : String, val _2 : String, val _3 : String) extends (String, String, String) {
class Line(val values : (String, String, String)) {
  val validValues = List("X", "O", " ")
  def isValid() = (true /: values.productIterator) {_&&validValues.contains(_)}
  
  def isXWinner = values.productIterator.count(_=="X")==3
  def isOWinner = values.productIterator.count(_=="O")==3
  def isNoWinner = !isXWinner && !isOWinner
}