Merge pull request ardalis#11 from ardalis/ardalis/memento

Add memento

Author: ardalis

DesignPatternsInCSharp.sln

@@ -12,7 +12,9 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GreeterService", "GreeterService\GreeterService.csproj", "{1F527722-FD31-4DC4-9FC9-8F259724107D}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DesignPatternsInCSharp.Benchmarks", "DesignPatternsInCSharp.Benchmarks\DesignPatternsInCSharp.Benchmarks.csproj", "{D6F7EB79-9204-4062-A3EB-EC001F60ECAB}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DesignPatternsInCSharp.Benchmarks", "DesignPatternsInCSharp.Benchmarks\DesignPatternsInCSharp.Benchmarks.csproj", "{D6F7EB79-9204-4062-A3EB-EC001F60ECAB}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HangmanGameApp", "HangmanGame\HangmanGameApp.csproj", "{A4CB28DD-1647-4FA3-A8CF-9ECE34A525F6}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -32,6 +34,10 @@ Global
 		{D6F7EB79-9204-4062-A3EB-EC001F60ECAB}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D6F7EB79-9204-4062-A3EB-EC001F60ECAB}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D6F7EB79-9204-4062-A3EB-EC001F60ECAB}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A4CB28DD-1647-4FA3-A8CF-9ECE34A525F6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A4CB28DD-1647-4FA3-A8CF-9ECE34A525F6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A4CB28DD-1647-4FA3-A8CF-9ECE34A525F6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A4CB28DD-1647-4FA3-A8CF-9ECE34A525F6}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

DesignPatternsInCSharp/Memento/DuplicateGuessException.cs

@@ -0,0 +1,8 @@
+using System;
+
+namespace DesignPatternsInCSharp.Memento
+{
+    public class DuplicateGuessException : Exception
+    {
+    }
+}

DesignPatternsInCSharp/Memento/GameResult.cs

@@ -0,0 +1,10 @@
+namespace DesignPatternsInCSharp.Memento
+{
+    // TODO: Consider refactoring to use https://github.com/ardalis/SmartEnum
+    public enum GameResult
+    {
+        InProgress,
+        Lost,
+        Won
+    }
+}

DesignPatternsInCSharp/Memento/HangmanGame.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace DesignPatternsInCSharp.Memento
+{
+    public class HangmanGame
+    {
+        private readonly string _secretWord;
+        private const char _maskChar = '_';
+        protected const int INITIAL_GUESSES = 5;
+
+        public HangmanGame(string secretWord = "secret")
+        {
+            _secretWord = secretWord.ToUpperInvariant();
+        }
+
+        public bool IsOver => this.Result > GameResult.InProgress;
+        public string CurrentMaskedWord => new string(_secretWord.Select(c => PreviousGuesses.Contains(c) ? c : _maskChar).ToArray());
+        public List<char> PreviousGuesses { get; } = new List<char>();
+        public int GuessesRemaining => INITIAL_GUESSES - PreviousGuesses.Count(c => !CurrentMaskedWord.Contains(c));
+        public GameResult Result { get; private set; }
+
+        public void Guess(char guessChar)
+        {
+            // TODO: Consider using Ardalis.GuardClauses
+            // TODO: Consider returning Ardalis.Result
+            if (char.IsWhiteSpace(guessChar)) throw new InvalidGuessException("Guess cannot be blank.");
+            if (!Regex.IsMatch(guessChar.ToString(), "^[A-Z]$")) throw new InvalidGuessException("Guess must be a capital letter A through Z");
+            if (IsOver) throw new InvalidGuessException("Can't make guesses after game is over.");
+
+            if (PreviousGuesses.Any(g => g == guessChar)) throw new DuplicateGuessException();
+
+            PreviousGuesses.Add(guessChar);
+
+            if (_secretWord.IndexOf(guessChar) >= 0)
+            {
+                if (!CurrentMaskedWord.Contains(_maskChar))
+                {
+                    Result = GameResult.Won;
+                }
+                return;
+            }
+
+            if(GuessesRemaining <= 0)
+            {
+                Result = GameResult.Lost;
+            }
+        }
+    }
+}

