Refactor hangman to harness immutability, object orientation, old&plain cli

src/main/java/hangman/Main.java

@@ -14,85 +14,33 @@
  */
 package hangman;
 
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.io.PrintStream;
-import java.util.Iterator;
-import java.util.Random;
 import java.util.Scanner;
 
-public class Main {
-
-    private final InputStream input;
-    private final OutputStream output;
-    private final int max;
-    private static final String[] WORDS = {
-        "simplicity", "equality", "grandmother",
-        "neighborhood", "relationship", "mathematics",
-        "university", "explanation"
-    };
-
-    public Main(final InputStream in, final OutputStream out, final int m) {
-        this.input = in;
-        this.output = out;
-        this.max = m;
-    }
-
-    public static void main(final String... args) {
-        new Main(System.in, System.out, 5).exec();
-    }
-
-    public void exec() {
-        String word = WORDS[new Random().nextInt(WORDS.length)];
-        boolean[] visible = new boolean[word.length()];
-        int mistakes = 0;
-        try (final PrintStream out = new PrintStream(this.output)) {
-            final Iterator<String> scanner = new Scanner(this.input);
-            boolean done = true;
-            while (mistakes < this.max) {
-                done = true;
-                for (int i = 0; i < word.length(); ++i) {
-                    if (!visible[i]) {
-                        done = false;
-                    }
-                }
-                if (done) {
-                    break;
-                }
-                out.print("Guess a letter: ");
-                char chr = scanner.next().charAt(0);
-                boolean hit = false;
-                for (int i = 0; i < word.length(); ++i) {
-                    if (word.charAt(i) == chr && !visible[i]) {
-                        visible[i] = true;
-                        hit = true;
-                    }
-                }
-                if (hit) {
-                    out.print("Hit!\n");
-                } else {
-                    out.printf(
-                        "Missed, mistake #%d out of %d\n",
-                        mistakes + 1, this.max
-                    );
-                    ++mistakes;
-                }
-                out.append("The word: ");
-                for (int i = 0; i < word.length(); ++i) {
-                    if (visible[i]) {
-                        out.print(word.charAt(i));
-                    } else {
-                        out.print("?");
-                    }
-                }
-                out.append("\n\n");
-            }
-            if (done) {
-                out.print("You won!\n");
-            } else {
-                out.print("You lost.\n");
-            }
-        }
-    }
+import hangman.core.Hangman;
+import hangman.core.Round;
+import hangman.secret.HardcodedVocabulary;
 
+public final class Main {
+	public final static void main(String[] args) {
+		final Scanner scan = new Scanner(System.in);
+		final Hangman hangman = new Hangman(new HardcodedVocabulary());
+		Round currentRound, lastRound = null;
+		do {
+			System.out.print("Guess a letter: ");
+			final char c = scan.next().charAt(0);
+			currentRound = lastRound==null?hangman.disclose(c):hangman.discloseAlso(lastRound,c);
+			if (currentRound.missed) {
+				System.out.printf("Missed, mistake #%d out of %d\n", currentRound.mistakes, hangman.allowedMistakes);
+			} else {
+				System.out.println("Hit!");
+			}
+			System.out.println("The word: " + currentRound.currentGuess);
+			lastRound = currentRound;
+		} while(hangman.gameStage(lastRound) == Hangman.Stage.PLAYING);
+		if (hangman.gameStage(lastRound) == Hangman.Stage.YOUWON) {
+			System.out.printf("You won in %d rounds!\n", lastRound.round);
+		} else {
+			System.out.printf("You lost in %d rounds.\n", lastRound.round);
+		}
+	}
 }

src/main/java/hangman/core/Guess.java

@@ -0,0 +1,28 @@
+package hangman.core;
+
+public final class Guess {
+	public static final char unknownChar = '\0';
+	public final String knownText;
+
+	public Guess( String knownText ) {
+		this.knownText = knownText;
+	}
+
+	public final boolean missed() {
+		return this.knownText.replace(""+unknownChar,"").length()==0;
+	}
+
+	public final Guess combine( Guess otherGuess ) {
+		String combinedSolution = "";
+		for( int i=0 ; i < knownText.length() ; i++ ) {
+			final char c = (char) (knownText.charAt(i)|otherGuess.knownText.charAt(i));
+			combinedSolution += c;
+		}
+		return new Guess(combinedSolution);
+	}
+
+	public final String toString() {
+		// Replace non-printable NULL characters with CLI friendly alternative
+		return knownText.replace(unknownChar, '_');
+	}
+}

src/main/java/hangman/core/Hangman.java

@@ -0,0 +1,35 @@
+package hangman.core;
+
+import hangman.secret.SecretProvider;
+
+public final class Hangman {
+	public static enum Stage {
+		PLAYING, YOUWON, YOULOSE
+	}
+
+	private final SecretPhrase secretPhrase;
+	public final int allowedMistakes;
+
+	public Hangman(SecretProvider secretProvider) {
+		this.secretPhrase = secretProvider.provideSecret();
+		this.allowedMistakes = secretPhrase.allowedMistakes;
+	}
+
+	public final Round disclose(char c) {
+		return new Round(secretPhrase.discover(c));
+	}
+
+	public final Round discloseAlso(Round prevRound, char c) {
+		return prevRound.nextRound(secretPhrase.discover(c));
+	}
+
+	public final Stage gameStage(Round round) {
+		if (round.mistakes >= secretPhrase.allowedMistakes) {
+			return Stage.YOULOSE;
+		} else if (secretPhrase.resolve(round.currentGuess)) {
+			return Stage.YOUWON;
+		} else {
+			return Stage.PLAYING;
+		}
+	}
+}

src/main/java/hangman/core/Round.java

@@ -0,0 +1,34 @@
+package hangman.core;
+
+public final class Round {
+	public final int round;
+	public final int mistakes;
+	public final boolean missed;
+	public final Guess currentGuess;
+
+	public Round( Guess initialGuess ) {
+		this.round = 1;
+		this.currentGuess = initialGuess;
+		if(initialGuess.missed()) {
+			this.mistakes = 1;
+			this.missed = true;
+		} else {
+			this.mistakes = 0;
+			this.missed = false;
+		}
+	}
+
+	private Round( Guess guess, int newRound, int mistakes, boolean missed ) {
+		this.missed = missed;
+		this.round = newRound;
+		this.mistakes = mistakes;
+		this.currentGuess = guess;
+	}
+
+	public final Round nextRound( Guess newGuess ) {
+		if(newGuess.missed())
+			return new Round(currentGuess.combine(newGuess), round+1, mistakes+1, true);
+		else
+			return new Round(currentGuess.combine(newGuess), round+1, mistakes, false);
+	}
+}

src/main/java/hangman/core/SecretPhrase.java

@@ -0,0 +1,21 @@
+package hangman.core;
+
+public final class SecretPhrase {
+	public final int allowedMistakes;
+	private final String phrase;
+
+	// It seems reasonable for that the SecretPhrase
+	// determines the difficulty and number of allowed mistakes
+	public SecretPhrase(String phrase, int allowedMistakes) {
+		this.phrase = phrase;
+		this.allowedMistakes = allowedMistakes;
+	}
+
+	public final Guess discover(char character) {
+		return new Guess(phrase.replaceAll("[^" + character + "]", ""+Guess.unknownChar));
+	}
+
+	public final boolean resolve(Guess solution) {
+		return phrase.equals(solution.knownText);
+	}
+}

src/main/java/hangman/secret/HardcodedVocabulary.java

@@ -0,0 +1,17 @@
+package hangman.secret;
+
+import java.util.Random;
+
+import hangman.core.SecretPhrase;
+
+public final class HardcodedVocabulary implements SecretProvider {
+	private static final String[] WORDS = {
+			"simplicity", "equality", "grandmother",
+			"neighborhood", "relationship",
+			"mathematics", "university", "explanation" };
+
+	@Override
+	public final SecretPhrase provideSecret() {
+		return new SecretPhrase(WORDS[new Random().nextInt(WORDS.length)], 5);
+	}
+}

src/main/java/hangman/secret/SecretProvider.java

@@ -0,0 +1,7 @@
+package hangman.secret;
+
+import hangman.core.SecretPhrase;
+
+public interface SecretProvider {
+	public SecretPhrase provideSecret();
+}

src/main/java/hangman/secret/StubVocabulary.java

@@ -0,0 +1,18 @@
+package hangman.secret;
+
+import hangman.core.SecretPhrase;
+
+public final class StubVocabulary implements SecretProvider {
+	private final String secretPhrase;
+	private final int allowedMistakes;
+
+	public StubVocabulary(String secretPhrase, int allowedMistakes) {
+		this.secretPhrase = secretPhrase;
+		this.allowedMistakes = allowedMistakes;
+	}
+
+	@Override
+	public final SecretPhrase provideSecret() {
+		return new SecretPhrase(secretPhrase, allowedMistakes);
+	}
+}

src/test/java/hangman/GuessRoundTest.java

@@ -0,0 +1,31 @@
+package hangman;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import hangman.core.Round;
+import hangman.core.SecretPhrase;
+
+public final class GuessRoundTest {
+	@Test
+	public final void guessRoundProgression() {
+		final SecretPhrase secret = new SecretPhrase( "elegant objects", 8);
+
+		final Round gr1 = new Round(secret.discover('a'));
+		Assert.assertEquals(1,gr1.round);
+		Assert.assertEquals(false,gr1.missed);
+		Assert.assertEquals(0,gr1.mistakes);
+		Assert.assertEquals("\0\0\0\0a\0\0\0\0\0\0\0\0\0\0", gr1.currentGuess.knownText);
+
+		final Round gr2 = gr1.nextRound(secret.discover('o'));
+		Assert.assertEquals(2,gr2.round);
+		Assert.assertEquals(0,gr2.mistakes);
+		Assert.assertEquals(false,gr2.missed);
+		Assert.assertEquals("\0\0\0\0a\0\0\0o\0\0\0\0\0\0", gr2.currentGuess.knownText);
+
+		final Round gr3 = gr2.nextRound(secret.discover('v'));
+		Assert.assertEquals(3,gr3.round);
+		Assert.assertEquals(1,gr3.mistakes);
+		Assert.assertEquals(true,gr3.missed);
+	}
+}

src/test/java/hangman/HagmanTest.java

@@ -0,0 +1,24 @@
+package hangman;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import hangman.core.Hangman;
+import hangman.core.Round;
+import hangman.secret.StubVocabulary;
+
+public class HagmanTest {
+	@Test
+	public void hangmanRounds() {
+		final Hangman hangman = new Hangman(new StubVocabulary("hangman",2));
+		final Round gr1 = hangman.disclose('e');
+		final Round gr2 = hangman.discloseAlso(gr1,'h');
+		final Round gr3 = hangman.discloseAlso(gr2,'n');
+		final Round gr4 = hangman.discloseAlso(gr3,'a');
+		Assert.assertEquals(4,gr4.round);
+		Assert.assertEquals("han\0\0an",gr4.currentGuess.knownText);
+		Assert.assertEquals(Hangman.Stage.PLAYING, hangman.gameStage(gr4));
+		final Round gr5 = hangman.discloseAlso(gr4,'w');
+		Assert.assertEquals(Hangman.Stage.YOULOSE, hangman.gameStage(gr5));
+	}
+}

src/test/java/hangman/SecretWordTest.java

@@ -0,0 +1,16 @@
+package hangman;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import hangman.core.Guess;
+import hangman.core.SecretPhrase;
+
+public class SecretWordTest {
+	@Test
+	public void discoverLetters() {
+		final SecretPhrase secret = new SecretPhrase( "elegant objects", 8 );
+		final Guess partialSolution = secret.discover('e');
+		Assert.assertEquals("e\0e\0\0\0\0\0\0\0\0e\0\0\0", partialSolution.knownText);
+	}
+}