From b212142002a294ba12e6a02bb5ebb15d7b54b57f Mon Sep 17 00:00:00 2001
From: Adam Getchell <acgetchell@ucdavis.edu>
Date: Thu, 2 Oct 2014 02:36:06 -0700
Subject: [PATCH 1/5] Fixed CMakelist to work with GMock

---
 CMakeLists.txt  | 17 ++++++++---------
 SoundexTest.cpp | 30 +++++++++++++++++++++++++++---
 2 files changed, 35 insertions(+), 12 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4cc738d..3185b10 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,15 +2,14 @@ project(chapterFirstExample)
 cmake_minimum_required(VERSION 2.6)
 
 include_directories($ENV{GMOCK_HOME}/include $ENV{GMOCK_HOME}/gtest/include)
-link_directories($ENV{GMOCK_HOME}/mybuild $ENV{GMOCK_HOME}/gtest/mybuild)
-add_definitions(-std=c++0x)
+link_directories($ENV{GMOCK_HOME}/lib/.libs $ENV{GMOCK_HOME}/gtest/lib/.libs)
+#add_definitions(-std=c++0x)
 set(CMAKE_CXX_FLAGS "${CMAXE_CXX_FLAGS} -Wall")
 
-set(sources 
-   main.cpp 
+set(sources
+   main.cpp
    SoundexTest.cpp)
-add_executable(test ${sources})
-target_link_libraries(test pthread)
-target_link_libraries(test gmock)
-target_link_libraries(test gtest)
-
+add_executable(unittests ${sources})
+target_link_libraries(unittests pthread)
+target_link_libraries(unittests gmock)
+target_link_libraries(unittests gtest)
diff --git a/SoundexTest.cpp b/SoundexTest.cpp
index f44975c..5acaa7d 100644
--- a/SoundexTest.cpp
+++ b/SoundexTest.cpp
@@ -1,6 +1,30 @@
-#include "gmock/gmock.h"    //<label id="code.include"/>
+#include <string>
 
-TEST(SoundexEncoding, RetainsSoleLetterOfOneLetterWord) { //<label id="code.test"/>
-   Soundex soundex;   //<label id="code.construct"/>
+class Soundex {
+public:
+  std::string encode(const std::string& word) const {
+    return zeroPad(word);
+  }
+
+private:
+  std::string zeroPad(const std::string& word) const {
+    return word + "000";
+  }
+};
+
+#include "gmock/gmock.h"
+using ::testing::Eq;
+
+TEST(SoundexEncoding, RetainsSoleLetterOfOneLetterWord) {
+   Soundex soundex;
+   auto encoded = soundex.encode("A");
+   ASSERT_THAT(encoded, Eq("A000"));
 }
 
+TEST(SoundexEncoding, PadsWithZerosToEnsureThreeDigits) {
+  Soundex soundex;
+
+  auto encoded = soundex.encode("I");
+
+  ASSERT_THAT(encoded, Eq("I000"));
+}

From 3e2d9a2268686e3f3e2b686d59d5692dad29c5f3 Mon Sep 17 00:00:00 2001
From: Adam Getchell <acgetchell@ucdavis.edu>
Date: Thu, 2 Oct 2014 14:55:30 -0700
Subject: [PATCH 2/5] Separate header files

---
 ExpectToFailCompile |  1 -
 Soundex.h           | 33 +++++++++++++++++++++++++++++++++
 SoundexTest.cpp     | 31 +++++++++++++------------------
 3 files changed, 46 insertions(+), 19 deletions(-)
 delete mode 100644 ExpectToFailCompile
 create mode 100644 Soundex.h

diff --git a/ExpectToFailCompile b/ExpectToFailCompile
deleted file mode 100644
index 80d4c17..0000000
--- a/ExpectToFailCompile
+++ /dev/null
@@ -1 +0,0 @@
-this branch is expected to fail compilation
diff --git a/Soundex.h b/Soundex.h
new file mode 100644
index 0000000..d82df22
--- /dev/null
+++ b/Soundex.h
@@ -0,0 +1,33 @@
+#ifndef Soundex_h
+#define Soundex_h
+#include <string>
+
+class Soundex {
+public:
+  static const size_t MaxCodeLength = 4;
+
+  std::string encode(const std::string& word) const {
+    return zeroPad(head(word) + encodedDigits(word));
+  }
+
+private:
+  std::string head(const std::string& word) const {
+    return word.substr(0, 1);
+  }
+
+  std::string encodedDigits(const std::string& word) const {
+    if (word.length() > 1) return encodedDigit();
+    return "";
+  }
+
+  std::string encodedDigit() const {
+    return "1";
+  }
+
+  std::string zeroPad(const std::string& word) const {
+    auto zerosNeeded = MaxCodeLength - word.length();
+    return word + std::string(zerosNeeded, '0');
+  }
+};
+
+#endif
diff --git a/SoundexTest.cpp b/SoundexTest.cpp
index 5acaa7d..08c0d88 100644
--- a/SoundexTest.cpp
+++ b/SoundexTest.cpp
@@ -1,30 +1,25 @@
-#include <string>
+#include "gmock/gmock.h"
+#include "Soundex.h"
 
-class Soundex {
-public:
-  std::string encode(const std::string& word) const {
-    return zeroPad(word);
-  }
+using namespace testing;
 
-private:
-  std::string zeroPad(const std::string& word) const {
-    return word + "000";
-  }
+class SoundexEncoding: public Test {
+public:
+  Soundex soundex;
 };
 
-#include "gmock/gmock.h"
-using ::testing::Eq;
-
-TEST(SoundexEncoding, RetainsSoleLetterOfOneLetterWord) {
-   Soundex soundex;
+TEST_F(SoundexEncoding, RetainsSoleLetterOfOneLetterWord) {
    auto encoded = soundex.encode("A");
+
    ASSERT_THAT(encoded, Eq("A000"));
 }
 
-TEST(SoundexEncoding, PadsWithZerosToEnsureThreeDigits) {
-  Soundex soundex;
-
+TEST_F(SoundexEncoding, PadsWithZerosToEnsureThreeDigits) {
   auto encoded = soundex.encode("I");
 
   ASSERT_THAT(encoded, Eq("I000"));
 }
+
+TEST_F(SoundexEncoding, ReplacesConsonantsWithAppropriateDigits) {
+  ASSERT_THAT(soundex.encode("Ab"), Eq("A100"));
+}

From fdf84757a63e400a07f5027e4bca72cdab67975f Mon Sep 17 00:00:00 2001
From: Adam Getchell <acgetchell@ucdavis.edu>
Date: Thu, 2 Oct 2014 22:44:39 -0700
Subject: [PATCH 3/5] SoundEx works now, and it's important to use C++11 for
 unordered_map

---
 CMakeLists.txt  |  2 +-
 Soundex.h       | 16 +++++++++++++---
 SoundexTest.cpp | 10 +++-------
 3 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3185b10..32b3c7b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 2.6)
 
 include_directories($ENV{GMOCK_HOME}/include $ENV{GMOCK_HOME}/gtest/include)
 link_directories($ENV{GMOCK_HOME}/lib/.libs $ENV{GMOCK_HOME}/gtest/lib/.libs)
-#add_definitions(-std=c++0x)
+add_definitions(-std=c++11)
 set(CMAKE_CXX_FLAGS "${CMAXE_CXX_FLAGS} -Wall")
 
 set(sources
diff --git a/Soundex.h b/Soundex.h
index d82df22..7bb9373 100644
--- a/Soundex.h
+++ b/Soundex.h
@@ -1,6 +1,7 @@
 #ifndef Soundex_h
 #define Soundex_h
 #include <string>
+#include <unordered_map>
 
 class Soundex {
 public:
@@ -16,12 +17,21 @@ class Soundex {
   }
 
   std::string encodedDigits(const std::string& word) const {
-    if (word.length() > 1) return encodedDigit();
+    if (word.length() > 1) return encodedDigit(word[1]);
     return "";
   }
 
-  std::string encodedDigit() const {
-    return "1";
+  std::string encodedDigit(char letter) const {
+    const std::unordered_map<char, std::string> encodings {
+      {'b', "1"}, {'f', "1"}, {'p', "1"}, {'v', "1"},
+      {'c', "2"}, {'g', "2"}, {'j', "2"}, {'k', "2"}, {'q', "2"},
+                  {'s', "2"}, {'x', "2"}, {'z', "2"},
+      {'d', "3"}, {'t', "3"},
+      {'l', "4"},
+      {'m', "5"}, {'n', "5"},
+      {'r', "6"}
+    };
+    return encodings.find(letter)->second;
   }
 
   std::string zeroPad(const std::string& word) const {
diff --git a/SoundexTest.cpp b/SoundexTest.cpp
index 08c0d88..bec3dae 100644
--- a/SoundexTest.cpp
+++ b/SoundexTest.cpp
@@ -9,17 +9,13 @@ class SoundexEncoding: public Test {
 };
 
 TEST_F(SoundexEncoding, RetainsSoleLetterOfOneLetterWord) {
-   auto encoded = soundex.encode("A");
-
-   ASSERT_THAT(encoded, Eq("A000"));
+   ASSERT_THAT(soundex.encode("A"), Eq("A000"));
 }
 
 TEST_F(SoundexEncoding, PadsWithZerosToEnsureThreeDigits) {
-  auto encoded = soundex.encode("I");
-
-  ASSERT_THAT(encoded, Eq("I000"));
+  ASSERT_THAT(soundex.encode("I"), Eq("I000"));
 }
 
 TEST_F(SoundexEncoding, ReplacesConsonantsWithAppropriateDigits) {
-  ASSERT_THAT(soundex.encode("Ab"), Eq("A100"));
+  EXPECT_THAT(soundex.encode("Ax"), Eq("A200"));
 }

From 3cad4d6fb5a3dc39b7d71fcf6702a1066cf485ac Mon Sep 17 00:00:00 2001
From: Adam Getchell <acgetchell@ucdavis.edu>
Date: Fri, 3 Oct 2014 01:42:26 -0700
Subject: [PATCH 4/5] Lots of tests and refactoring!

---
 Soundex.h       | 70 ++++++++++++++++++++++++++++++++++++++++---------
 SoundexTest.cpp | 36 +++++++++++++++++++++++++
 2 files changed, 93 insertions(+), 13 deletions(-)

diff --git a/Soundex.h b/Soundex.h
index 7bb9373..77ca19d 100644
--- a/Soundex.h
+++ b/Soundex.h
@@ -5,20 +5,10 @@
 
 class Soundex {
 public:
-  static const size_t MaxCodeLength = 4;
+  static const size_t MaxCodeLength{4};
 
   std::string encode(const std::string& word) const {
-    return zeroPad(head(word) + encodedDigits(word));
-  }
-
-private:
-  std::string head(const std::string& word) const {
-    return word.substr(0, 1);
-  }
-
-  std::string encodedDigits(const std::string& word) const {
-    if (word.length() > 1) return encodedDigit(word[1]);
-    return "";
+    return zeroPad(upperFront(head(word)) + tail(encodedDigits(word)));
   }
 
   std::string encodedDigit(char letter) const {
@@ -31,13 +21,67 @@ class Soundex {
       {'m', "5"}, {'n', "5"},
       {'r', "6"}
     };
-    return encodings.find(letter)->second;
+    auto it = encodings.find(lower(letter));
+    return it == encodings.end() ? NotADigit : it->second;
+  }
+
+private:
+  char lower(char c) const {
+    return std::tolower(static_cast<unsigned char>(c));
+  }
+
+  std::string head(const std::string& word) const {
+    return word.substr(0, 1);
+  }
+
+  std::string tail(const std::string& word) const {
+    return word.substr(1);
+  }
+
+  const std::string NotADigit{"*"};
+
+  std::string encodedDigits(const std::string& word) const {
+    std::string encoding;
+    encodeHead(encoding, word);
+    encodeTail(encoding, word);
+    return encoding;
+  }
+
+  void encodeHead(std::string& encoding, const std::string& word) const {
+    encoding += encodedDigit(word.front());
+  }
+
+  void encodeTail(std::string& encoding, const std::string& word) const {
+    for (auto letter: tail(word)) {
+      if (!isComplete(encoding))
+        encodeLetter(encoding, letter);
+    }
+  }
+
+  void encodeLetter(std::string& encoding, char letter) const {
+    auto digit = encodedDigit(letter);
+    if (digit != NotADigit && digit != lastDigit(encoding))
+      encoding += digit;
+  }
+
+  bool isComplete (const std::string& encoding) const {
+    return encoding.length() == MaxCodeLength;
   }
 
   std::string zeroPad(const std::string& word) const {
     auto zerosNeeded = MaxCodeLength - word.length();
     return word + std::string(zerosNeeded, '0');
   }
+
+  std::string lastDigit(const std::string& encoding) const {
+    if (encoding.empty()) return NotADigit;
+    return std::string(1, encoding.back());
+  }
+
+  std::string upperFront(const std::string& string) const {
+    return std::string(1,
+      std::toupper(static_cast<unsigned char>(string.front())));
+  }
 };
 
 #endif
diff --git a/SoundexTest.cpp b/SoundexTest.cpp
index bec3dae..98608b4 100644
--- a/SoundexTest.cpp
+++ b/SoundexTest.cpp
@@ -19,3 +19,39 @@ TEST_F(SoundexEncoding, PadsWithZerosToEnsureThreeDigits) {
 TEST_F(SoundexEncoding, ReplacesConsonantsWithAppropriateDigits) {
   EXPECT_THAT(soundex.encode("Ax"), Eq("A200"));
 }
+
+TEST_F(SoundexEncoding, IgnoresNonAlphabetics) {
+  ASSERT_THAT(soundex.encode("A#"), Eq("A000"));
+}
+
+TEST_F(SoundexEncoding, ReplacesMultipleConsonantsWithDigits) {
+  ASSERT_THAT(soundex.encode("Acdl"), Eq("A234"));
+}
+
+TEST_F(SoundexEncoding, LimitsLengthToFourCharacters) {
+  ASSERT_THAT(soundex.encode("Dcdlb").length(), Eq(4u));
+}
+
+TEST_F(SoundexEncoding, IgnoresVowelLikeLetters) {
+  ASSERT_THAT(soundex.encode("BaAeEiIoOuUhHyYcdl"), Eq("B234"));
+}
+
+TEST_F(SoundexEncoding, CombinesDublicateEncodings) {
+  ASSERT_THAT(soundex.encodedDigit('b'), Eq(soundex.encodedDigit('f')));
+  ASSERT_THAT(soundex.encodedDigit('c'), Eq(soundex.encodedDigit('g')));
+  ASSERT_THAT(soundex.encodedDigit('d'), Eq(soundex.encodedDigit('t')));
+
+  ASSERT_THAT(soundex.encode("Abfcgdt"), Eq("A123"));
+}
+
+TEST_F(SoundexEncoding, UppercasesFirstLetter) {
+  ASSERT_THAT(soundex.encode("abcd"), StartsWith("A"));
+}
+
+TEST_F(SoundexEncoding, IgnoresCaseWhenEncodingConsonants) {
+  ASSERT_THAT(soundex.encode("BCDL"), Eq(soundex.encode("Bcdl")));
+}
+
+TEST_F(SoundexEncoding, CombinesDuplicateCodesWhen2ndLetterDuplicates1st) {
+  ASSERT_THAT(soundex.encode("Bbcd"), Eq("B230"));
+}

From a8c5d8f19bb6cb9fdfe36ce072d4efdb4ddc6693 Mon Sep 17 00:00:00 2001
From: Adam Getchell <acgetchell@ucdavis.edu>
Date: Fri, 3 Oct 2014 01:54:52 -0700
Subject: [PATCH 5/5] Minimally functioning SoundEx that passes all tests

---
 Soundex.h       | 14 ++++++++++----
 SoundexTest.cpp |  4 ++++
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/Soundex.h b/Soundex.h
index 77ca19d..599bf5c 100644
--- a/Soundex.h
+++ b/Soundex.h
@@ -52,18 +52,24 @@ class Soundex {
   }
 
   void encodeTail(std::string& encoding, const std::string& word) const {
-    for (auto letter: tail(word)) {
+    for (auto i = 1u; i < word.length(); i++) {
       if (!isComplete(encoding))
-        encodeLetter(encoding, letter);
+        encodeLetter(encoding, word[i], word[i-1]);
     }
   }
 
-  void encodeLetter(std::string& encoding, char letter) const {
+  void encodeLetter(std::string& encoding, char letter, char lastLetter) const {
     auto digit = encodedDigit(letter);
-    if (digit != NotADigit && digit != lastDigit(encoding))
+    if (digit != NotADigit &&
+      (digit != lastDigit(encoding) || isVowel(lastLetter)))
       encoding += digit;
   }
 
+  bool isVowel(char letter) const {
+    return
+      std::string("aeiouy").find(lower(letter)) != std::string::npos;
+  }
+
   bool isComplete (const std::string& encoding) const {
     return encoding.length() == MaxCodeLength;
   }
diff --git a/SoundexTest.cpp b/SoundexTest.cpp
index 98608b4..e57bb4b 100644
--- a/SoundexTest.cpp
+++ b/SoundexTest.cpp
@@ -55,3 +55,7 @@ TEST_F(SoundexEncoding, IgnoresCaseWhenEncodingConsonants) {
 TEST_F(SoundexEncoding, CombinesDuplicateCodesWhen2ndLetterDuplicates1st) {
   ASSERT_THAT(soundex.encode("Bbcd"), Eq("B230"));
 }
+
+TEST_F(SoundexEncoding, DoesNotCombineDuplicateEncodingsSeparatedByVowels) {
+  ASSERT_THAT(soundex.encode("Jbob"), Eq("J110"));
+}