DesignPatternsInCSharp/Memento/HangmanGameWithUndo.cs

@@ -0,0 +1,19 @@
+namespace DesignPatternsInCSharp.Memento
+{
+    public class HangmanGameWithUndo : HangmanGame
+    {
+        public HangmanMemento CreateSetPoint()
+        {
+            var guesses = PreviousGuesses.ToArray();
+            return new HangmanMemento() { Guesses = guesses };
+        }
+
+        public void ResumeFrom(HangmanMemento memento)
+        {
+            var guesses = memento.Guesses;
+            PreviousGuesses.Clear();
+            PreviousGuesses.AddRange(guesses);
+        }
+    }
+
+}

DesignPatternsInCSharp/Memento/HangmanMemento.cs

@@ -0,0 +1,7 @@
+namespace DesignPatternsInCSharp.Memento
+{
+    public sealed class HangmanMemento
+    {
+        internal char[] Guesses { get; set; }
+    }
+}

DesignPatternsInCSharp/Memento/InvalidGuessException.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace DesignPatternsInCSharp.Memento
+{
+    public class InvalidGuessException : Exception
+    {
+        public InvalidGuessException(string message) : base(message)
+        {
+        }
+    }
+}

DesignPatternsInCSharp/Memento/Tests/HangmanGameConstructor.cs

@@ -0,0 +1,17 @@
+using Xunit;
+
+namespace DesignPatternsInCSharp.Memento.Tests
+{
+    public class HangmaneGamConstructor
+    {
+        private const string TEST_SECRET_WORD = "TEST";
+
+        private HangmanGame _game = new HangmanGame(TEST_SECRET_WORD);
+
+        [Fact]
+        public void HasMaskedWordOfAllUnderscores()
+        {
+            Assert.Equal("____", _game.CurrentMaskedWord);
+        }
+    }
+}

DesignPatternsInCSharp/Memento/Tests/HangmanGameGuess.cs

@@ -0,0 +1,98 @@
+using System;
+using Xunit;
+
+namespace DesignPatternsInCSharp.Memento.Tests
+{
+    public class HangmanGameGuess
+    {
+        private const string TEST_SECRET_WORD = "TEST";
+
+        private HangmanGame _game = new HangmanGame(TEST_SECRET_WORD);
+
+        [Theory]
+        [InlineData(' ')]
+        [InlineData('-')]
+        [InlineData('1')]
+        public void ThrowsGivenInvalidGuess(char invalidGuess)
+        {
+            Assert.Throws<InvalidGuessException>(() => _game.Guess(invalidGuess));
+        }
+
+        [Fact]
+        public void ThrowsGivenDuplicateGuess()
+        {
+            char wrongGuess = 'Z';
+            _game.Guess(wrongGuess);
+
+            Assert.Throws<DuplicateGuessException>(() => _game.Guess(wrongGuess));
+        }
+
+        [Fact]
+        public void ThrowsGivenValidGuessWhenGameIsOver()
+        {
+            _game.Guess('T');
+            _game.Guess('E');
+            _game.Guess('S'); // game over - WON
+
+            Assert.Throws<InvalidGuessException>(() => _game.Guess('A'));
+        }
+
+        [Fact]
+        public void DecrementsGuessesRemainingGivenInvalidGuess()
+        {
+            int initialGuesses = _game.GuessesRemaining;
+            char wrongGuess = 'Z';
+
+            _game.Guess(wrongGuess);
+
+            Assert.Equal(initialGuesses - 1, _game.GuessesRemaining);
+        }
+
+        [Theory]
+        [InlineData('E')]
+        public void DoesNotDecrementGuessesRemainingGivenValidGuess(char correctGuess)
+        {
+            int initialGuesses = _game.GuessesRemaining;
+
+            _game.Guess(correctGuess);
+
+            Assert.Equal(initialGuesses, _game.GuessesRemaining);
+        }
+
+        [Fact]
+        public void MaskedWordIncludesGuessLetterIfCorrect()
+        {
+            char correctGuess = 'E';
+
+            _game.Guess(correctGuess);
+
+            Assert.True(_game.CurrentMaskedWord.IndexOf(Convert.ToChar(correctGuess)) >= 0);
+        }
+
+        [Fact]
+        public void SetsGameIsOverTrueAndResultLostWhenGuessesLeftReaches0()
+        {               
+            _game.Guess('A');
+            _game.Guess('B');
+            _game.Guess('C');
+            _game.Guess('D');
+            _game.Guess('E'); // correct
+            _game.Guess('F');
+
+            Assert.True(_game.IsOver);
+            Assert.Equal(GameResult.Lost, _game.Result);
+        }
+
+        [Fact]
+        public void SetsGameIsOverTrueAndResultWonWhenEntireWordIsGuessed()
+        {
+            _game.Guess('T');
+            _game.Guess('E');
+            _game.Guess('S');
+
+            Assert.True(_game.IsOver);
+            Assert.Equal(GameResult.Won, _game.Result);
+        }
+
+    }
+}

