Merge branch 'type_driven' - the Haskell-inspired Java

implementation of RPS

Conflicts:
	.gitignore
	build.xml
	src/RockPaperScissors.java
	src/com/twoguys/rps/Game.java
	src/com/twoguys/rps/Player.java
	src/com/twoguys/rps/Throw.java
	test/com/twoguys/rps/GameTest.java
	test/com/twoguys/rps/ThrowTest.java

.gitignore

@@ -1,2 +1,2 @@
 build/*
-dist/*
+dist/*

build.xml

@@ -10,6 +10,9 @@
 
   <target name="init">
     <tstamp />
+    <mkdir dir="${src}" />
+    <mkdir dir="${test}" />
+    <mkdir dir="${lib}" />
     <mkdir dir="${classes}" />
     <mkdir dir="${test.classes}" />
     <mkdir dir="${test.report}" />
@@ -43,9 +46,10 @@
     <junit printsummary="on" haltonerror="true" haltonfailure="true">
       <classpath refid="class.path" />
       <batchtest todir="${test.report}">
-	<formatter type="plain" />
+	<formatter type="plain" usefile="false" />
 	<fileset dir="${test}">
 	  <include name="**/*Test.java"/>
+	  <exclude name="**/*AbstractTest.java"/>
 	</fileset>
       </batchtest>
     </junit>

data/RockPaperScissorsTest/bestof_game.expected

@@ -0,0 +1,13 @@
+Player 1 Name: 
+Player 2 Name: 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+Ben Wins!

data/RockPaperScissorsTest/bestof_game.input

@@ -0,0 +1,12 @@
+Nate
+Ben
+R
+P
+R
+S
+R
+P
+R
+S
+R
+P

data/RockPaperScissorsTest/firstto_game.expected

@@ -0,0 +1,9 @@
+Player 1 Name: 
+Player 2 Name: 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+Ben Wins!

data/RockPaperScissorsTest/firstto_game.input

@@ -0,0 +1,8 @@
+Nate
+Ben
+R
+P
+R
+P
+R
+P

data/RockPaperScissorsTest/nate_wins.expected

@@ -0,0 +1,5 @@
+Player 1 Name: 
+Player 2 Name: 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+Nate Wins!

data/RockPaperScissorsTest/nate_wins.input

@@ -0,0 +1,4 @@
+Nate
+Ben
+R
+S

data/RockPaperScissorsTest/noargs_game.expected

@@ -0,0 +1,5 @@
+Player 1 Name: 
+Player 2 Name: 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+Ben Wins!

data/RockPaperScissorsTest/noargs_game.input

@@ -0,0 +1,4 @@
+Nate
+Ben
+R
+P

data/RockPaperScissorsTest/winby_game.expected

@@ -0,0 +1,15 @@
+Player 1 Name: 
+Player 2 Name: 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+[R]ock, [P]aper, or [S]cissors? 
+Ben Wins!

data/RockPaperScissorsTest/winby_game.input

@@ -0,0 +1,15 @@
+Nate
+Ben
+R
+P
+R
+S
+R
+P
+R
+S
+R
+P
+R
+P
+

src/RockPaperScissors.java

@@ -1,18 +1,56 @@
-
 import com.twoguys.rps.*;
+import com.twoguys.util.*;
 import java.io.*;