HangmanGame/HangmanGameApp.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DesignPatternsInCSharp\DesignPatternsInCSharp.csproj" />
+  </ItemGroup>
+
+</Project>

HangmanGame/Program.cs

@@ -0,0 +1,100 @@
+#define SupportUndo
+
+using DesignPatternsInCSharp.Memento;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace HangmanGameApp
+{
+    /// <summary>
+    /// This program uses the Memento pattern
+    /// </summary>
+    class Program
+    {
+        static void Main(string[] args)
+        {
+
+#if SupportUndo
+            // MEMENTO NOTES:
+            // HangmanGameWithUndo == ORIGINATOR
+            // This Main Program   == CARETAKER
+            // HangmanMemento      == MEMENTO
+            var game = new HangmanGameWithUndo();
+            var gameHistory = new Stack<HangmanMemento>();
+            gameHistory.Push(game.CreateSetPoint());
+#else
+            var game = new HangmanGame();
+#endif
+
+            while (!game.IsOver)
+            {
+                Console.Clear();
+                Console.SetCursorPosition(0, 0);
+                Console.WriteLine("Welcome to Hangman");
+
+                Console.WriteLine(game.CurrentMaskedWord);
+                Console.WriteLine($"Previous Guesses: {String.Join(',', game.PreviousGuesses.ToArray())}");
+                Console.WriteLine($"Guesses Left: {game.GuessesRemaining}");
+
+#if SupportUndo
+                Console.WriteLine("Guess (a-z or '-' to undo last guess): ");
+#else
+                Console.WriteLine("Guess (a-z): ");
+#endif
+
+                var entry = char.ToUpperInvariant(Console.ReadKey().KeyChar);
+
+#if SupportUndo
+                if(entry == '-')
+                {
+                    if(gameHistory.Count > 1)
+                    {
+                        gameHistory.Pop();
+                        game.ResumeFrom(gameHistory.Peek());
+                        Console.WriteLine();
+                        continue;
+                    }
+                }
+#endif
+                try
+                {
+                    game.Guess(entry);
+#if SupportUndo
+                    gameHistory.Push(game.CreateSetPoint());
+#endif
+                    Console.WriteLine();
+                }
+                catch (DuplicateGuessException)
+                {
+                    OutputError("You already guessed that.");
+                    continue;
+                }
+                catch (InvalidGuessException)
+                {
+                    OutputError("Sorry, invalid guess.");
+                    continue;
+                }
+            }
+
+            if (game.Result == GameResult.Won)
+            {
+                Console.WriteLine("CONGRATS! YOU WON!");
+            }
+
+            if (game.Result == GameResult.Lost)
+            {
+                Console.WriteLine("SORRY, You lost this time. Try again!");
+            }
+        }
+
+        private static void OutputError(string message)
+        {
+            Console.WriteLine();
+            Console.ForegroundColor = ConsoleColor.Red;
+            Console.WriteLine(message);
+            Console.ResetColor();
+            Thread.Sleep(3000);
+        }
+    }
+}