+import java.util.*;
 
 public class RockPaperScissors {
 
-    public static void main(String[] args) throws Exception {
-	Reader in = new InputStreamReader(System.in);
+    private LineNumberReader in;
+    private Writer out;
+
+    public static void main(String[] args) {
+	InputStreamReader stdin = new InputStreamReader(System.in);
+	LineNumberReader in = new LineNumberReader(stdin);
 	Writer out = new OutputStreamWriter(System.out);
+
+	RockPaperScissors rps = new RockPaperScissors(in, out);
+	rps.run(args);
+    }
+
+    public RockPaperScissors(LineNumberReader in, Writer out) {
+	this.in = in;
+	this.out = out;
+    }
+
+    public void run(String[] args) {
+	try {
+	    Either<String, WinLogic> logicOrError = WinLogicFactory.create(args);
 
-	Player p1 = new InteractivePlayer(in, out, 1);
-	Player p2 = new InteractivePlayer(in, out, 2);
+	    if(logicOrError.left() != null) {
+		out.write(logicOrError.left());
+	    } else {
+		WinLogic logic = logicOrError.right();
 
-	Game game = new Game(p1, p2);
-	Player winner = game.play();
-	winner.notifyWinner();
+		PlayerPrompt prompt1 = new PlayerPrompt(in, out, 1);
+		PlayerPrompt prompt2 = new PlayerPrompt(in, out, 2);
+
+		Player player1 = prompt1.prompt();
+		Player player2 = prompt2.prompt();
+
+		AllThrows p1Throws = new AllThrows(new ThrowPrompt(in, out));
+		AllThrows p2Throws = new AllThrows(new ThrowPrompt(in, out));
+
+		Pair<Player, Iterator<Throw>> p1 = new Pair<Player, Iterator<Throw>>(player1, p1Throws);
+		Pair<Player, Iterator<Throw>> p2 = new Pair<Player, Iterator<Throw>>(player2, p2Throws);
+
+		Game game = new Game(logic, p1, p2);
+		Player winner = game.play();
+
+		out.write(winner.getName() + " Wins!");
+	    }
+	} catch(Exception e) {
+	    e.printStackTrace(new PrintWriter(out));
+	}
     }
+
 }

src/com/twoguys/rps/AllThrows.java

@@ -0,0 +1,43 @@
+package com.twoguys.rps;
+
+import com.twoguys.util.*;
+import java.text.*;
+import java.util.*;
+
+public class AllThrows implements Iterator<Throw> {
+
+    private Prompt<Throw> prompt;
+    private Throw next;
+
+    public AllThrows(Prompt<Throw> prompt) {
+	this.prompt = prompt;
+    }
+
+    @Override
+    public boolean hasNext() {
+	try {
+	    next = prompt.prompt();
+	} catch(ParseException e) {
+	    return false;
+	}
+	return true;
+    }
+
+    @Override
+    public Throw next() {
+	Throw result = next;
+	try {
+	    if(next == null) {
+		result = prompt.prompt();
+	    }
+	    next = null;
+	    return result;
+	} catch(Exception e) {
+	    throw new RuntimeException(e);
+	}
+    }
+
+    @Override
+    public void remove() {	
+    }
+}

src/com/twoguys/rps/BestOf.java

@@ -0,0 +1,26 @@
+package com.twoguys.rps;
+
+import com.twoguys.util.*;
+
+public class BestOf implements WinLogic {
+
+    private int of;
+    private WinLogic impl;
+
+    public BestOf(int of) {
+	if(of <= 1 || of % 2 == 0) {
+	    throw new IllegalArgumentException(of + " is not valid, must provide an odd number greater than 1");
+	}
+
+	this.of = of;
+	this.impl = new FirstTo(of / 2 + 1);	
+    }
+
+    public Maybe<Player> determineWinner(Pair<Player, Integer> p1, Pair<Player, Integer> p2) {
+	return impl.determineWinner(p1, p2);
+    }
+
+    public int getOf() {
+	return of;
+    }
+}

src/com/twoguys/rps/FirstTo.java

@@ -0,0 +1,10 @@
+package com.twoguys.rps;
+
+import com.twoguys.util.*;
+
+public class FirstTo extends WinBy {
+
+    public FirstTo(int to) {
+	super(to, 0);
+    }
+}

src/com/twoguys/rps/Game.java

@@ -1,20 +1,50 @@
 package com.twoguys.rps;
 
+import com.twoguys.util.*;
+import java.util.*;
+
 public class Game {
 
-    private Player p1;
-    private Player p2;
+    public static final Maybe<Player> NO_WINNER = new Nothing();
+
+    private WinLogic logic;
+    private Player player1;
+    private Player player2;
+    private int p1Score = 0;
+    private int p2Score = 0;
+    private Iterator<Throw> p1Throws;
+    private Iterator<Throw> p2Throws;
 
-    public Game(Player p1, Player p2) {
-	this.p1 = p1;
-	this.p2 = p2;
+    public Game(WinLogic logic, Pair<Player, Iterator<Throw>> player1, Pair<Player, Iterator<Throw>> player2) {
+	this.logic = logic;
+	this.player1 = player1.a;
+	this.player2 = player2.a;
+	this.p1Throws = player1.b;
+	this.p2Throws = player2.b;
     }
 
-    public Player play() {
-	Throw p1Throw = p1.getThrow();
-	Throw p2Throw = p2.getThrow();
+    private Maybe<Player> getWinner() {
+	Pair<Player, Integer> p1 = new Pair<Player, Integer>(player1, p1Score);
+	Pair<Player, Integer> p2 = new Pair<Player, Integer>(player2, p2Score);
 
-	return p1Throw.beats(p2Throw) ? p1 : p2;
+	return logic.determineWinner(p1, p2);
+    }
+
+    public Player play() {
+	Maybe<Player> player = getWinner();
+	while(player.equals(NO_WINNER)) {
+	    if(p1Throws.hasNext() && p2Throws.hasNext()) {
+		Throw t1 = p1Throws.next();
+		Throw t2 = p2Throws.next();
+		if(t1.beats(t2)) {
+		    p1Score++;
+		} else if(t2.beats(t1)) {
+		    p2Score++;
+		}
+	    }
+	    player = getWinner();
+	}
+	return player.value();
     }
 
 }

src/com/twoguys/rps/Player.java

@@ -1,9 +1,18 @@
 package com.twoguys.rps;
 
-public interface Player {
+public class Player {
 
-    public String getName();
-    public Throw getThrow();
-    public void notifyWinner();
+    private String name;
 
+    public Player(String name) {
+	this.name = name;
+    }
+
+    public String getName() {
+	return name;
+    }
+
+    public void setName(String name) {
+	this.name = name;
+    }
 }

src/com/twoguys/rps/PlayerPrompt.java

@@ -0,0 +1,12 @@
+package com.twoguys.rps;
+
+import com.twoguys.util.*;
+import java.io.*;
+
+public class PlayerPrompt extends Prompt<Player> {
+
+    public PlayerPrompt(LineNumberReader in, Writer out, int n) {
+	super(in, new Notify(out, "Player " + n + " Name: "), new com.twoguys.util.Reader<Player>(new ReadPlayer()));
+    }
+
+}

src/com/twoguys/rps/ReadPlayer.java

@@ -0,0 +1,13 @@
+package com.twoguys.rps;
+
+import com.twoguys.util.*;
+import java.util.*;
+
+public class ReadPlayer implements Read<Player> {
+
+    public List<Pair<Player, String>> read(String str) {
+	Player player = new Player(str);
+	Pair<Player, String> parsed = new Pair<Player, String>(player, "");
+	return Arrays.asList(parsed);
+    }
+}