version 0.6.0

fixed new season menu

ChangeLog.md

@@ -1,5 +1,16 @@
 # Changelog for mtlstats
 
+## 0.6.0
+- Generate lifetime statistics report
+- Implemented goalie editing
+- Reset game standings on new season
+
+## 0.5.0
+
+- Fixed player creation bug
+- Prompt for goalie informaiton on game data entry
+- Implemented player editing
+
 ## v0.4.0
 
 - Record penalty minutes

package.yaml

@@ -1,5 +1,5 @@
 name:                mtlstats
-version:             0.4.0
+version:             0.6.0
 github:              "mtlstats/mtlstats"
 license:             GPL-3
 author:              "Jonathan Lamothe"
@@ -11,13 +11,13 @@ extra-source-files:
 - ChangeLog.md
 
 # Metadata used when publishing your package
-# synopsis:            Short description of your package
+synopsis:            Hockey statistics tracker
-# category:            Web
+category:            Statistics
 
 # To avoid duplicated efforts in documentation and dealing with the
 # complications of embedding Haddock markup inside cabal files, it is
 # common to point users to the README.md file.
-description:         Please see the README on GitHub at <https://github.com/jlamothe/mtlstats#readme>
+description:         Please see the README on GitHub at <https://github.com/mtlstats/mtlstats#readme>
 
 dependencies:
 - base >= 4.7 && < 5
@@ -33,6 +33,10 @@ dependencies:
 - bytestring
 - microlens
 
+ghc-options:
+  - -Wall
+  - -Werror
+
 library:
   source-dirs: src
 

src/Mtlstats/Actions.hs

@@ -24,32 +24,28 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 module Mtlstats.Actions
   ( startNewSeason
   , resetYtd
+  , resetStandings
   , startNewGame
   , addChar
   , removeChar
-  , overtimeCheck
-  , updateGameStats
-  , validateGameDate
   , createPlayer
+  , createGoalie
+  , editPlayer
+  , editGoalie
   , addPlayer
-  , recordGoalAssists
+  , addGoalie
-  , awardGoal
+  , resetCreatePlayerState
-  , awardAssist
+  , resetCreateGoalieState
-  , resetGoalData
-  , assignPMins
   , backHome
   , scrollUp
   , scrollDown
   ) where
 
 import Control.Monad.Trans.State (modify)
-import qualified Data.Map as M
 import Data.Maybe (fromMaybe)
-import Data.Time.Calendar (fromGregorianValid)
+import Lens.Micro ((^.), (&), (.~), (%~))
-import Lens.Micro (over, (^.), (&), (.~), (?~), (%~), (+~))
 
 import Mtlstats.Types
-import Mtlstats.Util
 
 -- | Starts a new season
 startNewSeason :: ProgState -> ProgState
@@ -61,6 +57,12 @@ resetYtd
   = (database . dbPlayers %~ map (pYtd .~ newPlayerStats))
   . (database . dbGoalies %~ map (gYtd .~ newGoalieStats))
 
+-- | Resets game standings
+resetStandings :: ProgState -> ProgState
+resetStandings = database
+  %~ ( dbHomeGameStats .~ newGameStats)
+  .  ( dbAwayGameStats .~ newGameStats)
+
 -- | Starts a new game
 startNewGame :: ProgState -> ProgState
 startNewGame
@@ -77,75 +79,32 @@ removeChar = inputBuffer %~ \case
   ""  -> ""
   str -> init str
 
--- | Determines whether or not to perform a check for overtime
-overtimeCheck :: ProgState -> ProgState
-overtimeCheck s
-  | fromMaybe False $ gameTied $ s^.progMode.gameStateL =
-    s & progMode.gameStateL
-    %~ (homeScore .~ Nothing)
-    .  (awayScore .~ Nothing)
-  | fromMaybe False $ gameWon $ s^.progMode.gameStateL =
-    s & progMode.gameStateL.overtimeFlag ?~ False
-  | otherwise  = s
-
--- | Adjusts the game stats based on the results of the current game
-updateGameStats :: ProgState -> ProgState
-updateGameStats s = fromMaybe s $ do
-  let gs = s^.progMode.gameStateL
-  gType  <- gs^.gameType
-  won    <- gameWon gs
-  lost   <- gameLost gs
-  ot     <- gs^.overtimeFlag
-  tScore <- teamScore gs
-  oScore <- otherScore gs
-  let
-    hw  = if gType == HomeGame && won then 1 else 0
-    hl  = if gType == HomeGame && lost then 1 else 0
-    hot = if gType == HomeGame && ot then 1 else 0
-    hgf = if gType == HomeGame then tScore else 0
-    hga = if gType == HomeGame then oScore else 0
-    aw  = if gType == AwayGame && won then 1 else 0
-    al  = if gType == AwayGame && lost then 1 else 0
-    aot = if gType == AwayGame && ot then 1 else 0
-    agf = if gType == AwayGame then tScore else 0
-    aga = if gType == AwayGame then oScore else 0
-  Just $ s
-    & database.dbHomeGameStats
-      %~ (gmsWins         +~ hw)
-      .  (gmsLosses       +~ hl)
-      .  (gmsOvertime     +~ hot)
-      .  (gmsGoalsFor     +~ hgf)
-      .  (gmsGoalsAgainst +~ hga)
-    & database.dbAwayGameStats
-      %~ (gmsWins         +~ aw)
-      .  (gmsLosses       +~ al)
-      .  (gmsOvertime     +~ aot)
-      .  (gmsGoalsFor     +~ agf)
-      .  (gmsGoalsAgainst +~ aga)
-
--- | Validates the game date
-validateGameDate :: ProgState -> ProgState
-validateGameDate s = fromMaybe s $ do
-  y <- toInteger <$> s^.progMode.gameStateL.gameYear
-  m <- s^.progMode.gameStateL.gameMonth
-  d <- s^.progMode.gameStateL.gameDay
-  Just $ if null $ fromGregorianValid y m d
-    then s & progMode.gameStateL
-      %~ (gameYear  .~ Nothing)
-      .  (gameMonth .~ Nothing)
-      .  (gameDay   .~ Nothing)
-    else s
-
 -- | Starts player creation mode
 createPlayer :: ProgState -> ProgState
 createPlayer = let
-  cb = modify $ progMode .~ MainMenu
+  callback = modify $ progMode .~ MainMenu
-  cps
+  cps = newCreatePlayerState
-    = newCreatePlayerState
+    & cpsSuccessCallback .~ callback
-    & cpsSuccessCallback .~ cb
+    & cpsFailureCallback .~ callback
-    & cpsFailureCallback .~ cb
   in progMode .~ CreatePlayer cps
 
+-- | Starts goalie creation mode
+createGoalie :: ProgState -> ProgState
+createGoalie = let
+  callback = modify $ progMode .~ MainMenu
+  cgs = newCreateGoalieState
+    & cgsSuccessCallback .~ callback
+    & cgsFailureCallback .~ callback
+  in progMode .~ CreateGoalie cgs
+
+-- | Starts the player editing process
+editPlayer :: ProgState -> ProgState
+editPlayer = progMode .~ EditPlayer newEditPlayerState
+
+-- | Starts the 'Goalie' editing process
+editGoalie :: ProgState -> ProgState
+editGoalie = progMode .~ EditGoalie newEditGoalieState
+
 -- | Adds the entered player to the roster
 addPlayer :: ProgState -> ProgState
 addPlayer s = fromMaybe s $ do
@@ -158,80 +117,29 @@ addPlayer s = fromMaybe s $ do
   Just $ s & database.dbPlayers
     %~ (++[player])
 
--- | Awards the goal and assists to the players
+-- | Adds the entered goalie to the roster
-recordGoalAssists :: ProgState -> ProgState
+addGoalie :: ProgState -> ProgState
-recordGoalAssists ps = fromMaybe ps $ do
+addGoalie s = fromMaybe s $ do
-  let gs = ps^.progMode.gameStateL
+  let cgs = s^.progMode.createGoalieStateL
-  goalId <- gs^.goalBy
+  num <- cgs^.cgsNumber
-  let assistIds = gs^.assistsBy
+  let
-  Just $ ps
+    name   = cgs^.cgsName
-    & awardGoal goalId
+    goalie = newGoalie num name
-    & (\s -> foldr awardAssist s assistIds)
+  Just $ s & database.dbGoalies
-    & progMode.gameStateL
+    %~ (++[goalie])
-      %~ (goalBy              .~ Nothing)
-      .  (assistsBy           .~ [])
-      .  (pointsAccounted     %~ succ)
-      .  (confirmGoalDataFlag .~ False)
 
--- | Awards a goal to a player
+-- | Resets the 'CreatePlayerState' value
-awardGoal
+resetCreatePlayerState :: ProgState -> ProgState
-  :: Int
+resetCreatePlayerState = progMode.createPlayerStateL
-  -- ^ The player's index number
+  %~ (cpsNumber   .~ Nothing)
-  -> ProgState
+  .  (cpsName     .~ "")
-  -> ProgState
+  .  (cpsPosition .~ "")
-awardGoal n ps = ps
-  & progMode.gameStateL.gamePlayerStats %~
-    (\m -> let
-      stats = M.findWithDefault newPlayerStats n m
-      in M.insert n (stats & psGoals %~ succ) m)
-  & database.dbPlayers %~ map
-    (\(i, p) -> if i == n
-      then p
-        & pYtd.psGoals      %~ succ
-        & pLifetime.psGoals %~ succ
-      else p) . zip [0..]
 
--- | Awards an assist to a player
+-- | Resets the 'CreateGoalieState' value
-awardAssist
+resetCreateGoalieState :: ProgState -> ProgState
-  :: Int
+resetCreateGoalieState = progMode.createGoalieStateL
-  -- ^ The player's index number
+  %~ (cgsNumber .~ Nothing)
-  -> ProgState
+  .  (cgsName   .~ "")
-  -> ProgState
-awardAssist n ps = ps
-  & progMode.gameStateL.gamePlayerStats %~
-    (\m -> let
-      stats = M.findWithDefault newPlayerStats n m
-      in M.insert n (stats & psAssists %~ succ) m)
-  & database.dbPlayers %~ map
-    (\(i, p) -> if i == n
-      then p
-        & pYtd.psAssists      %~ succ
-        & pLifetime.psAssists %~ succ
-      else p) . zip [0..]
-
--- | Resets the entered data for the current goal
-resetGoalData :: ProgState -> ProgState
-resetGoalData ps = ps & progMode.gameStateL
-  %~ (goalBy              .~ Nothing)
-  .  (assistsBy           .~ [])
-  .  (confirmGoalDataFlag .~ False)
-
--- | Adds penalty minutes to a player
-assignPMins
-  :: Int
-  -- ^ The number of minutes to add
-  -> ProgState
-  -> ProgState
-assignPMins mins s = fromMaybe s $ do
-  n <- s^.progMode.gameStateL.selectedPlayer
-  Just $ s
-    & database.dbPlayers %~ modifyNth n
-      (((pYtd.psPMin) +~ mins) . ((pLifetime.psPMin) +~ mins))
-    & progMode.gameStateL
-      %~ ( gamePlayerStats %~ updateMap n newPlayerStats
-           (psPMin +~ mins)
-         )
-      .  (selectedPlayer .~ Nothing)
 
 -- | Resets the program state back to the main menu
 backHome :: ProgState -> ProgState

src/Mtlstats/Actions/EditGoalie.hs

@@ -0,0 +1,164 @@
+{- |
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+module Mtlstats.Actions.EditGoalie
+  ( editGoalieNumber
+  , editGoalieName
+  , editGoalieYtdGames
+  , editGoalieYtdMins
+  , editGoalieYtdGoals
+  , editGoalieYtdWins
+  , editGoalieYtdLosses
+  , editGoalieYtdTies
+  , editGoalieLtGames
+  , editGoalieLtMins
+  , editGoalieLtGoals
+  , editGoalieLtWins
+  , editGoalieLtLosses
+  , editGoalieLtTies
+  ) where
+
+import Control.Monad (void)
+import Data.Maybe (fromMaybe)
+import Lens.Micro ((^.), (&), (.~), (%~))
+
+import Mtlstats.Types
+import Mtlstats.Util
+
+-- | Edits a goalie's number
+editGoalieNumber
+  :: Int
+  -- ^ New goalie number
+  -> ProgState
+  -> ProgState
+editGoalieNumber num = editGoalie (gNumber .~ num) EGMenu
+
+-- | Edits a goalie's name
+editGoalieName
+  :: String
+  -- ^ The new name
+  -> ProgState
+  -> ProgState
+editGoalieName name = editGoalie (gName .~ name) EGMenu
+
+-- | Edits a goalie's YTD games
+editGoalieYtdGames
+  :: Int
+  -- ^ The number of games played
+  -> ProgState
+  -> ProgState
+editGoalieYtdGames games = editGoalie (gYtd.gsGames .~ games) EGYtd
+
+-- | Edits a goalie's YTD minutes
+editGoalieYtdMins
+  :: Int
+  -- ^ The number of minutes played
+  -> ProgState
+  -> ProgState
+editGoalieYtdMins mins = editGoalie (gYtd.gsMinsPlayed .~ mins) EGYtd
+
+-- | Edits a goalie's YTD goals allowed
+editGoalieYtdGoals
+  :: Int
+  -- ^ The number of goals
+  -> ProgState
+  -> ProgState
+editGoalieYtdGoals goals = editGoalie (gYtd.gsGoalsAllowed .~ goals) EGYtd
+
+-- | Edits a goalie's YTD wins
+editGoalieYtdWins
+  :: Int
+  -- ^ The number of wins
+  -> ProgState
+  -> ProgState
+editGoalieYtdWins wins = editGoalie (gYtd.gsWins .~ wins) EGYtd
+
+-- | Edits a goalie's YTD losses
+editGoalieYtdLosses
+  :: Int
+  -- ^ The number of losses
+  -> ProgState
+  -> ProgState
+editGoalieYtdLosses losses = editGoalie (gYtd.gsLosses .~ losses) EGYtd
+
+-- | Edits a goalie's YTD ties
+editGoalieYtdTies
+  :: Int
+  -- ^ The number of ties
+  -> ProgState
+  -> ProgState
+editGoalieYtdTies ties = editGoalie (gYtd.gsTies .~ ties) EGYtd
+
+-- | Edits a goalie's lifetime games played
+editGoalieLtGames
+  :: Int
+  -- ^ The number of games
+  -> ProgState
+  -> ProgState
+editGoalieLtGames games = editGoalie (gLifetime.gsGames .~ games) EGLifetime
+
+-- | Edits a goalie's lifetime minutes played
+editGoalieLtMins
+  :: Int
+  -- ^ The number of minutes
+  -> ProgState
+  -> ProgState
+editGoalieLtMins mins = editGoalie (gLifetime.gsMinsPlayed .~ mins) EGLifetime
+
+-- | Edits a goalie's lifetime goals allowed
+editGoalieLtGoals
+  :: Int
+  -- ^ The number of goals
+  -> ProgState
+  -> ProgState
+editGoalieLtGoals goals = editGoalie (gLifetime.gsGoalsAllowed .~ goals) EGLifetime
+
+-- | Edits a goalie's lifetime wins
+editGoalieLtWins
+  :: Int
+  -- ^ The number of wins
+  -> ProgState
+  -> ProgState
+editGoalieLtWins wins = editGoalie (gLifetime.gsWins .~ wins) EGLifetime
+
+-- | Edits a goalie's lifetime losses
+editGoalieLtLosses
+  :: Int
+  -- ^ The number of losses
+  -> ProgState
+  -> ProgState
+editGoalieLtLosses losses = editGoalie (gLifetime.gsLosses .~ losses) EGLifetime
+
+-- | Edits a goalie's lifetime ties
+editGoalieLtTies
+  :: Int
+  -- ^ The number of ties
+  -> ProgState
+  -> ProgState
+editGoalieLtTies ties = editGoalie (gLifetime.gsTies .~ ties) EGLifetime
+
+editGoalie :: (Goalie -> Goalie) -> EditGoalieMode -> ProgState -> ProgState
+editGoalie f mode s = fromMaybe s $ do
+  gid <- s^.progMode.editGoalieStateL.egsSelectedGoalie
+  void $ nth gid $ s^.database.dbGoalies
+  Just $ s
+    & database.dbGoalies %~ modifyNth gid f
+    & progMode.editGoalieStateL.egsMode .~ mode

src/Mtlstats/Actions/NewGame.hs

@@ -0,0 +1,173 @@
+{- |
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+module Mtlstats.Actions.NewGame
+  ( overtimeCheck
+  , updateGameStats
+  , validateGameDate
+  , recordGoalAssists
+  , awardGoal
+  , awardAssist
+  , resetGoalData
+  , assignPMins
+  ) where
+
+import qualified Data.Map as M
+import Data.Maybe (fromMaybe)
+import Data.Time.Calendar (fromGregorianValid)
+import Lens.Micro ((^.), (&), (.~), (?~), (%~), (+~))
+
+import Mtlstats.Types
+import Mtlstats.Util
+
+-- | Determines whether or not to perform a check for overtime
+overtimeCheck :: ProgState -> ProgState
+overtimeCheck s
+  | fromMaybe False $ gameTied $ s^.progMode.gameStateL =
+    s & progMode.gameStateL
+    %~ (homeScore .~ Nothing)
+    .  (awayScore .~ Nothing)
+  | fromMaybe False $ gameWon $ s^.progMode.gameStateL =
+    s & progMode.gameStateL.overtimeFlag ?~ False
+  | otherwise  = s
+
+-- | Adjusts the game stats based on the results of the current game
+updateGameStats :: ProgState -> ProgState
+updateGameStats s = fromMaybe s $ do
+  let gs = s^.progMode.gameStateL
+  gType  <- gs^.gameType
+  won    <- gameWon gs
+  lost   <- gameLost gs
+  ot     <- gs^.overtimeFlag
+  tScore <- teamScore gs
+  oScore <- otherScore gs
+  let
+    hw  = if gType == HomeGame && won then 1 else 0
+    hl  = if gType == HomeGame && lost then 1 else 0
+    hot = if gType == HomeGame && ot then 1 else 0
+    hgf = if gType == HomeGame then tScore else 0
+    hga = if gType == HomeGame then oScore else 0
+    aw  = if gType == AwayGame && won then 1 else 0
+    al  = if gType == AwayGame && lost then 1 else 0
+    aot = if gType == AwayGame && ot then 1 else 0
+    agf = if gType == AwayGame then tScore else 0
+    aga = if gType == AwayGame then oScore else 0
+  Just $ s
+    & database.dbHomeGameStats
+      %~ (gmsWins         +~ hw)
+      .  (gmsLosses       +~ hl)
+      .  (gmsOvertime     +~ hot)
+      .  (gmsGoalsFor     +~ hgf)
+      .  (gmsGoalsAgainst +~ hga)
+    & database.dbAwayGameStats
+      %~ (gmsWins         +~ aw)
+      .  (gmsLosses       +~ al)
+      .  (gmsOvertime     +~ aot)
+      .  (gmsGoalsFor     +~ agf)
+      .  (gmsGoalsAgainst +~ aga)
+
+-- | Validates the game date
+validateGameDate :: ProgState -> ProgState
+validateGameDate s = fromMaybe s $ do
+  y <- toInteger <$> s^.progMode.gameStateL.gameYear
+  m <- s^.progMode.gameStateL.gameMonth
+  d <- s^.progMode.gameStateL.gameDay
+  Just $ if null $ fromGregorianValid y m d
+    then s & progMode.gameStateL
+      %~ (gameYear  .~ Nothing)
+      .  (gameMonth .~ Nothing)
+      .  (gameDay   .~ Nothing)
+    else s
+
+-- | Awards the goal and assists to the players
+recordGoalAssists :: ProgState -> ProgState
+recordGoalAssists ps = fromMaybe ps $ do
+  let gs = ps^.progMode.gameStateL
+  goalId <- gs^.goalBy
+  let assistIds = gs^.assistsBy
+  Just $ ps
+    & awardGoal goalId
+    & (\s -> foldr awardAssist s assistIds)
+    & progMode.gameStateL
+      %~ (goalBy              .~ Nothing)
+      .  (assistsBy           .~ [])
+      .  (pointsAccounted     %~ succ)
+      .  (confirmGoalDataFlag .~ False)
+
+-- | Awards a goal to a player
+awardGoal
+  :: Int
+  -- ^ The player's index number
+  -> ProgState
+  -> ProgState
+awardGoal n ps = ps
+  & progMode.gameStateL.gamePlayerStats %~
+    (\m -> let
+      stats = M.findWithDefault newPlayerStats n m
+      in M.insert n (stats & psGoals %~ succ) m)
+  & database.dbPlayers %~ map
+    (\(i, p) -> if i == n
+      then p
+        & pYtd.psGoals      %~ succ
+        & pLifetime.psGoals %~ succ
+      else p) . zip [0..]
+
+-- | Awards an assist to a player
+awardAssist
+  :: Int
+  -- ^ The player's index number
+  -> ProgState
+  -> ProgState
+awardAssist n ps = ps
+  & progMode.gameStateL.gamePlayerStats %~
+    (\m -> let
+      stats = M.findWithDefault newPlayerStats n m
+      in M.insert n (stats & psAssists %~ succ) m)
+  & database.dbPlayers %~ map
+    (\(i, p) -> if i == n
+      then p
+        & pYtd.psAssists      %~ succ
+        & pLifetime.psAssists %~ succ
+      else p) . zip [0..]
+
+-- | Resets the entered data for the current goal
+resetGoalData :: ProgState -> ProgState
+resetGoalData ps = ps & progMode.gameStateL
+  %~ (goalBy              .~ Nothing)
+  .  (assistsBy           .~ [])
+  .  (confirmGoalDataFlag .~ False)
+
+-- | Adds penalty minutes to a player
+assignPMins
+  :: Int
+  -- ^ The number of minutes to add
+  -> ProgState
+  -> ProgState
+assignPMins mins s = fromMaybe s $ do
+  n <- s^.progMode.gameStateL.gameSelectedPlayer
+  Just $ s
+    & database.dbPlayers %~ modifyNth n
+      (((pYtd.psPMin) +~ mins) . ((pLifetime.psPMin) +~ mins))
+    & progMode.gameStateL
+      %~ ( gamePlayerStats %~ updateMap n newPlayerStats
+           (psPMin +~ mins)
+         )
+      .  (gameSelectedPlayer .~ Nothing)

src/Mtlstats/Actions/NewGame/GoalieInput.hs

@@ -0,0 +1,109 @@
+{- |
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+module Mtlstats.Actions.NewGame.GoalieInput
+  ( finishGoalieEntry
+  , recordGoalieStats
+  , setGameGoalie
+  ) where
+
+import Control.Monad (void)
+import qualified Data.Map as M
+import Data.Maybe (fromMaybe)
+import Lens.Micro ((^.), (&), (.~), (%~), (+~))
+
+import Mtlstats.Config
+import Mtlstats.Types
+import Mtlstats.Util
+
+-- | Attempts to finish game goalie entry
+finishGoalieEntry :: ProgState -> ProgState
+finishGoalieEntry s = s & progMode.gameStateL.gameGoaliesRecorded
+  .~ not (null $ s^.progMode.gameStateL.gameGoalieStats)
+
+-- | Records the goalie's game stats
+recordGoalieStats :: ProgState -> ProgState
+recordGoalieStats s = fromMaybe s $ do
+  let gs = s^.progMode.gameStateL
+  gid   <- gs^.gameSelectedGoalie
+  mins  <- gs^.gameGoalieMinsPlayed
+  goals <- gs^.gameGoalsAllowed
+  void $ nth gid $ s^.database.dbGoalies
+
+  let
+    gameStats = M.findWithDefault newGoalieStats gid $ gs^.gameGoalieStats
+    bumpVal   = if gameStats^.gsGames == 0
+      then 1
+      else 0
+
+    bumpStats
+      = (gsGames        +~ bumpVal)
+      . (gsMinsPlayed   +~ mins)
+      . (gsGoalsAllowed +~ goals)
+
+    tryFinish = if mins >= gameLength
+      then finishGoalieEntry
+      else id
+
+  Just $ s
+    & progMode.gameStateL
+      %~ (gameGoalieStats    %~ updateMap gid newGoalieStats bumpStats)
+      .  (gameSelectedGoalie   .~ Nothing)
+      .  (gameGoalieMinsPlayed .~ Nothing)
+      .  (gameGoalsAllowed     .~ Nothing)
+    & database.dbGoalies
+      %~ modifyNth gid (\goalie -> goalie
+         & gYtd      %~ bumpStats
+         & gLifetime %~ bumpStats)
+    & tryFinish
+
+-- | Records the win, loss, or tie to a specific 'Goalie'
+setGameGoalie
+  :: Int
+  -- ^ The goalie's index
+  -> ProgState
+  -> ProgState
+setGameGoalie gid s = fromMaybe s $ do
+  let gs = s^.progMode.gameStateL
+  won  <- gameWon gs
+  lost <- gameLost gs
+  tied <- gs^.overtimeFlag
+  let
+    w = if won then 1 else 0
+    l = if lost then 1 else 0
+    t = if tied then 1 else 0
+
+    updateStats
+      = (gsWins   +~ w)
+      . (gsLosses +~ l)
+      . (gsTies   +~ t)
+
+    updateGoalie
+      = (gYtd      %~ updateStats)
+      . (gLifetime %~ updateStats)
+
+    updateGameState
+      = (gameGoalieStats %~ updateMap gid newGoalieStats updateStats)
+      . (gameGoalieAssigned .~ True)
+
+  Just $ s
+    & database.dbGoalies  %~ modifyNth gid updateGoalie
+    & progMode.gameStateL %~ updateGameState

src/Mtlstats/Config.hs

@@ -40,3 +40,7 @@ dbFname = "database.json"
 -- | The maximum number of assists
 maxAssists :: Int
 maxAssists = 2
+
+-- | The length of a typical game (in minutes)
+gameLength :: Int
+gameLength = 60

src/Mtlstats/Control.hs

@@ -21,22 +21,21 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 module Mtlstats.Control (dispatch) where
 
-import Control.Monad (join, when)
+import Control.Monad (join)
 import Control.Monad.Trans.State (gets, modify)
-import Data.Char (toUpper)
+import Data.Maybe (fromJust)
-import Data.Maybe (fromJust, fromMaybe, isJust)
+import Lens.Micro ((^.))
-import Lens.Micro ((^.), (.~), (%~))
 import Lens.Micro.Extras (view)
 import qualified UI.NCurses as C
 
 import Mtlstats.Actions
-import Mtlstats.Format
+import Mtlstats.Control.EditGoalie
+import Mtlstats.Control.EditPlayer
+import Mtlstats.Control.NewGame
 import Mtlstats.Handlers
 import Mtlstats.Menu
 import Mtlstats.Prompt
-import Mtlstats.Report
 import Mtlstats.Types
-import Mtlstats.Util
 
 -- | Reads the program state and returs the apropriate controller to
 -- run
@@ -44,25 +43,18 @@ dispatch :: ProgState -> Controller
 dispatch s = case s^.progMode of
   MainMenu  -> mainMenuC
   NewSeason -> newSeasonC
-  NewGame gs
+  NewGame _ -> newGameC s
-    | null $ gs^.gameYear             -> gameYearC
-    | null $ gs^.gameMonth            -> gameMonthC
-    | null $ gs^.gameDay              -> gameDayC
-    | null $ gs^.gameType             -> gameTypeC
-    | null $ gs^.otherTeam            -> otherTeamC
-    | null $ gs^.homeScore            -> homeScoreC
-    | null $ gs^.awayScore            -> awayScoreC
-    | null $ gs^.overtimeFlag         -> overtimeFlagC
-    | not $ gs^.dataVerified          -> verifyDataC
-    | fromJust (unaccountedPoints gs) -> goalInput gs
-    | isJust $ gs^.selectedPlayer     -> getPMinsC
-    | not $ gs^.pMinsRecorded         -> pMinPlayerC
-    | otherwise                       -> reportC
   CreatePlayer cps
     | null $ cps^.cpsNumber   -> getPlayerNumC
     | null $ cps^.cpsName     -> getPlayerNameC
     | null $ cps^.cpsPosition -> getPlayerPosC
     | otherwise               -> confirmCreatePlayerC
+  CreateGoalie cgs
+    | null $ cgs^.cgsNumber -> getGoalieNumC
+    | null $ cgs^.cgsName   -> getGoalieNameC
+    | otherwise             -> confirmCreateGoalieC
+  EditPlayer eps -> editPlayerC eps
+  EditGoalie egs -> editGoalieC egs
 
 mainMenuC :: Controller
 mainMenuC = Controller
@@ -78,219 +70,6 @@ newSeasonC = Controller
     return True
   }
 
-gameYearC :: Controller
-gameYearC = Controller
-  { drawController = \s -> do
-    header s
-    drawPrompt gameYearPrompt s
-  , handleController = \e -> do
-    promptHandler gameYearPrompt e
-    return True
-  }
-
-gameMonthC :: Controller
-gameMonthC = Controller
-  { drawController = \s -> do
-    header s
-    drawMenu gameMonthMenu
-  , handleController = \e -> do
-    menuHandler gameMonthMenu e
-    return True
-  }
-
-gameDayC :: Controller
-gameDayC = Controller
-  { drawController = \s -> do
-    header s
-    drawPrompt gameDayPrompt s
-  , handleController = \e -> do
-    promptHandler gameDayPrompt e
-    modify validateGameDate
-    return True
-  }
-
-gameTypeC :: Controller
-gameTypeC = Controller
-  { drawController = \s -> do
-    header s
-    drawMenu gameTypeMenu
-  , handleController = \e -> do
-    menuHandler gameTypeMenu e
-    return True
-  }
-
-otherTeamC :: Controller
-otherTeamC = Controller
-  { drawController = \s -> do
-    header s
-    drawPrompt otherTeamPrompt s
-  , handleController = \e -> do
-    promptHandler otherTeamPrompt e
-    return True
-  }
-
-homeScoreC :: Controller
-homeScoreC = Controller
-  { drawController = \s -> do
-    header s
-    drawPrompt homeScorePrompt s
-  , handleController = \e -> do
-    promptHandler homeScorePrompt e
-    return True
-  }
-
-awayScoreC :: Controller
-awayScoreC = Controller
-  { drawController = \s -> do
-    header s
-    drawPrompt awayScorePrompt s
-  , handleController = \e -> do
-    promptHandler awayScorePrompt e
-    modify overtimeCheck
-    return True
-  }
-
-overtimeFlagC :: Controller
-overtimeFlagC = Controller
-  { drawController = \s -> do
-    header s
-    C.drawString "Did the game go into overtime?  (Y/N)"
-    return C.CursorInvisible
-  , handleController = \e -> do
-    modify $ progMode.gameStateL.overtimeFlag .~ ynHandler e
-    return True
-  }
-
-verifyDataC :: Controller
-verifyDataC = Controller
-  { drawController = \s -> do
-    let gs = s^.progMode.gameStateL
-    header s
-    C.drawString "\n"
-    C.drawString $ "      Date: " ++ gameDate gs ++ "\n"
-    C.drawString $ " Game type: " ++ show (fromJust $ gs^.gameType) ++ "\n"
-    C.drawString $ "Other team: " ++ gs^.otherTeam ++ "\n"
-    C.drawString $ "Home score: " ++ show (fromJust $ gs^.homeScore) ++ "\n"
-    C.drawString $ "Away score: " ++ show (fromJust $ gs^.awayScore) ++ "\n"
-    C.drawString $ "  Overtime: " ++ show (fromJust $ gs^.overtimeFlag) ++ "\n\n"
-    C.drawString "Is the above information correct?  (Y/N)"
-    return C.CursorInvisible
-  , handleController = \e -> do
-    case ynHandler e of
-      Just True  -> do
-        modify $ progMode.gameStateL.dataVerified .~ True
-        modify updateGameStats
-      Just False -> modify $ progMode.gameStateL .~ newGameState
-      Nothing    -> return ()
-    return True
-  }
-
-goalInput :: GameState -> Controller
-goalInput gs
-  | null (gs^.goalBy            ) = recordGoalC
-  | not (gs^.confirmGoalDataFlag) = recordAssistC
-  | otherwise                     = confirmGoalDataC
-
-recordGoalC :: Controller
-recordGoalC = Controller
-  { drawController = \s -> let
-    (game, goal) = gameGoal s
-    in drawPrompt (recordGoalPrompt game goal) s
-  , handleController = \e -> do
-    (game, goal) <- gets gameGoal
-    promptHandler (recordGoalPrompt game goal) e
-    return True
-  }
-
-recordAssistC :: Controller
-recordAssistC = Controller
-  { drawController = \s -> let
-    (game, goal, assist) = gameGoalAssist s
-    in drawPrompt (recordAssistPrompt game goal assist) s
-  , handleController = \e -> do
-    (game, goal, assist) <- gets gameGoalAssist
-    promptHandler (recordAssistPrompt game goal assist) e
-    return True
-  }
-
-confirmGoalDataC :: Controller
-confirmGoalDataC = Controller
-  { drawController = \s -> do
-    let
-      (game, goal) = gameGoal s
-      gs           = s^.progMode.gameStateL
-      players      = s^.database.dbPlayers
-      msg          = unlines $
-        [ "          Game: " ++ padNum 2 game
-        , "          Goal: " ++ show goal
-        , "Goal scored by: " ++
-          playerSummary (fromJust $ gs^.goalBy >>= flip nth players)
-        ] ++
-        map
-          (\pid -> "   Assisted by: " ++
-            playerSummary (fromJust $ nth pid players))
-          (gs^.assistsBy) ++
-        [ ""
-        , "Is the above information correct? (Y/N)"
-        ]
-    C.drawString msg
-    return C.CursorInvisible
-  , handleController = \e -> do
-    case ynHandler e of
-      Just True  -> modify recordGoalAssists
-      Just False -> modify resetGoalData
-      Nothing    -> return ()
-    return True
-  }
-
-pMinPlayerC :: Controller
-pMinPlayerC = Controller
-  { drawController = \s -> do
-    header s
-    drawPrompt pMinPlayerPrompt s
-  , handleController = \e -> do
-    promptHandler pMinPlayerPrompt e
-    return True
-  }
-
-getPMinsC :: Controller
-getPMinsC = Controller
-  { drawController = \s -> do
-    header s
-    C.drawString $ fromMaybe "" $ do
-      pid    <- s^.progMode.gameStateL.selectedPlayer
-      player <- nth pid $ s^.database.dbPlayers
-      Just $ playerSummary player ++ "\n"
-    drawPrompt assignPMinsPrompt s
-  , handleController = \e -> do
-    promptHandler assignPMinsPrompt e
-    return True
-  }
-
-reportC :: Controller
-reportC = Controller
-  { drawController = \s -> do
-    (rows, cols) <- C.windowSize
-    C.drawString $ unlines $ slice
-      (s^.scrollOffset)
-      (fromInteger $ pred rows)
-      (report (fromInteger $ pred cols) s)
-    return C.CursorInvisible
-  , handleController = \e -> do
-    case e of
-      C.EventSpecialKey C.KeyUpArrow   -> modify scrollUp
-      C.EventSpecialKey C.KeyDownArrow -> modify scrollDown
-      C.EventSpecialKey C.KeyHome      -> modify $ scrollOffset .~ 0
-      C.EventSpecialKey _              -> modify backHome
-      C.EventCharacter _               -> modify backHome
-      _                                -> return ()
-    return True
-  }
-
-header :: ProgState -> C.Update ()
-header s = C.drawString $
-  "*** GAME " ++ padNum 2 (s^.database.dbGames) ++ " ***\n"
-
 getPlayerNumC :: Controller
 getPlayerNumC = Controller
   { drawController   = drawPrompt playerNumPrompt
@@ -335,14 +114,40 @@ confirmCreatePlayerC = Controller
     return True
   }
 
-gameGoal :: ProgState -> (Int, Int)
+getGoalieNumC :: Controller
-gameGoal s =
+getGoalieNumC = Controller
-  ( s^.database.dbGames
+  { drawController = drawPrompt goalieNumPrompt
-  , succ $ s^.progMode.gameStateL.pointsAccounted
+  , handleController = \e -> do
-  )
+    promptHandler goalieNumPrompt e
+    return True
+  }
 
-gameGoalAssist :: ProgState -> (Int, Int, Int)
+getGoalieNameC :: Controller
-gameGoalAssist s = let
+getGoalieNameC = Controller
-  (game, goal) = gameGoal s
+  { drawController = drawPrompt goalieNamePrompt
-  assist       = succ $ length $ s^.progMode.gameStateL.assistsBy
+  , handleController = \e -> do
-  in (game, goal, assist)
+    promptHandler goalieNamePrompt e
+    return True
+  }
+
+confirmCreateGoalieC :: Controller
+confirmCreateGoalieC = Controller
+  { drawController = \s -> do
+    let cgs = s^.progMode.createGoalieStateL
+    C.drawString $ unlines
+      [ "Goalie number: " ++ show (fromJust $ cgs^.cgsNumber)
+      , "  Goalie name: " ++ cgs^.cgsName
+      , ""
+      , "Create goalie: are you sure?  (Y/N)"
+      ]
+    return C.CursorInvisible
+  , handleController = \e -> do
+    case ynHandler e of
+      Just True -> do
+        modify addGoalie
+        join $ gets (^.progMode.createGoalieStateL.cgsSuccessCallback)
+      Just False ->
+        join $ gets (^.progMode.createGoalieStateL.cgsFailureCallback)
+      Nothing -> return ()
+    return True
+  }

src/Mtlstats/Control/EditGoalie.hs

@@ -0,0 +1,137 @@
+{- |
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+{-# LANGUAGE LambdaCase #-}
+
+module Mtlstats.Control.EditGoalie (editGoalieC) where
+
+import Data.Maybe (fromMaybe)
+import Lens.Micro ((^.))
+import UI.NCurses as C
+
+import Mtlstats.Menu
+import Mtlstats.Menu.EditGoalie
+import Mtlstats.Prompt
+import Mtlstats.Prompt.EditGoalie
+import Mtlstats.Types
+import Mtlstats.Util
+
+-- | Controller/dispatcher for editing a 'Goalie'
+editGoalieC :: EditGoalieState -> Controller
+editGoalieC egs
+  | null $ egs^.egsSelectedGoalie = selectC
+  | otherwise = editC $ egs^.egsMode
+
+selectC :: Controller
+selectC = promptController goalieToEditPrompt
+
+editC :: EditGoalieMode -> Controller
+editC = \case
+  EGMenu      -> menuC
+  EGNumber    -> numberC
+  EGName      -> nameC
+  EGYtd       -> ytdMenuC
+  EGLifetime  -> lifetimeMenuC
+  EGYtdGames  -> ytdGamesC
+  EGYtdMins   -> ytdMinsC
+  EGYtdGoals  -> ytdGoalsC
+  EGYtdWins   -> ytdWinsC
+  EGYtdLosses -> ytdLossesC
+  EGYtdTies   -> ytdTiesC
+  EGLtGames   -> ltGamesC
+  EGLtMins    -> ltMinsC
+  EGLtGoals   -> ltGoalsC
+  EGLtWins    -> ltWinsC
+  EGLtLosses  -> ltLossesC
+  EGLtTies    -> ltTiesC
+
+menuC :: Controller
+menuC = menuControllerWith header editGoalieMenu
+
+numberC :: Controller
+numberC = promptController editGoalieNumberPrompt
+
+nameC :: Controller
+nameC = promptController editGoalieNamePrompt
+
+ytdMenuC :: Controller
+ytdMenuC = menuControllerWith header editGoalieYtdMenu
+
+lifetimeMenuC :: Controller
+lifetimeMenuC = menuControllerWith header editGoalieLtMenu
+
+ytdGamesC :: Controller
+ytdGamesC = promptController editGoalieYtdGamesPrompt
+
+ytdMinsC :: Controller
+ytdMinsC = promptController editGoalieYtdMinsPrompt
+
+ytdGoalsC :: Controller
+ytdGoalsC = promptController editGoalieYtdGoalsPrompt
+
+ytdWinsC :: Controller
+ytdWinsC = promptController editGoalieYtdWinsPrompt
+
+ytdLossesC :: Controller
+ytdLossesC = promptController editGoalieYtdLossesPrompt
+
+ytdTiesC :: Controller
+ytdTiesC = promptController editGoalieYtdTiesPrompt
+
+ltGamesC :: Controller
+ltGamesC = promptController editGoalieLtGamesPrompt
+
+ltMinsC :: Controller
+ltMinsC = promptController editGoalieLtMinsPrompt
+
+ltGoalsC :: Controller
+ltGoalsC = promptController editGoalieLtGoalsPrompt
+
+ltWinsC :: Controller
+ltWinsC = promptController editGoalieLtWinsPrompt
+
+ltLossesC :: Controller
+ltLossesC = promptController editGoalieLtLossesPrompt
+
+ltTiesC :: Controller
+ltTiesC = promptController editGoalieLtTiesPrompt
+
+header :: ProgState -> C.Update ()
+header s = C.drawString $ fromMaybe "" $ do
+  gid <- s^.progMode.editGoalieStateL.egsSelectedGoalie
+  g   <- nth gid $ s^.database.dbGoalies
+  Just $ unlines
+    [ "         Goalie number: " ++ show (g^.gNumber)
+    , "           Goalie name: " ++ g^.gName
+    , "      YTD games played: " ++ show (g^.gYtd.gsGames)
+    , "       YTD mins played: " ++ show (g^.gYtd.gsMinsPlayed)
+    , "     YTD goals allowed: " ++ show (g^.gYtd.gsGoalsAllowed)
+    , "              YTD wins: " ++ show (g^.gYtd.gsWins)
+    , "            YTD losses: " ++ show (g^.gYtd.gsLosses)
+    , "              YTD ties: " ++ show (g^.gYtd.gsTies)
+    , " Lifetime games played: " ++ show (g^.gLifetime.gsGames)
+    , "  Lifetime mins played: " ++ show (g^.gLifetime.gsMinsPlayed)
+    , "Lifetime goals allowed: " ++ show (g^.gLifetime.gsGoalsAllowed)
+    , "         Lifetime wins: " ++ show (g^.gLifetime.gsWins)
+    , "       Lifetime losses: " ++ show (g^.gLifetime.gsLosses)
+    , "         Lifetime ties: " ++ show (g^.gLifetime.gsTies)
+    , ""
+    ]

src/Mtlstats/Control/EditPlayer.hs

@@ -0,0 +1,143 @@
+{- |
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+module Mtlstats.Control.EditPlayer (editPlayerC) where
+
+import Data.Maybe (fromMaybe)
+import Lens.Micro ((^.))
+import qualified UI.NCurses as C
+
+import Mtlstats.Menu
+import Mtlstats.Prompt
+import Mtlstats.Prompt.EditPlayer
+import Mtlstats.Types
+import Mtlstats.Util
+
+-- | Dispatcher/controller for the player edit mode
+editPlayerC :: EditPlayerState -> Controller
+editPlayerC eps
+  | null $ eps^.epsSelectedPlayer = selectPlayerC
+  | otherwise = case eps^.epsMode of
+    EPMenu       -> menuC
+    EPNumber     -> numberC
+    EPName       -> nameC
+    EPPosition   -> positionC
+    EPYtdGoals   -> ytdGoalsC
+    EPYtdAssists -> ytdAssistsC
+    EPYtdPMin    -> ytdPMinC
+    EPLtGoals    -> ltGoalsC
+    EPLtAssists  -> ltAssistsC
+    EPLtPMin     -> ltPMinC
+
+selectPlayerC :: Controller
+selectPlayerC = Controller
+  { drawController   = drawPrompt playerToEditPrompt
+  , handleController = \e -> do
+    promptHandler playerToEditPrompt e
+    return True
+  }
+
+menuC :: Controller
+menuC = Controller
+  { drawController = \s -> do
+    let
+      header = fromMaybe "" $ do
+        pid <- s^.progMode.editPlayerStateL.epsSelectedPlayer
+        p   <- nth pid $ s^.database.dbPlayers
+        Just $ playerDetails p ++ "\n"
+    C.drawString header
+    drawMenu editPlayerMenu
+  , handleController = \e -> do
+    menuHandler editPlayerMenu e
+    return True
+  }
+
+numberC :: Controller
+numberC = Controller
+  { drawController = drawPrompt editPlayerNumPrompt
+  , handleController = \e -> do
+    promptHandler editPlayerNumPrompt e
+    return True
+  }
+
+nameC :: Controller
+nameC = Controller
+  { drawController   = drawPrompt editPlayerNamePrompt
+  , handleController = \e -> do
+    promptHandler editPlayerNamePrompt e
+    return True
+  }
+
+positionC :: Controller
+positionC = Controller
+  { drawController   = drawPrompt editPlayerPosPrompt
+  , handleController = \e -> do
+    promptHandler editPlayerPosPrompt e
+    return True
+  }
+
+ytdGoalsC :: Controller
+ytdGoalsC = Controller
+  { drawController   = drawPrompt editPlayerYtdGoalsPrompt
+  , handleController = \e -> do
+    promptHandler editPlayerYtdGoalsPrompt e
+    return True
+  }
+
+ytdAssistsC :: Controller
+ytdAssistsC = Controller
+  { drawController   = drawPrompt editPlayerYtdAssistsPrompt
+  , handleController = \e -> do
+    promptHandler editPlayerYtdAssistsPrompt e
+    return True
+  }
+
+ytdPMinC :: Controller
+ytdPMinC = Controller
+  { drawController   = drawPrompt editPlayerYtdPMinPrompt
+  , handleController = \e -> do
+    promptHandler editPlayerYtdPMinPrompt e
+    return True
+  }
+
+ltGoalsC :: Controller
+ltGoalsC = Controller
+  { drawController   = drawPrompt editPlayerLtGoalsPrompt
+  , handleController = \e -> do
+    promptHandler editPlayerLtGoalsPrompt e
+    return True
+  }
+
+ltAssistsC :: Controller
+ltAssistsC = Controller
+  { drawController   = drawPrompt editPlayerLtAssistsPrompt
+  , handleController = \e -> do
+    promptHandler editPlayerLtAssistsPrompt e
+    return True
+  }
+
+ltPMinC :: Controller
+ltPMinC = Controller
+  { drawController   = drawPrompt editPlayerLtPMinPrompt
+  , handleController = \e -> do
+    promptHandler editPlayerLtPMinPrompt e
+    return True
+  }

src/Mtlstats/Control/NewGame.hs

@@ -0,0 +1,283 @@
+{- |
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+module Mtlstats.Control.NewGame (newGameC) where
+
+import Control.Monad.Trans.State (gets, modify)
+import Data.Maybe (fromJust, fromMaybe, isJust)
+import Lens.Micro ((^.), (.~))
+import qualified UI.NCurses as C
+
+import Mtlstats.Actions
+import Mtlstats.Actions.NewGame
+import Mtlstats.Control.NewGame.GoalieInput
+import Mtlstats.Format
+import Mtlstats.Handlers
+import Mtlstats.Menu
+import Mtlstats.Prompt
+import Mtlstats.Prompt.NewGame
+import Mtlstats.Report
+import Mtlstats.Types
+import Mtlstats.Util
+
+-- | Dispatcher for a new game
+newGameC :: ProgState -> Controller
+newGameC s = let
+  gs = s^.progMode.gameStateL
+  in if null $ gs^.gameYear               then gameYearC
+  else if null $ gs^.gameMonth            then gameMonthC
+  else if null $ gs^.gameDay              then gameDayC
+  else if null $ gs^.gameType             then gameTypeC
+  else if null $ gs^.otherTeam            then otherTeamC
+  else if null $ gs^.homeScore            then homeScoreC
+  else if null $ gs^.awayScore            then awayScoreC
+  else if null $ gs^.overtimeFlag         then overtimeFlagC
+  else if not $ gs^.dataVerified          then verifyDataC
+  else if fromJust (unaccountedPoints gs) then goalInput gs
+  else if isJust $ gs^.gameSelectedPlayer then getPMinsC
+  else if not $ gs^.gamePMinsRecorded     then pMinPlayerC
+  else if not $ gs^.gameGoalieAssigned    then goalieInputC s
+  else reportC
+
+gameYearC :: Controller
+gameYearC = Controller
+  { drawController = \s -> do
+    header s
+    drawPrompt gameYearPrompt s
+  , handleController = \e -> do
+    promptHandler gameYearPrompt e
+    return True
+  }
+
+gameMonthC :: Controller
+gameMonthC = Controller
+  { drawController = \s -> do
+    header s
+    drawMenu gameMonthMenu
+  , handleController = \e -> do
+    menuHandler gameMonthMenu e
+    return True
+  }
+
+gameDayC :: Controller
+gameDayC = Controller
+  { drawController = \s -> do
+    header s
+    drawPrompt gameDayPrompt s
+  , handleController = \e -> do
+    promptHandler gameDayPrompt e
+    modify validateGameDate
+    return True
+  }
+
+gameTypeC :: Controller
+gameTypeC = Controller
+  { drawController = \s -> do
+    header s
+    drawMenu gameTypeMenu
+  , handleController = \e -> do
+    menuHandler gameTypeMenu e
+    return True
+  }
+
+otherTeamC :: Controller
+otherTeamC = Controller
+  { drawController = \s -> do
+    header s
+    drawPrompt otherTeamPrompt s
+  , handleController = \e -> do
+    promptHandler otherTeamPrompt e
+    return True
+  }
+
+homeScoreC :: Controller
+homeScoreC = Controller
+  { drawController = \s -> do
+    header s
+    drawPrompt homeScorePrompt s
+  , handleController = \e -> do
+    promptHandler homeScorePrompt e
+    return True
+  }
+
+awayScoreC :: Controller
+awayScoreC = Controller
+  { drawController = \s -> do
+    header s
+    drawPrompt awayScorePrompt s
+  , handleController = \e -> do
+    promptHandler awayScorePrompt e
+    modify overtimeCheck
+    return True
+  }
+
+overtimeFlagC :: Controller
+overtimeFlagC = Controller
+  { drawController = \s -> do
+    header s
+    C.drawString "Did the game go into overtime?  (Y/N)"
+    return C.CursorInvisible
+  , handleController = \e -> do
+    modify $ progMode.gameStateL.overtimeFlag .~ ynHandler e
+    return True
+  }
+
+verifyDataC :: Controller
+verifyDataC = Controller
+  { drawController = \s -> do
+    let gs = s^.progMode.gameStateL
+    header s
+    C.drawString "\n"
+    C.drawString $ "      Date: " ++ gameDate gs ++ "\n"
+    C.drawString $ " Game type: " ++ show (fromJust $ gs^.gameType) ++ "\n"
+    C.drawString $ "Other team: " ++ gs^.otherTeam ++ "\n"
+    C.drawString $ "Home score: " ++ show (fromJust $ gs^.homeScore) ++ "\n"
+    C.drawString $ "Away score: " ++ show (fromJust $ gs^.awayScore) ++ "\n"
+    C.drawString $ "  Overtime: " ++ show (fromJust $ gs^.overtimeFlag) ++ "\n\n"
+    C.drawString "Is the above information correct?  (Y/N)"
+    return C.CursorInvisible
+  , handleController = \e -> do
+    case ynHandler e of
+      Just True  -> do
+        modify $ progMode.gameStateL.dataVerified .~ True
+        modify updateGameStats
+      Just False -> modify $ progMode.gameStateL .~ newGameState
+      Nothing    -> return ()
+    return True
+  }
+
+goalInput :: GameState -> Controller
+goalInput gs
+  | null (gs^.goalBy            ) = recordGoalC
+  | not (gs^.confirmGoalDataFlag) = recordAssistC
+  | otherwise                     = confirmGoalDataC
+
+recordGoalC :: Controller
+recordGoalC = Controller
+  { drawController = \s -> let
+    (game, goal) = gameGoal s
+    in drawPrompt (recordGoalPrompt game goal) s
+  , handleController = \e -> do
+    (game, goal) <- gets gameGoal
+    promptHandler (recordGoalPrompt game goal) e
+    return True
+  }
+
+recordAssistC :: Controller
+recordAssistC = Controller
+  { drawController = \s -> let
+    (game, goal, assist) = gameGoalAssist s
+    in drawPrompt (recordAssistPrompt game goal assist) s
+  , handleController = \e -> do
+    (game, goal, assist) <- gets gameGoalAssist
+    promptHandler (recordAssistPrompt game goal assist) e
+    return True
+  }
+
+confirmGoalDataC :: Controller
+confirmGoalDataC = Controller
+  { drawController = \s -> do
+    let
+      (game, goal) = gameGoal s
+      gs           = s^.progMode.gameStateL
+      players      = s^.database.dbPlayers
+      msg          = unlines $
+        [ "          Game: " ++ padNum 2 game
+        , "          Goal: " ++ show goal
+        , "Goal scored by: " ++
+          playerSummary (fromJust $ gs^.goalBy >>= flip nth players)
+        ] ++
+        map
+          (\pid -> "   Assisted by: " ++
+            playerSummary (fromJust $ nth pid players))
+          (gs^.assistsBy) ++
+        [ ""
+        , "Is the above information correct? (Y/N)"
+        ]
+    C.drawString msg
+    return C.CursorInvisible
+  , handleController = \e -> do
+    case ynHandler e of
+      Just True  -> modify recordGoalAssists
+      Just False -> modify resetGoalData
+      Nothing    -> return ()
+    return True
+  }
+
+pMinPlayerC :: Controller
+pMinPlayerC = Controller
+  { drawController = \s -> do
+    header s
+    drawPrompt pMinPlayerPrompt s
+  , handleController = \e -> do
+    promptHandler pMinPlayerPrompt e
+    return True
+  }
+
+getPMinsC :: Controller
+getPMinsC = Controller
+  { drawController = \s -> do
+    header s
+    C.drawString $ fromMaybe "" $ do
+      pid    <- s^.progMode.gameStateL.gameSelectedPlayer
+      player <- nth pid $ s^.database.dbPlayers
+      Just $ playerSummary player ++ "\n"
+    drawPrompt assignPMinsPrompt s
+  , handleController = \e -> do
+    promptHandler assignPMinsPrompt e
+    return True
+  }
+
+reportC :: Controller
+reportC = Controller
+  { drawController = \s -> do
+    (rows, cols) <- C.windowSize
+    C.drawString $ unlines $ slice
+      (s^.scrollOffset)
+      (fromInteger $ pred rows)
+      (report (fromInteger $ pred cols) s)
+    return C.CursorInvisible
+  , handleController = \e -> do
+    case e of
+      C.EventSpecialKey C.KeyUpArrow   -> modify scrollUp
+      C.EventSpecialKey C.KeyDownArrow -> modify scrollDown
+      C.EventSpecialKey C.KeyHome      -> modify $ scrollOffset .~ 0
+      C.EventSpecialKey _              -> modify backHome
+      C.EventCharacter _               -> modify backHome
+      _                                -> return ()
+    return True
+  }
+
+header :: ProgState -> C.Update ()
+header s = C.drawString $
+  "*** GAME " ++ padNum 2 (s^.database.dbGames) ++ " ***\n"
+
+gameGoal :: ProgState -> (Int, Int)
+gameGoal s =
+  ( s^.database.dbGames
+  , succ $ s^.progMode.gameStateL.pointsAccounted
+  )
+
+gameGoalAssist :: ProgState -> (Int, Int, Int)
+gameGoalAssist s = let
+  (game, goal) = gameGoal s
+  assist       = succ $ length $ s^.progMode.gameStateL.assistsBy
+  in (game, goal, assist)

src/Mtlstats/Control/NewGame/GoalieInput.hs

@@ -0,0 +1,66 @@
+{- |
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+module Mtlstats.Control.NewGame.GoalieInput (goalieInputC) where
+
+import Data.Maybe (fromMaybe)
+import Lens.Micro ((^.))
+import qualified UI.NCurses as C
+
+import Mtlstats.Format
+import Mtlstats.Menu
+import Mtlstats.Prompt
+import Mtlstats.Prompt.NewGame.GoalieInput
+import Mtlstats.Types
+import Mtlstats.Util
+
+-- | The dispatcher for handling goalie input
+goalieInputC :: ProgState -> Controller
+goalieInputC s = let
+  gs = s^.progMode.gameStateL
+  in if gs^.gameGoaliesRecorded
+    then selectGameGoalieC s
+  else if null $ gs^.gameSelectedGoalie
+    then selectGoalieC
+  else if null $ gs^.gameGoalieMinsPlayed
+    then minsPlayedC
+  else goalsAllowedC
+
+selectGoalieC :: Controller
+selectGoalieC = promptController selectGameGoaliePrompt
+
+minsPlayedC :: Controller
+minsPlayedC = promptControllerWith header goalieMinsPlayedPrompt
+
+goalsAllowedC :: Controller
+goalsAllowedC = promptControllerWith header goalsAllowedPrompt
+
+selectGameGoalieC :: ProgState -> Controller
+selectGameGoalieC = menuController . gameGoalieMenu
+
+header :: ProgState -> C.Update ()
+header s = C.drawString $ unlines
+  [ "*** GAME " ++ padNum 2 (s^.database.dbGames) ++ " ***"
+  , fromMaybe "" $ do
+    n <- s^.progMode.gameStateL.gameSelectedGoalie
+    g <- nth n $ s^.database.dbGoalies
+    Just $ goalieSummary g
+  ]

src/Mtlstats/Menu.hs

@@ -21,19 +21,25 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 module Mtlstats.Menu (
   -- * Menu Functions
+  menuController,
+  menuControllerWith,
   drawMenu,
   menuHandler,
   -- * Menus
   mainMenu,
   newSeasonMenu,
   gameMonthMenu,
-  gameTypeMenu
+  gameTypeMenu,
+  editPlayerMenu,
+  gameGoalieMenu
 ) where
 
 import Control.Monad.IO.Class (liftIO)
 import Control.Monad.Trans.State (gets, modify)
 import Data.Aeson (encodeFile)
 import Data.Char (toUpper)
+import qualified Data.Map as M
+import Data.Maybe (mapMaybe)
 import Lens.Micro ((^.), (.~), (?~))
 import Lens.Micro.Extras (view)
 import System.EasyFile
@@ -44,9 +50,32 @@ import System.EasyFile
 import qualified UI.NCurses as C
 
 import Mtlstats.Actions
+import qualified Mtlstats.Actions.NewGame.GoalieInput as GI
 import Mtlstats.Config
 import Mtlstats.Types
 import Mtlstats.Types.Menu
+import Mtlstats.Util
+
+-- | Generates a simple 'Controller' for a Menu
+menuController :: Menu () -> Controller
+menuController = menuControllerWith $ const $ return ()
+
+-- | Generate a simple 'Controller' for a 'Menu' with a header
+menuControllerWith
+  :: (ProgState -> C.Update ())
+  -- ^ Generates the header
+  -> Menu ()
+  -- ^ The menu
+  -> Controller
+  -- ^ The resulting controller
+menuControllerWith header menu = Controller
+  { drawController = \s -> do
+    header s
+    drawMenu menu
+  , handleController = \e -> do
+    menuHandler menu e
+    return True
+  }
 
 -- | The draw function for a 'Menu'
 drawMenu :: Menu a -> C.Update C.CursorMode
@@ -71,7 +100,13 @@ mainMenu = Menu "*** MAIN MENU ***" True
     modify startNewGame >> return True
   , MenuItem '3' "Create Player" $
     modify createPlayer >> return True
-  , MenuItem '4' "Exit" $ do
+  , MenuItem '4' "Create Goalie" $
+    modify createGoalie >> return True
+  , MenuItem '5' "Edit Player" $
+    modify editPlayer >> return True
+  , MenuItem '6' "Edit Goalie" $
+    modify editGoalie >> return True
+  , MenuItem 'X' "Exit" $ do
     db <- gets $ view database
     liftIO $ do
       dir <- getAppUserDataDirectory appName
@@ -84,11 +119,13 @@ mainMenu = Menu "*** MAIN MENU ***" True
 -- | The new season menu
 newSeasonMenu :: Menu ()
 newSeasonMenu = Menu "*** SEASON TYPE ***" ()
-  [ MenuItem '1' "Regular Season" $ do
+  [ MenuItem 'R' "Regular Season" $ modify
-    modify resetYtd
+    $ resetYtd
-    modify startNewGame
+    . resetStandings
-  , MenuItem '2' "Playoffs" $
+    . startNewGame
-    modify startNewGame
+  , MenuItem 'P' "Playoffs" $ modify
+    $ resetStandings
+    . startNewGame
   ]
 
 -- | Requests the month in which the game took place
@@ -119,3 +156,36 @@ gameTypeMenu = Menu "Game type:" ()
   , MenuItem '2' "Away Game" $
     modify $ progMode.gameStateL.gameType ?~ AwayGame
   ]
+
+-- | The player edit menu
+editPlayerMenu :: Menu ()
+editPlayerMenu = Menu "*** EDIT PLAYER ***" () $ map
+  (\(ch, label, mode) -> MenuItem ch label $ case mode of
+    Nothing -> modify $ progMode .~ MainMenu
+    Just m  -> modify $ progMode.editPlayerStateL.epsMode .~ m)
+  [ ( '1', "Change number",         Just EPNumber     )
+  , ( '2', "Change name",           Just EPName       )
+  , ( '3', "Change position",       Just EPPosition   )
+  , ( '4', "YTD goals",             Just EPYtdGoals   )
+  , ( '5', "YTD assists",           Just EPYtdAssists )
+  , ( '6', "YTD penalty mins",      Just EPYtdPMin    )
+  , ( '7', "Lifetime goals",        Just EPLtGoals    )
+  , ( '8', "Lifetime assists",      Just EPLtAssists  )
+  , ( '9', "Lifetime penalty mins", Just EPLtPMin     )
+  , ( '0', "Finished editing",      Nothing           )
+  ]
+
+-- | Game goalie selection menu
+gameGoalieMenu :: ProgState -> Menu ()
+gameGoalieMenu s = let
+  title   = "Which goalie should get credit for the game?"
+  gids    = map fst $ M.toList $ s^.progMode.gameStateL.gameGoalieStats
+  goalies = mapMaybe
+    (\n -> do
+      goalie <- nth n $ s^.database.dbGoalies
+      Just (n, goalie))
+    gids
+  in Menu title () $ map
+    (\(ch, (gid, goalie)) -> MenuItem ch (goalieSummary goalie) $
+      modify $ GI.setGameGoalie gid) $
+    zip ['1'..] goalies

src/Mtlstats/Menu/EditGoalie.hs

@@ -0,0 +1,80 @@
+{- |
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+module Mtlstats.Menu.EditGoalie
+  ( editGoalieMenu
+  , editGoalieYtdMenu
+  , editGoalieLtMenu
+  ) where
+
+import Control.Monad.Trans.State (modify)
+import Data.Maybe (maybe)
+import Lens.Micro ((.~))
+
+import Mtlstats.Types
+import Mtlstats.Types.Menu
+
+-- | The 'Goalie' edit menu
+editGoalieMenu :: Menu ()
+editGoalieMenu = Menu "*** EDIT GOALTENDER ***" () $ map
+  (\(key, label, val) -> MenuItem key label $ modify $ maybe
+    (progMode .~ MainMenu)
+    (progMode.editGoalieStateL.egsMode .~)
+    val)
+  --  key, label,                 value
+  [ ( '1', "Edit number",         Just EGNumber   )
+  , ( '2', "Edit name",           Just EGName     )
+  , ( '3', "Edit YTD stats",      Just EGYtd      )
+  , ( '4', "Edit Lifetime stats", Just EGLifetime )
+  , ( 'R', "Return to Main Menu", Nothing         )
+  ]
+
+-- | The 'Goalie' YTD edit menu
+editGoalieYtdMenu :: Menu ()
+editGoalieYtdMenu = editMenu "*** EDIT GOALTENDER YEAR-TO-DATE ***"
+  --  key, label,                 value
+  [ ( '1', "Edit YTD games",      EGYtdGames  )
+  , ( '2', "Edit YTD minutes",    EGYtdMins   )
+  , ( '3', "Edit YTD goals",      EGYtdGoals  )
+  , ( '4', "Edit YTD wins",       EGYtdWins   )
+  , ( '5', "Edit YTD losses",     EGYtdLosses )
+  , ( '6', "Edit YTD ties",       EGYtdTies   )
+  , ( 'R', "Return to edit menu", EGMenu      )
+  ]
+
+-- | The 'Goalie' lifetime edit menu
+editGoalieLtMenu :: Menu ()
+editGoalieLtMenu = editMenu
+  "*** EDIT GOALTENDER LIFETIME ***"
+  --  key, label,                   value
+  [ ( '1', "Edit lifetime games",   EGLtGames  )
+  , ( '2', "Edit lifetime minutes", EGLtMins   )
+  , ( '3', "Edit lifetime goals",   EGLtGoals  )
+  , ( '4', "Edit lifetime wins",    EGLtWins   )
+  , ( '5', "Edit lifetime losses",  EGLtLosses )
+  , ( '6', "Edit lifetime ties",    EGLtTies   )
+  , ( 'R', "Return to edit menu",   EGMenu     )
+  ]
+
+editMenu :: String -> [(Char, String, EditGoalieMode)] -> Menu ()
+editMenu title = Menu title () . map
+  (\(key, label, val) -> MenuItem key label $
+    modify $ progMode.editGoalieStateL.egsMode .~ val)

src/Mtlstats/Prompt.hs

@@ -25,36 +25,34 @@ module Mtlstats.Prompt (
   -- * Prompt Functions
   drawPrompt,
   promptHandler,
+  promptControllerWith,
+  promptController,
   strPrompt,
   numPrompt,
+  selectPrompt,
   -- * Individual prompts
-  gameYearPrompt,
-  gameDayPrompt,
-  otherTeamPrompt,
-  homeScorePrompt,
-  awayScorePrompt,
   playerNumPrompt,
   playerNamePrompt,
   playerPosPrompt,
+  goalieNumPrompt,
+  goalieNamePrompt,
   selectPlayerPrompt,
-  recordGoalPrompt,
+  selectGoaliePrompt,
-  recordAssistPrompt,
+  playerToEditPrompt
-  pMinPlayerPrompt,
-  assignPMinsPrompt
 ) where
 
 import Control.Monad (when)
+import Control.Monad.Extra (whenJust)
 import Control.Monad.Trans.State (gets, modify)
 import Data.Char (isDigit, toUpper)
 import Data.Foldable (forM_)
-import Lens.Micro ((^.), (&), (.~), (?~), (%~))
+import Lens.Micro ((^.), (&), (.~), (?~))
 import Lens.Micro.Extras (view)
 import Text.Read (readMaybe)
 import qualified UI.NCurses as C
 
 import Mtlstats.Actions
 import Mtlstats.Config
-import Mtlstats.Format
 import Mtlstats.Types
 import Mtlstats.Util
 
@@ -80,6 +78,31 @@ promptHandler p (C.EventSpecialKey k) =
   promptSpecialKey p k
 promptHandler _ _ = return ()
 
+-- | Builds a controller out of a prompt with a header
+promptControllerWith
+  :: (ProgState -> C.Update ())
+  -- ^ The header
+  -> Prompt
+  -- ^ The prompt to use
+  -> Controller
+  -- ^ The resulting controller
+promptControllerWith header prompt = Controller
+  { drawController = \s -> do
+    header s
+    drawPrompt prompt s
+  , handleController = \e -> do
+    promptHandler prompt e
+    return True
+  }
+
+-- | Builds a controller out of a prompt
+promptController
+  :: Prompt
+  -- ^ The prompt to use
+  -> Controller
+  -- ^ The resulting controller
+promptController = promptControllerWith (const $ return ())
+
 -- | Builds a string prompt
 strPrompt
   :: String
@@ -108,30 +131,42 @@ numPrompt pStr act = Prompt
   , promptSpecialKey = const $ return ()
   }
 
--- | Prompts for the game year
+-- | Builds a selection prompt
-gameYearPrompt :: Prompt
+selectPrompt :: SelectParams a -> Prompt
-gameYearPrompt = numPrompt "Game year: " $
+selectPrompt params = Prompt
-  modify . (progMode.gameStateL.gameYear ?~)
+  { promptDrawer = \s -> do
-
+    let sStr = s^.inputBuffer
--- | Prompts for the day of the month the game took place
+    C.drawString $ spPrompt params ++ sStr
-gameDayPrompt :: Prompt
+    (row, col) <- C.cursorPosition
-gameDayPrompt = numPrompt "Day of month: " $
+    C.drawString $ "\n\n" ++ spSearchHeader params ++ "\n"
-  modify . (progMode.gameStateL.gameDay ?~)
+    let results = zip [1..maxFunKeys] $ spSearch params sStr (s^.database)
-
+    C.drawString $ unlines $ map
--- | Prompts for the other team name
+      (\(n, (_, x)) -> let
-otherTeamPrompt :: Prompt
+        desc = spElemDesc params x
-otherTeamPrompt = strPrompt "Other team: " $
+        in "F" ++ show n ++ ") " ++ desc)
-  modify . (progMode.gameStateL.otherTeam .~)
+      results
-
+    C.moveCursor row col
--- | Prompts for the home score
+  , promptCharCheck = const True
-homeScorePrompt :: Prompt
+  , promptAction = \sStr -> if null sStr
-homeScorePrompt = numPrompt "Home score: " $
+    then spCallback params Nothing
-  modify . (progMode.gameStateL.homeScore ?~)
+    else do
-
+      db <- gets (^.database)
--- | Prompts for the away score
+      case spSearchExact params sStr db of
-awayScorePrompt :: Prompt
+        Nothing -> spNotFound params sStr
-awayScorePrompt = numPrompt "Away score: " $
+        Just n  -> spCallback params $ Just n
-  modify . (progMode.gameStateL.awayScore ?~)
+  , promptSpecialKey = \case
+    C.KeyFunction rawK -> do
+      sStr <- gets (^.inputBuffer)
+      db   <- gets (^.database)
+      let
+        n       = pred $ fromInteger rawK
+        results = spSearch params sStr db
+      when (n < maxFunKeys) $
+        whenJust (nth n results) $ \(sel, _) -> do
+          modify $ inputBuffer .~ ""
+          spCallback params $ Just sel
+    _ -> return ()
+  }
 
 -- | Prompts for a new player's number
 playerNumPrompt :: Prompt
@@ -148,6 +183,16 @@ playerPosPrompt :: Prompt
 playerPosPrompt = strPrompt "Player position: " $
   modify . (progMode.createPlayerStateL.cpsPosition .~)
 
+-- | Prompts tor the goalie's number
+goalieNumPrompt :: Prompt
+goalieNumPrompt = numPrompt "Goalie number: " $
+  modify . (progMode.createGoalieStateL.cgsNumber ?~)
+
+-- | Prompts for the goalie's name
+goalieNamePrompt :: Prompt
+goalieNamePrompt = strPrompt "Goalie name: " $
+  modify . (progMode.createGoalieStateL.cgsName .~)
+
 -- | Selects a player (creating one if necessary)
 selectPlayerPrompt
   :: String
@@ -156,96 +201,57 @@ selectPlayerPrompt
   -- ^ The callback to run (takes the index number of the payer as
   -- input)
   -> Prompt
-selectPlayerPrompt pStr callback = Prompt
+selectPlayerPrompt pStr callback = selectPrompt SelectParams
-  { promptDrawer = \s -> do
+  { spPrompt       = pStr
-    let sStr = s^.inputBuffer
+  , spSearchHeader = "Player select:"
-    C.drawString pStr
+  , spSearch       = \sStr db -> playerSearch sStr (db^.dbPlayers)
-    C.drawString sStr
+  , spSearchExact  = \sStr db -> fst <$> playerSearchExact sStr (db^.dbPlayers)
-    (row, col) <- C.cursorPosition
+  , spElemDesc     = playerSummary
-    C.drawString "\n\nPlayer select:\n"
+  , spCallback     = callback
-    let sel = zip [1..maxFunKeys] $ playerSearch sStr $ s^.database.dbPlayers
+  , spNotFound     = \sStr -> do
-    mapM_
+    mode <- gets (^.progMode)
-      (\(n, (_, p)) -> C.drawString $
+    let
-        "F" ++ show n ++ ") " ++ p^.pName ++ " (" ++ show (p^.pNumber) ++ ")\n")
+      cps = newCreatePlayerState
-      sel
+        & cpsName .~ sStr
-    C.moveCursor row col
+        & cpsSuccessCallback .~ do
-  , promptCharCheck = const True
+          modify $ progMode .~ mode
-  , promptAction = \sStr -> if null sStr
+          index <- pred . length <$> gets (^.database.dbPlayers)
-    then callback Nothing
+          callback $ Just index
-    else do
+        & cpsFailureCallback .~ modify (progMode .~ mode)
-      players <- gets $ view $ database.dbPlayers
+    modify $ progMode .~ CreatePlayer cps
-      case playerSearchExact sStr players of
-        Just (n, _) -> callback $ Just n
-        Nothing -> do
-          mode <- gets $ view progMode
-          let
-            cps
-              = newCreatePlayerState
-              & cpsName .~ sStr
-              & cpsSuccessCallback .~ do
-                modify $ progMode .~ mode
-                pIndex <- pred . length <$> gets (view $ database.dbPlayers)
-                callback $ Just pIndex
-              & cpsFailureCallback .~ do
-                modify $ progMode .~ mode
-                callback Nothing
-          modify $ progMode .~ CreatePlayer cps
-  , promptSpecialKey = \case
-    C.KeyFunction n -> do
-      sStr    <- gets $ view inputBuffer
-      players <- gets $ view $ database.dbPlayers
-      modify $ inputBuffer .~ ""
-      let
-        fKey    = pred $ fromIntegral n
-        options = playerSearch sStr players
-        sel     = fst <$> nth fKey options
-      callback sel
-    _ -> return ()
   }
 
--- | Prompts for the player who scored the goal
+-- | Selects a goalie (creating one if necessary)
-recordGoalPrompt
+selectGoaliePrompt
-  :: Int
+  :: String
-  -- ^ The game number
+  -- ^ The prompt string
-  -> Int
+  -> (Maybe Int -> Action ())
-  -- ^ The goal number
+  -- ^ The callback to run (takes the index number of the goalie as
+  -- input)
   -> Prompt
-recordGoalPrompt game goal = selectPlayerPrompt
+selectGoaliePrompt pStr callback = selectPrompt SelectParams
-  (  "*** GAME " ++ padNum 2 game ++ " ***\n"
+  { spPrompt       = pStr
-  ++ "Who scored goal number " ++ show goal ++ "? "
+  , spSearchHeader = "Goalie select:"
-  ) $ modify . (progMode.gameStateL.goalBy .~)
+  , spSearch       = \sStr db -> goalieSearch sStr (db^.dbGoalies)
+  , spSearchExact  = \sStr db -> fst <$> goalieSearchExact sStr (db^.dbGoalies)
+  , spElemDesc     = goalieSummary
+  , spCallback     = callback
+  , spNotFound     = \sStr -> do
+    mode <- gets (^.progMode)
+    let
+      cgs = newCreateGoalieState
+        & cgsName .~ sStr
+        & cgsSuccessCallback .~ do
+          modify $ progMode .~ mode
+          index <- pred . length <$> gets (^.database.dbGoalies)
+          callback $ Just index
+        & cgsFailureCallback .~ modify (progMode .~ mode)
+    modify $ progMode .~ CreateGoalie cgs
+  }
 
--- | Prompts for a player who assisted the goal
+playerToEditPrompt :: Prompt
-recordAssistPrompt
+playerToEditPrompt = selectPlayerPrompt "Player to edit: " $
-  :: Int
+  modify . (progMode.editPlayerStateL.epsSelectedPlayer .~)
-  -- ^ The game number
-  -> Int
-  -- ^ The goal nuber
-  -> Int
-  -- ^ The assist number
-  -> Prompt
-recordAssistPrompt game goal assist = selectPlayerPrompt
-  (  "*** GAME " ++ padNum 2 game ++ " ***\n"
-  ++ "Goal: " ++ show goal ++ "\n"
-  ++ "Assist #" ++ show assist ++ ": "
-  ) $ \case
-    Nothing -> modify $ progMode.gameStateL.confirmGoalDataFlag .~ True
-    Just n  -> do
-      modify $ progMode.gameStateL.assistsBy %~ (++[n])
-      nAssists <- length <$> gets (view $ progMode.gameStateL.assistsBy)
-      when (nAssists >= maxAssists) $
-        modify $ progMode.gameStateL.confirmGoalDataFlag .~ True
-
-pMinPlayerPrompt :: Prompt
-pMinPlayerPrompt = selectPlayerPrompt
-  "Assign penalty minutes to: " $
-  \case
-    Nothing -> modify $ progMode.gameStateL.pMinsRecorded .~ True
-    Just n  -> modify $ progMode.gameStateL.selectedPlayer ?~ n
-
-assignPMinsPrompt :: Prompt
-assignPMinsPrompt = numPrompt "Penalty minutes: " $
-  modify . assignPMins
 
 drawSimplePrompt :: String -> ProgState -> C.Update ()
 drawSimplePrompt pStr s = C.drawString $ pStr ++ s^.inputBuffer

src/Mtlstats/Prompt/EditGoalie.hs

@@ -0,0 +1,120 @@
+{- |
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+module Mtlstats.Prompt.EditGoalie
+  ( goalieToEditPrompt
+  , editGoalieNumberPrompt
+  , editGoalieNamePrompt
+  , editGoalieYtdGamesPrompt
+  , editGoalieYtdMinsPrompt
+  , editGoalieYtdGoalsPrompt
+  , editGoalieYtdWinsPrompt
+  , editGoalieYtdLossesPrompt
+  , editGoalieYtdTiesPrompt
+  , editGoalieLtGamesPrompt
+  , editGoalieLtMinsPrompt
+  , editGoalieLtGoalsPrompt
+  , editGoalieLtWinsPrompt
+  , editGoalieLtLossesPrompt
+  , editGoalieLtTiesPrompt
+  ) where
+
+import Control.Monad.Trans.State (modify)
+import Lens.Micro ((.~))
+
+import Mtlstats.Actions.EditGoalie
+import Mtlstats.Prompt
+import Mtlstats.Types
+
+-- | Prompt to select a 'Goalie' for editing
+goalieToEditPrompt :: Prompt
+goalieToEditPrompt = selectGoaliePrompt "Goalie to edit: " $
+  modify . (progMode.editGoalieStateL.egsSelectedGoalie .~)
+
+-- | Prompt to edit a goalie's number
+editGoalieNumberPrompt :: Prompt
+editGoalieNumberPrompt = numPrompt "Goalie number: " $
+  modify . editGoalieNumber
+
+-- | Prompt to edit a goalie's name
+editGoalieNamePrompt :: Prompt
+editGoalieNamePrompt = strPrompt "Goalie name: " $
+  modify . editGoalieName
+
+-- | Prompt to edit a goalie's YTD games played
+editGoalieYtdGamesPrompt :: Prompt
+editGoalieYtdGamesPrompt = numPrompt "Year-to-date games played: " $
+  modify . editGoalieYtdGames
+
+-- | Prompt to edit a goalie's YTD minutes played
+editGoalieYtdMinsPrompt :: Prompt
+editGoalieYtdMinsPrompt = numPrompt "Year-to-date minutes played: " $
+  modify . editGoalieYtdMins
+
+-- | Prompt to edit a goalie's YTD goales allowed
+editGoalieYtdGoalsPrompt :: Prompt
+editGoalieYtdGoalsPrompt = numPrompt "Year-to-date goals allowed: " $
+  modify . editGoalieYtdGoals
+
+-- | Prompt to edit a goalie's YTD wins
+editGoalieYtdWinsPrompt :: Prompt
+editGoalieYtdWinsPrompt = numPrompt "Year-to-date wins: " $
+  modify . editGoalieYtdWins
+
+-- | Prompt to edit a goalie's YTD losses
+editGoalieYtdLossesPrompt :: Prompt
+editGoalieYtdLossesPrompt = numPrompt "Year-to-date losses: " $
+  modify . editGoalieYtdLosses
+
+-- | Prompt to edit a goalie's YTD ties
+editGoalieYtdTiesPrompt :: Prompt
+editGoalieYtdTiesPrompt = numPrompt "Year-to-date ties: " $
+  modify . editGoalieYtdTies
+
+-- | Prompt to edit a goalie's lifetime games played
+editGoalieLtGamesPrompt :: Prompt
+editGoalieLtGamesPrompt = numPrompt "Lifetime games played: " $
+  modify . editGoalieLtGames
+
+-- | Prompt to edit a goalie's lifetime minutes played
+editGoalieLtMinsPrompt :: Prompt
+editGoalieLtMinsPrompt = numPrompt "Lifetime minutes played: " $
+  modify . editGoalieLtMins
+
+-- | Prompt to edit a goalie's lifetime goals allowed
+editGoalieLtGoalsPrompt :: Prompt
+editGoalieLtGoalsPrompt = numPrompt "Lifetime goals allowed: " $
+  modify . editGoalieLtGoals
+
+-- | Prompt to edit a goalie's lifetime wins
+editGoalieLtWinsPrompt :: Prompt
+editGoalieLtWinsPrompt = numPrompt "Lifetime wins: " $
+  modify . editGoalieLtWins
+
+-- | Prompt to edit a goalie's lifetime losses
+editGoalieLtLossesPrompt :: Prompt
+editGoalieLtLossesPrompt = numPrompt "Lifetime losses: " $
+  modify . editGoalieLtLosses
+
+-- | Prompt to edit a goalie's lifetime ties
+editGoalieLtTiesPrompt :: Prompt
+editGoalieLtTiesPrompt = numPrompt "Lifetime ties: " $
+  modify . editGoalieLtTies

src/Mtlstats/Prompt/EditPlayer.hs

@@ -0,0 +1,92 @@
+{- |
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+module Mtlstats.Prompt.EditPlayer
+  ( editPlayerNumPrompt
+  , editPlayerNamePrompt
+  , editPlayerPosPrompt
+  , editPlayerYtdGoalsPrompt
+  , editPlayerYtdAssistsPrompt
+  , editPlayerYtdPMinPrompt
+  , editPlayerLtGoalsPrompt
+  , editPlayerLtAssistsPrompt
+  , editPlayerLtPMinPrompt
+  ) where
+
+import Control.Monad.Extra (whenJustM)
+import Control.Monad.Trans.State (gets, modify)
+import Lens.Micro ((^.), (.~), (%~))
+
+import Mtlstats.Prompt
+import Mtlstats.Types
+import Mtlstats.Util
+
+-- | Prompt to edit a player's number
+editPlayerNumPrompt :: Prompt
+editPlayerNumPrompt = numPrompt "Player number: " $
+  editPlayer . (pNumber .~)
+
+-- | Prompt to edit a player's name
+editPlayerNamePrompt :: Prompt
+editPlayerNamePrompt = strPrompt "Player name: " $
+  editPlayer . (pName .~)
+
+-- | Prompt to edit a player's position
+editPlayerPosPrompt :: Prompt
+editPlayerPosPrompt = strPrompt "Player position: " $
+  editPlayer . (pPosition .~)
+
+-- | Prompt to edit a player's year-to-date goals
+editPlayerYtdGoalsPrompt :: Prompt
+editPlayerYtdGoalsPrompt = numPrompt "Year-to-date goals: " $
+  editPlayer . (pYtd.psGoals .~)
+
+-- | Prompt to edit a player's year-to-date assists
+editPlayerYtdAssistsPrompt :: Prompt
+editPlayerYtdAssistsPrompt = numPrompt "Year-to-date assists: " $
+  editPlayer . (pYtd.psAssists .~)
+
+-- | Prompt to edit a player's year-to-date penalty minutes
+editPlayerYtdPMinPrompt :: Prompt
+editPlayerYtdPMinPrompt = numPrompt "Year-to-date penalty minutes: " $
+  editPlayer . (pYtd.psPMin .~)
+
+-- | Prompt to edit a player's lifetime goals
+editPlayerLtGoalsPrompt :: Prompt
+editPlayerLtGoalsPrompt = numPrompt "Lifetime goals: " $
+  editPlayer . (pLifetime.psGoals .~)
+
+-- | Prompt to edit a player's lifetime assists
+editPlayerLtAssistsPrompt :: Prompt
+editPlayerLtAssistsPrompt = numPrompt "Lifetime assists: " $
+  editPlayer . (pLifetime.psAssists .~)
+
+-- | Prompt to edit a player's lifetime penalty minutes
+editPlayerLtPMinPrompt :: Prompt
+editPlayerLtPMinPrompt = numPrompt "Lifetime penalty minutes: " $
+  editPlayer . (pLifetime.psPMin .~)
+
+editPlayer :: (Player -> Player) -> Action ()
+editPlayer f =
+  whenJustM (gets (^.progMode.editPlayerStateL.epsSelectedPlayer)) $ \pid ->
+    modify
+      $ (database.dbPlayers %~ modifyNth pid f)
+      . (progMode.editPlayerStateL.epsMode .~ EPMenu)

src/Mtlstats/Prompt/NewGame.hs

@@ -0,0 +1,115 @@
+{- |
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+{-# LANGUAGE LambdaCase #-}
+
+module Mtlstats.Prompt.NewGame
+  ( gameYearPrompt
+  , gameDayPrompt
+  , otherTeamPrompt
+  , homeScorePrompt
+  , awayScorePrompt
+  , recordGoalPrompt
+  , recordAssistPrompt
+  , pMinPlayerPrompt
+  , assignPMinsPrompt
+  ) where
+
+import Control.Monad (when)
+import Control.Monad.Trans.State (gets, modify)
+import Lens.Micro ((^.), (.~), (?~), (%~))
+
+import Mtlstats.Actions.NewGame
+import Mtlstats.Config
+import Mtlstats.Format
+import Mtlstats.Prompt
+import Mtlstats.Types
+
+-- | Prompts for the game year
+gameYearPrompt :: Prompt
+gameYearPrompt = numPrompt "Game year: " $
+  modify . (progMode.gameStateL.gameYear ?~)
+
+-- | Prompts for the day of the month the game took place
+gameDayPrompt :: Prompt
+gameDayPrompt = numPrompt "Day of month: " $
+  modify . (progMode.gameStateL.gameDay ?~)
+
+-- | Prompts for the other team name
+otherTeamPrompt :: Prompt
+otherTeamPrompt = strPrompt "Other team: " $
+  modify . (progMode.gameStateL.otherTeam .~)
+
+-- | Prompts for the home score
+homeScorePrompt :: Prompt
+homeScorePrompt = numPrompt "Home score: " $
+  modify . (progMode.gameStateL.homeScore ?~)
+
+-- | Prompts for the away score
+awayScorePrompt :: Prompt
+awayScorePrompt = numPrompt "Away score: " $
+  modify . (progMode.gameStateL.awayScore ?~)
+
+-- | Prompts for the player who scored the goal
+recordGoalPrompt
+  :: Int
+  -- ^ The game number
+  -> Int
+  -- ^ The goal number
+  -> Prompt
+recordGoalPrompt game goal = selectPlayerPrompt
+  (  "*** GAME " ++ padNum 2 game ++ " ***\n"
+  ++ "Who scored goal number " ++ show goal ++ "? "
+  ) $ modify . (progMode.gameStateL.goalBy .~)
+
+-- | Prompts for a player who assisted the goal
+recordAssistPrompt
+  :: Int
+  -- ^ The game number
+  -> Int
+  -- ^ The goal nuber
+  -> Int
+  -- ^ The assist number
+  -> Prompt
+recordAssistPrompt game goal assist = selectPlayerPrompt
+  (  "*** GAME " ++ padNum 2 game ++ " ***\n"
+  ++ "Goal: " ++ show goal ++ "\n"
+  ++ "Assist #" ++ show assist ++ ": "
+  ) $ \case
+    Nothing -> modify $ progMode.gameStateL.confirmGoalDataFlag .~ True
+    Just n  -> do
+      modify $ progMode.gameStateL.assistsBy %~ (++[n])
+      nAssists <- length <$> gets (^.progMode.gameStateL.assistsBy)
+      when (nAssists >= maxAssists) $
+        modify $ progMode.gameStateL.confirmGoalDataFlag .~ True
+
+-- | Prompts for the player to assign penalty minutes to
+pMinPlayerPrompt :: Prompt
+pMinPlayerPrompt = selectPlayerPrompt
+  "Assign penalty minutes to: " $
+  \case
+    Nothing -> modify $ progMode.gameStateL.gamePMinsRecorded  .~ True
+    Just n  -> modify $ progMode.gameStateL.gameSelectedPlayer ?~ n
+
+-- | Prompts for the number of penalty mintues to assign to the player
+assignPMinsPrompt :: Prompt
+assignPMinsPrompt = numPrompt "Penalty minutes: " $
+  modify . assignPMins

src/Mtlstats/Prompt/NewGame/GoalieInput.hs

@@ -0,0 +1,53 @@
+{- |
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+{-# LANGUAGE LambdaCase #-}
+
+module Mtlstats.Prompt.NewGame.GoalieInput
+  ( selectGameGoaliePrompt
+  , goalieMinsPlayedPrompt
+  , goalsAllowedPrompt
+  ) where
+
+import Control.Monad.Trans.State (modify)
+import Lens.Micro ((?~))
+
+import Mtlstats.Actions.NewGame.GoalieInput
+import Mtlstats.Prompt
+import Mtlstats.Types
+
+-- | Prompts for a goalie who played in the game
+selectGameGoaliePrompt :: Prompt
+selectGameGoaliePrompt = selectGoaliePrompt "Which goalie played this game: " $
+  \case
+    Nothing -> modify finishGoalieEntry
+    Just n  -> modify $ progMode.gameStateL.gameSelectedGoalie  ?~ n
+
+-- | Prompts for the number of minutes the goalie has played
+goalieMinsPlayedPrompt :: Prompt
+goalieMinsPlayedPrompt = numPrompt "Minutes played: " $
+  modify . (progMode.gameStateL.gameGoalieMinsPlayed ?~)
+
+-- | Prompts for the number of goals the goalie allowed
+goalsAllowedPrompt :: Prompt
+goalsAllowedPrompt = numPrompt "Goals allowed: " $ \n -> do
+  modify (progMode.gameStateL.gameGoalsAllowed ?~ n)
+  modify recordGoalieStats

src/Mtlstats/Report.hs

@@ -43,6 +43,8 @@ report width s
   ++ gameStatsReport width s
   ++ [""]
   ++ yearToDateStatsReport width s
+  ++ [""]
+  ++ lifetimeStatsReport width s
 
 standingsReport :: Int -> ProgState -> [String]
 standingsReport width s = fromMaybe [] $ do
@@ -103,12 +105,16 @@ yearToDateStatsReport width s = playerReport width "YEAR TO DATE" $
   map (\p -> (p, p^.pYtd)) $
   filter playerIsActive $ s^.database.dbPlayers
 
+lifetimeStatsReport :: Int -> ProgState -> [String]
+lifetimeStatsReport width s = playerReport width "LIFETIME" $
+  map (\p -> (p, p^.pLifetime)) $ s^.database.dbPlayers
+
 gameDate :: GameState -> String
 gameDate gs = fromMaybe "" $ do
-  year  <- show <$> gs^.gameYear
+  y <- show <$> gs^.gameYear
-  month <- month <$> gs^.gameMonth
+  m <- month <$> gs^.gameMonth
-  day   <- padNum 2 <$> gs^.gameDay
+  d <- padNum 2 <$> gs^.gameDay
-  Just $ month ++ " " ++ day ++ " " ++ year
+  Just $ m ++ " " ++ d ++ " " ++ y
 
 playerReport :: Int -> String -> [(Player, PlayerStats)] -> [String]
 playerReport width label ps = let

src/Mtlstats/Types.hs

@@ -30,6 +30,11 @@ module Mtlstats.Types (
   GameState (..),
   GameType (..),
   CreatePlayerState (..),
+  CreateGoalieState (..),
+  EditPlayerState (..),
+  EditPlayerMode (..),
+  EditGoalieState (..),
+  EditGoalieMode (..),
   Database (..),
   Player (..),
   PlayerStats (..),
@@ -37,6 +42,7 @@ module Mtlstats.Types (
   GoalieStats (..),
   GameStats (..),
   Prompt (..),
+  SelectParams (..),
   -- * Lenses
   -- ** ProgState Lenses
   database,
@@ -46,6 +52,9 @@ module Mtlstats.Types (
   -- ** ProgMode Lenses
   gameStateL,
   createPlayerStateL,
+  createGoalieStateL,
+  editPlayerStateL,
+  editGoalieStateL,
   -- ** GameState Lenses
   gameYear,
   gameMonth,
@@ -61,14 +70,31 @@ module Mtlstats.Types (
   assistsBy,
   gamePlayerStats,
   confirmGoalDataFlag,
-  selectedPlayer,
+  gameSelectedPlayer,
-  pMinsRecorded,
+  gamePMinsRecorded,
+  gameGoalieStats,
+  gameSelectedGoalie,
+  gameGoalieMinsPlayed,
+  gameGoalsAllowed,
+  gameGoaliesRecorded,
+  gameGoalieAssigned,
   -- ** CreatePlayerState Lenses
   cpsNumber,
   cpsName,
   cpsPosition,
   cpsSuccessCallback,
   cpsFailureCallback,
+  -- ** CreateGoalieState Lenses
+  cgsNumber,
+  cgsName,
+  cgsSuccessCallback,
+  cgsFailureCallback,
+  -- ** EditPlayerState Lenses
+  epsSelectedPlayer,
+  epsMode,
+  -- ** EditGoalieState Lenses
+  egsSelectedGoalie,
+  egsMode,
   -- ** Database Lenses
   dbPlayers,
   dbGoalies,
@@ -94,7 +120,6 @@ module Mtlstats.Types (
   gsGames,
   gsMinsPlayed,
   gsGoalsAllowed,
-  gsGoalsAgainst,
   gsWins,
   gsLosses,
   gsTies,
@@ -108,6 +133,9 @@ module Mtlstats.Types (
   newProgState,
   newGameState,
   newCreatePlayerState,
+  newCreateGoalieState,
+  newEditPlayerState,
+  newEditGoalieState,
   newDatabase,
   newPlayer,
   newPlayerStats,
@@ -133,10 +161,15 @@ module Mtlstats.Types (
   playerSearchExact,
   modifyPlayer,
   playerSummary,
+  playerDetails,
   playerIsActive,
   -- ** PlayerStats Helpers
   psPoints,
-  addPlayerStats
+  addPlayerStats,
+  -- ** Goalie Helpers
+  goalieSearch,
+  goalieSearchExact,
+  goalieSummary
 ) where
 
 import Control.Monad.Trans.State (StateT)
@@ -190,12 +223,18 @@ data ProgMode
   | NewSeason
   | NewGame GameState
   | CreatePlayer CreatePlayerState
+  | CreateGoalie CreateGoalieState
+  | EditPlayer EditPlayerState
+  | EditGoalie EditGoalieState
 
 instance Show ProgMode where
   show MainMenu         = "MainMenu"
   show NewSeason        = "NewSeason"
   show (NewGame _)      = "NewGame"
   show (CreatePlayer _) = "CreatePlayer"
+  show (CreateGoalie _) = "CreateGoalie"
+  show (EditPlayer _)   = "EditPlayer"
+  show (EditGoalie _)   = "EditGoalie"
 
 -- | The game state
 data GameState = GameState
@@ -222,17 +261,32 @@ data GameState = GameState
   , _goalBy              :: Maybe Int
   -- ^ The index number of the player who scored the most recently
   -- entered goal
-  , _assistsBy           :: [Int]
+  , _assistsBy            :: [Int]
   -- ^ The index numbers of the players who have assisted the most
   -- recently entered goal
-  , _gamePlayerStats     :: M.Map Int PlayerStats
+  , _gamePlayerStats      :: M.Map Int PlayerStats
   -- ^ The player stats accumulated over the game
-  , _confirmGoalDataFlag :: Bool
+  , _confirmGoalDataFlag  :: Bool
   -- ^ Set when the user confirms the goal data
-  , _selectedPlayer      :: Maybe Int
+  , _gameSelectedPlayer   :: Maybe Int
   -- ^ Index number of the selected 'Player'
-  , _pMinsRecorded       :: Bool
+  , _gamePMinsRecorded    :: Bool
   -- ^ Set when the penalty mintes have been recorded
+  , _gameGoalieStats      :: M.Map Int GoalieStats
+  -- ^ The goalie stats accumulated over the game
+  , _gameSelectedGoalie   :: Maybe Int
+  -- ^ Index number of the selected 'Goalie'
+  , _gameGoalieMinsPlayed :: Maybe Int
+  -- ^ The number of minutes the currently selected goalie played in
+  -- the game
+  , _gameGoalsAllowed     :: Maybe Int
+  -- ^ The number of goals the currently selected goalie allowed in
+  -- the game
+  , _gameGoaliesRecorded  :: Bool
+  -- ^ Set when the user confirms that all goalie info has been entered
+  , _gameGoalieAssigned   :: Bool
+  -- ^ Set to 'True' when the goalie has been selected who will be
+  -- given the win/loss/tie
   } deriving (Eq, Show)
 
 -- | The type of game
@@ -255,6 +309,68 @@ data CreatePlayerState = CreatePlayerState
   -- ^ The function to call on failure
   }
 
+-- | Goalie creation status
+data CreateGoalieState = CreateGoalieState
+  { _cgsNumber    :: Maybe Int
+  -- ^ The goalie's number
+  , _cgsName      :: String
+  -- ^ The goalie's name
+  , _cgsSuccessCallback :: Action ()
+  -- ^ The function to call on success
+  , _cgsFailureCallback :: Action ()
+  -- ^ The function to call on failure
+  }
+
+-- | Player edit status
+data EditPlayerState = EditPlayerState
+  { _epsSelectedPlayer :: Maybe Int
+  -- ^ The index number of the player being edited
+  , _epsMode           :: EditPlayerMode
+  -- ^ The editing mode
+  }
+
+-- | Player editing mode
+data EditPlayerMode
+  = EPMenu
+  | EPNumber
+  | EPName
+  | EPPosition
+  | EPYtdGoals
+  | EPYtdAssists
+  | EPYtdPMin
+  | EPLtGoals
+  | EPLtAssists
+  | EPLtPMin
+  deriving (Eq, Show)
+
+-- | 'Goalie' edit status
+data EditGoalieState = EditGoalieState
+  { _egsSelectedGoalie :: Maybe Int
+  -- ^ The index number of the 'Goalie' being edited
+  , _egsMode           :: EditGoalieMode
+  }
+
+-- | 'Goalie' editing mode
+data EditGoalieMode
+  = EGMenu
+  | EGNumber
+  | EGName
+  | EGYtd
+  | EGLifetime
+  | EGYtdGames
+  | EGYtdMins
+  | EGYtdGoals
+  | EGYtdWins
+  | EGYtdLosses
+  | EGYtdTies
+  | EGLtGames
+  | EGLtMins
+  | EGLtGoals
+  | EGLtWins
+  | EGLtLosses
+  | EGLtTies
+  deriving (Eq, Show)
+
 -- | Represents the database
 data Database = Database
   { _dbPlayers       :: [Player]
@@ -396,8 +512,6 @@ data GoalieStats = GoalieStats
   -- ^ The number of minutes played
   , _gsGoalsAllowed :: Int
   -- ^ The number of goals allowed
-  , _gsGoalsAgainst :: Int
-  -- ^ The number of goals against
   , _gsWins         :: Int
   -- ^ The number of wins
   , _gsLosses       :: Int
@@ -411,28 +525,25 @@ instance FromJSON GoalieStats where
     <$> v .: "games"
     <*> v .: "mins_played"
     <*> v .: "goals_allowed"
-    <*> v .: "goals_against"
     <*> v .: "wins"
     <*> v .: "losses"
     <*> v .: "ties"
 
 instance ToJSON GoalieStats where
-  toJSON (GoalieStats g m al ag w l t) = object
+  toJSON (GoalieStats g m a w l t) = object
     [ "games"         .= g
     , "mins_played"   .= m
-    , "goals_allowed" .= al
+    , "goals_allowed" .= a
-    , "goals_against" .= ag
     , "wins"          .= w
     , "losses"        .= l
     , "ties"          .= t
     ]
-  toEncoding (GoalieStats g m al ag w l t) = pairs $
+  toEncoding (GoalieStats g m a w l t) = pairs $
-      "games"         .= g  <>
+      "games"         .= g <>
-      "mins_played"   .= m  <>
+      "mins_played"   .= m <>
-      "goals_allowed" .= al <>
+      "goals_allowed" .= a <>
-      "goals_against" .= ag <>
+      "wins"          .= w <>
-      "wins"          .= w  <>
+      "losses"        .= l <>
-      "losses"        .= l  <>
       "ties"          .= t
 
 -- | Game statistics
@@ -475,7 +586,7 @@ instance ToJSON GameStats where
 -- | Defines a user prompt
 data Prompt = Prompt
   { promptDrawer     :: ProgState -> C.Update ()
-  -- ^ Draws the prompt to thr screen
+  -- ^ Draws the prompt to the screen
   , promptCharCheck  :: Char -> Bool
   -- ^ Determines whether or not the character is valid
   , promptAction     :: String -> Action ()
@@ -484,9 +595,30 @@ data Prompt = Prompt
   -- ^ Action to perform when a special key is pressed
   }
 
+-- | Parameters for a search prompt
+data SelectParams a = SelectParams
+  { spPrompt       :: String
+  -- ^ The search prompt
+  , spSearchHeader :: String
+  -- ^ The header to display at the top of the search list
+  , spSearch       :: String -> Database -> [(Int, a)]
+  -- ^ The search function
+  , spSearchExact  :: String -> Database -> Maybe Int
+  -- ^ Search function looking for an exact match
+  , spElemDesc     :: a -> String
+  -- ^ Provides a string description of an element
+  , spCallback     :: Maybe Int -> Action ()
+  -- ^ The function when the selection is made
+  , spNotFound     :: String -> Action ()
+  -- ^ The function to call when the selection doesn't exist
+  }
+
 makeLenses ''ProgState
 makeLenses ''GameState
 makeLenses ''CreatePlayerState
+makeLenses ''CreateGoalieState
+makeLenses ''EditPlayerState
+makeLenses ''EditGoalieState
 makeLenses ''Database
 makeLenses ''Player
 makeLenses ''PlayerStats
@@ -508,6 +640,27 @@ createPlayerStateL = lens
     _                -> newCreatePlayerState)
   (\_ cps -> CreatePlayer cps)
 
+createGoalieStateL :: Lens' ProgMode CreateGoalieState
+createGoalieStateL = lens
+  (\case
+    CreateGoalie cgs -> cgs
+    _                -> newCreateGoalieState)
+  (\_ cgs -> CreateGoalie cgs)
+
+editPlayerStateL :: Lens' ProgMode EditPlayerState
+editPlayerStateL = lens
+  (\case
+    EditPlayer eps -> eps
+    _              -> newEditPlayerState)
+  (\_ eps -> EditPlayer eps)
+
+editGoalieStateL :: Lens' ProgMode EditGoalieState
+editGoalieStateL = lens
+  (\case
+    EditGoalie egs -> egs
+    _              -> newEditGoalieState)
+  (\_ egs -> EditGoalie egs)
+
 -- | Constructor for a 'ProgState'
 newProgState :: ProgState
 newProgState = ProgState
@@ -520,22 +673,28 @@ newProgState = ProgState
 -- | Constructor for a 'GameState'
 newGameState :: GameState
 newGameState = GameState
-  { _gameYear            = Nothing
+  { _gameYear             = Nothing
-  , _gameMonth           = Nothing
+  , _gameMonth            = Nothing
-  , _gameDay             = Nothing
+  , _gameDay              = Nothing
-  , _gameType            = Nothing
+  , _gameType             = Nothing
-  , _otherTeam           = ""
+  , _otherTeam            = ""
-  , _homeScore           = Nothing
+  , _homeScore            = Nothing
-  , _awayScore           = Nothing
+  , _awayScore            = Nothing
-  , _overtimeFlag        = Nothing
+  , _overtimeFlag         = Nothing
-  , _dataVerified        = False
+  , _dataVerified         = False
-  , _pointsAccounted     = 0
+  , _pointsAccounted      = 0
-  , _goalBy              = Nothing
+  , _goalBy               = Nothing
-  , _assistsBy           = []
+  , _assistsBy            = []
-  , _gamePlayerStats     = M.empty
+  , _gamePlayerStats      = M.empty
-  , _confirmGoalDataFlag = False
+  , _confirmGoalDataFlag  = False
-  , _selectedPlayer      = Nothing
+  , _gameSelectedPlayer   = Nothing
-  , _pMinsRecorded       = False
+  , _gamePMinsRecorded    = False
+  , _gameGoalieStats      = M.empty
+  , _gameSelectedGoalie   = Nothing
+  , _gameGoalieMinsPlayed = Nothing
+  , _gameGoalsAllowed     = Nothing
+  , _gameGoaliesRecorded  = False
+  , _gameGoalieAssigned   = False
   }
 
 -- | Constructor for a 'CreatePlayerState'
@@ -548,6 +707,29 @@ newCreatePlayerState = CreatePlayerState
   , _cpsFailureCallback = return ()
   }
 
+-- | Constructor for a 'CreateGoalieState'
+newCreateGoalieState :: CreateGoalieState
+newCreateGoalieState = CreateGoalieState
+  { _cgsNumber          = Nothing
+  , _cgsName            = ""
+  , _cgsSuccessCallback = return ()
+  , _cgsFailureCallback = return ()
+  }
+
+-- | Constructor for an 'EditPlayerState'
+newEditPlayerState :: EditPlayerState
+newEditPlayerState = EditPlayerState
+  { _epsSelectedPlayer = Nothing
+  , _epsMode           = EPMenu
+  }
+
+-- | Constructor for an 'EditGoalieState' value
+newEditGoalieState :: EditGoalieState
+newEditGoalieState = EditGoalieState
+  { _egsSelectedGoalie = Nothing
+  , _egsMode           = EGMenu
+  }
+
 -- | Constructor for a 'Database'
 newDatabase :: Database
 newDatabase = Database
@@ -603,7 +785,6 @@ newGoalieStats = GoalieStats
   { _gsGames        = 0
   , _gsMinsPlayed   = 0
   , _gsGoalsAllowed = 0
-  , _gsGoalsAgainst = 0
   , _gsWins         = 0
   , _gsLosses       = 0
   , _gsTies         = 0
@@ -699,9 +880,8 @@ playerSearch
   -> [(Int, Player)]
   -- ^ The matching players with their index numbers
 playerSearch sStr =
-  filter (match sStr) .
+  filter match . zip [0..]
-  zip [0..]
+  where match (_, p) = sStr `isInfixOf` (p^.pName)
-  where match sStr (_, p) = sStr `isInfixOf` (p^.pName)
 
 -- | Searches for a player by exact match on name
 playerSearchExact
@@ -712,10 +892,8 @@ playerSearchExact
   -> Maybe (Int, Player)
   -- ^ The player's index and value
 playerSearchExact sStr =
-  listToMaybe .
+  listToMaybe . filter match . zip [0..]
-  filter (match sStr) .
+  where match (_, p) = p^.pName == sStr
-  zip [0..]
-  where match sStr (_, p) = p^.pName == sStr
 
 -- | Modifies a player with a given name
 modifyPlayer
@@ -737,6 +915,20 @@ playerSummary :: Player -> String
 playerSummary p =
   p^.pName ++ " (" ++ show (p^.pNumber) ++ ") " ++ p^.pPosition
 
+-- | Provides a detailed string describing a 'Player'
+playerDetails :: Player -> String
+playerDetails p = unlines
+  [ "               Number: " ++ show (p^.pNumber)
+  , "                 Name: " ++ p^.pName
+  , "             Position: " ++ p^.pPosition
+  , "            YTD goals: " ++ show (p^.pYtd.psGoals)
+  , "          YTD assists: " ++ show (p^.pYtd.psAssists)
+  , "     YTD penalty mins: " ++ show (p^.pYtd.psPMin)
+  , "       Lifetime goals: " ++ show (p^.pLifetime.psGoals)
+  , "     Lifetime assists: " ++ show (p^.pLifetime.psAssists)
+  , "Lifetime penalty mins: " ++ show (p^.pLifetime.psPMin)
+  ]
+
 -- | Determines whether or not a player has been active in the current
 -- season/year
 playerIsActive :: Player -> Bool
@@ -757,3 +949,33 @@ addPlayerStats s1 s2 = newPlayerStats
   & psGoals   .~ s1^.psGoals + s2^.psGoals
   & psAssists .~ s1^.psAssists + s2^.psAssists
   & psPMin    .~ s1^.psPMin + s2^.psPMin
+
+-- | Searches a list of goalies
+goalieSearch
+  :: String
+  -- ^ The search string
+  -> [Goalie]
+  -- ^ The list to search
+  -> [(Int, Goalie)]
+  -- ^ The search results with their corresponding index numbers
+goalieSearch sStr = filter (\(_, goalie) -> sStr `isInfixOf` (goalie^.gName)) .
+  zip [0..]
+
+-- | Searches a list of goalies for an exact match
+goalieSearchExact
+  :: String
+  -- ^ The search string
+  -> [Goalie]
+  -- ^ The list to search
+  -> Maybe (Int, Goalie)
+  -- ^ The result with its index number
+goalieSearchExact sStr goalies = let
+  results = filter (\(_, goalie) -> sStr == goalie^.gName) $
+    zip [0..] goalies
+  in case results of
+    []       -> Nothing
+    result:_ -> Just result
+
+-- | Provides a description string for a 'Goalie'
+goalieSummary :: Goalie -> String
+goalieSummary g = g^.gName ++ " (" ++ show (g^.gNumber) ++ ")"

src/Mtlstats/Types/Menu.hs

@@ -38,7 +38,6 @@ module Mtlstats.Types.Menu (
 
 import Lens.Micro ((^.))
 import Lens.Micro.TH (makeLenses)
-import qualified UI.NCurses as C
 
 import Mtlstats.Types
 

test/Actions/EditGoalieSpec.hs

@@ -0,0 +1,537 @@
+{-
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+module Actions.EditGoalieSpec (spec) where
+
+import Data.Maybe (fromJust)
+import Lens.Micro ((^.), (&), (.~))
+import Test.Hspec (Spec, context, describe, it, shouldBe)
+
+import Mtlstats.Actions.EditGoalie
+import Mtlstats.Types
+import Mtlstats.Util
+
+spec :: Spec
+spec = describe "EditGoalie" $ do
+  editGoalieNumberSpec
+  editGoalieNameSpec
+  editGoalieYtdGamesSpec
+  editGoalieYtdMinsSpec
+  editGoalieYtdGoalsSpec
+  editGoalieYtdWinsSpec
+  editGoalieYtdLossesSpec
+  editGoalieYtdTiesSpec
+  editGoalieLtGamesSpec
+  editGoalieLtMinsSpec
+  editGoalieLtGoalsSpec
+  editGoalieLtWinsSpec
+  editGoalieLtLossesSpec
+  editGoalieLtTiesSpec
+
+editGoalieNumberSpec :: Spec
+editGoalieNumberSpec = describe "editGoalieNumber" $ editTest
+  (editGoalieNumber 5)
+  EGNumber
+  (uncurry newGoalie)
+  [ ( "set Joe"
+    , Just 0
+    , (5, "Joe")
+    , (3, "Bob")
+    , EGMenu
+    )
+  , ( "set Bob"
+    , Just 1
+    , (2, "Joe")
+    , (5, "Bob")
+    , EGMenu
+    )
+  , ( "out of bounds"
+    , Just 2
+    , (2, "Joe")
+    , (3, "Bob")
+    , EGNumber
+    )
+  , ( "no goalie selected"
+    , Nothing
+    , (2, "Joe")
+    , (3, "Bob")
+    , EGNumber
+    )
+  ]
+
+editGoalieNameSpec :: Spec
+editGoalieNameSpec = describe "editGoalieName" $ editTest
+  (editGoalieName "foo")
+  EGName
+  (uncurry newGoalie)
+  [ ( "set Joe"
+    , Just 0
+    , ( 2, "foo" )
+    , ( 3, "Bob" )
+    , EGMenu
+    )
+  , ( "set Bob"
+    , Just 1
+    , ( 2, "Joe" )
+    , ( 3, "foo" )
+    , EGMenu
+    )
+  , ( "out of bounds"
+    , Just 2
+    , ( 2, "Joe" )
+    , ( 3, "Bob" )
+    , EGName
+    )
+  , ( "no goalie selected"
+    , Nothing
+    , ( 2, "Joe" )
+    , ( 3, "Bob" )
+    , EGName
+    )
+  ]
+
+editGoalieYtdGamesSpec :: Spec
+editGoalieYtdGamesSpec = describe "editGoalieYtdGames" $ editTest
+  (editGoalieYtdGames 1)
+  EGYtdGames
+  (\(num, name, games) -> newGoalie num name & gYtd.gsGames .~ games)
+  [ ( "set Joe"
+    , Just 0
+    , ( 2, "Joe", 1 )
+    , ( 3, "Bob", 0 )
+    , EGYtd
+    )
+  , ( "set Bob"
+    , Just 1
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 1 )
+    , EGYtd
+    )
+  , ( "out of bounds"
+    , Just 2
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGYtdGames
+    )
+  , ( "no goalie selected"
+    , Nothing
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGYtdGames
+    )
+  ]
+
+editGoalieYtdMinsSpec :: Spec
+editGoalieYtdMinsSpec = describe "editGoalieYtdMins" $ editTest
+  (editGoalieYtdMins 1)
+  EGYtdMins
+  (\(num, name, mins) -> newGoalie num name & gYtd.gsMinsPlayed .~ mins)
+  [ ( "set Joe"
+    , Just 0
+    , ( 2, "Joe", 1 )
+    , ( 3, "Bob", 0 )
+    , EGYtd
+    )
+  , ( "set Bob"
+    , Just 1
+    , (2, "Joe", 0 )
+    , (3, "Bob", 1 )
+    , EGYtd
+    )
+  , ( "out of bounds"
+    , Just 2
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGYtdMins
+    )
+  , ( "no goalie selected"
+    , Nothing
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGYtdMins
+    )
+  ]
+
+editGoalieYtdGoalsSpec :: Spec
+editGoalieYtdGoalsSpec = describe "editGoalieYtdGoals" $ editTest
+  (editGoalieYtdGoals 1)
+  EGYtdGoals
+  (\(num, name, goals) -> newGoalie num name & gYtd.gsGoalsAllowed .~ goals)
+  [ ( "set Joe"
+    , Just 0
+    , ( 2, "Joe", 1 )
+    , ( 3, "Bob", 0 )
+    , EGYtd
+    )
+  , ( "set Bob"
+    , Just 1
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 1 )
+    , EGYtd
+    )
+  , ( "out of bounds"
+    , Just 2
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGYtdGoals
+    )
+  , ( "no goalie selected"
+    , Nothing
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGYtdGoals
+    )
+  ]
+
+editGoalieYtdWinsSpec :: Spec
+editGoalieYtdWinsSpec = describe "editGoalieYtdWins" $ editTest
+  (editGoalieYtdWins 1)
+  EGYtdWins
+  (\(num, name, wins) -> newGoalie num name & gYtd.gsWins .~ wins)
+  [ ( "set Joe"
+    , Just 0
+    , ( 2, "Joe", 1 )
+    , ( 3, "Bob", 0 )
+    , EGYtd
+    )
+  , ( "set Bob"
+    , Just 1
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 1 )
+    , EGYtd
+    )
+  , ( "out of bounds"
+    , Just 2
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGYtdWins
+    )
+  , ( "no goalie selected"
+    , Nothing
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGYtdWins
+    )
+  ]
+
+editGoalieYtdLossesSpec :: Spec
+editGoalieYtdLossesSpec = describe "editGoalieYtdLosses" $ editTest
+  (editGoalieYtdLosses 1)
+  EGYtdLosses
+  (\(num, name, losses) -> newGoalie num name & gYtd.gsLosses .~ losses)
+  [ ( "set Joe"
+    , Just 0
+    , ( 2, "Joe", 1 )
+    , ( 3, "Bob", 0 )
+    , EGYtd
+    )
+  , ( "set Bob"
+    , Just 1
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 1 )
+    , EGYtd
+    )
+  , ( "out of bounds"
+    , Just 2
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGYtdLosses
+    )
+  , ( "no goalie selected"
+    , Nothing
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGYtdLosses
+    )
+  ]
+
+editGoalieYtdTiesSpec :: Spec
+editGoalieYtdTiesSpec = describe "editGoalieYtdTies" $ editTest
+  (editGoalieYtdTies 1)
+  EGYtdTies
+  (\(num, name, ties) -> newGoalie num name & gYtd.gsTies .~ ties)
+  [ ( "set Joe"
+    , Just 0
+    , ( 2, "Joe", 1 )
+    , ( 3, "Bob", 0 )
+    , EGYtd
+    )
+  , ( "set Bob"
+    , Just 1
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 1 )
+    , EGYtd
+    )
+  , ( "out of bounds"
+    , Just 2
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGYtdTies
+    )
+  , ( "no goalie selected"
+    , Nothing
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGYtdTies
+    )
+  ]
+
+editGoalieLtGamesSpec :: Spec
+editGoalieLtGamesSpec = describe "editGoalieLtGames" $ editTest
+  (editGoalieLtGames 1)
+  EGLtGames
+  (\(num, name, games) -> newGoalie num name & gLifetime.gsGames .~ games)
+  [ ( "set Joe"
+    , Just 0
+    , ( 2, "Joe", 1 )
+    , ( 3, "Bob", 0 )
+    , EGLifetime
+    )
+  , ( "set Bob"
+    , Just 1
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 1 )
+    , EGLifetime
+    )
+  , ( "out of bounds"
+    , Just 2
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGLtGames
+    )
+  , ( "no goalie selected"
+    , Nothing
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGLtGames
+    )
+  ]
+
+editGoalieLtMinsSpec :: Spec
+editGoalieLtMinsSpec = describe "editGoalieLtMins" $ editTest
+  (editGoalieLtMins 1)
+  EGLtMins
+  (\(num, name, mins) -> newGoalie num name & gLifetime.gsMinsPlayed .~ mins)
+  [ ( "set Joe"
+    , Just 0
+    , ( 2, "Joe", 1 )
+    , ( 3, "Bob", 0 )
+    , EGLifetime
+    )
+  , ( "set Bob"
+    , Just 1
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 1 )
+    , EGLifetime
+    )
+  , ( "out of bounds"
+    , Just 2
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGLtMins
+    )
+  , ( "no goalie selected"
+    , Nothing
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGLtMins
+    )
+  ]
+
+editGoalieLtGoalsSpec :: Spec
+editGoalieLtGoalsSpec = describe "editGoalieLtGoals" $ editTest
+  (editGoalieLtGoals 1)
+  EGLtGoals
+  (\(num, name, goals) -> newGoalie num name & gLifetime.gsGoalsAllowed .~ goals)
+  [ ( "set Joe"
+    , Just 0
+    , ( 2, "Joe", 1 )
+    , ( 3, "Bob", 0 )
+    , EGLifetime
+    )
+  , ( "set Bob"
+    , Just 1
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 1 )
+    , EGLifetime
+    )
+  , ( "out of bounds"
+    , Just 2
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGLtGoals
+    )
+  , ( "no goalie selected"
+    , Nothing
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGLtGoals
+    )
+  ]
+
+editGoalieLtWinsSpec :: Spec
+editGoalieLtWinsSpec = describe "editGoalieLtWins" $ editTest
+  (editGoalieLtWins 1)
+  EGLtWins
+  (\(num, name, wins) -> newGoalie num name & gLifetime.gsWins .~ wins)
+  [ ( "set Joe"
+    , Just 0
+    , ( 2, "Joe", 1 )
+    , ( 3, "Bob", 0 )
+    , EGLifetime
+    )
+  , ( "set Bob"
+    , Just 1
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 1 )
+    , EGLifetime
+    )
+  , ( "out of bounds"
+    , Just 2
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGLtWins
+    )
+  , ( "no goalie selected"
+    , Nothing
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGLtWins
+    )
+  ]
+
+editGoalieLtLossesSpec :: Spec
+editGoalieLtLossesSpec = describe "editGoalieLtLosses" $ editTest
+  (editGoalieLtLosses 1)
+  EGLtLosses
+  (\(num, name, losses) -> newGoalie num name & gLifetime.gsLosses .~ losses)
+  [ ( "set Joe"
+    , Just 0
+    , ( 2, "Joe", 1 )
+    , ( 3, "Bob", 0 )
+    , EGLifetime
+    )
+  , ( "set Bob"
+    , Just 1
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 1 )
+    , EGLifetime
+    )
+  , ( "out of bounds"
+    , Just 2
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGLtLosses
+    )
+  , ( "no goalie selected"
+    , Nothing
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGLtLosses
+    )
+  ]
+
+editGoalieLtTiesSpec :: Spec
+editGoalieLtTiesSpec = describe "editGoalieLtTies" $ editTest
+  (editGoalieLtTies 1)
+  EGLtTies
+  (\(num, name, ties) -> newGoalie num name & gLifetime.gsTies .~ ties)
+  [ ( "set Joe"
+    , Just 0
+    , ( 2, "Joe", 1 )
+    , ( 3, "Bob", 0 )
+    , EGLifetime
+    )
+  , ( "set Bob"
+    , Just 1
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 1 )
+    , EGLifetime
+    )
+  , ( "out of bounds"
+    , Just 2
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGLtTies
+    )
+  , ( "no goalie selected"
+    , Nothing
+    , ( 2, "Joe", 0 )
+    , ( 3, "Bob", 0 )
+    , EGLtTies
+    )
+  ]
+
+editTest
+  :: (ProgState -> ProgState)
+  -> EditGoalieMode
+  -> (a -> Goalie)
+  -> [(String, Maybe Int, a, a, EditGoalieMode)]
+  -> Spec
+editTest func setMode mkGoalie params = do
+  mapM_
+    (\(setLabel, setGid, joeData, bobData, expectMode) -> context setLabel $ do
+      let
+        egs = newEditGoalieState
+          & egsSelectedGoalie .~ setGid
+          & egsMode           .~ setMode
+
+        ps = func $ progState $ EditGoalie egs
+
+      mapM_
+        (\(chkLabel, chkGid, goalieData) -> context chkLabel $ let
+          actual   = fromJust $ nth chkGid $ ps^.database.dbGoalies
+          expected = mkGoalie goalieData
+          in it ("should be " ++ show expected) $
+            actual `shouldBe` expected)
+        --  label,       goalie ID, goalie data
+        [ ( "check Joe", 0,         joeData     )
+        , ( "check Bob", 1,         bobData     )
+        ]
+
+      context "check mode" $
+        it ("should be " ++ show expectMode) $
+          ps^.progMode.editGoalieStateL.egsMode `shouldBe` expectMode)
+
+    params
+
+  context "wrong progMode" $ do
+    let ps = func $ progState MainMenu
+
+    it "should not change the database" $
+      ps^.database `shouldBe` db
+
+    it "should not change the progMode" $
+      show (ps^.progMode) `shouldBe` "MainMenu"
+
+joe :: Goalie
+joe = newGoalie 2 "Joe"
+
+bob :: Goalie
+bob = newGoalie 3 "Bob"
+
+db :: Database
+db = newDatabase & dbGoalies .~ [joe, bob]
+
+progState :: ProgMode -> ProgState
+progState mode = newProgState
+  & progMode .~ mode
+  & database .~ db

test/Actions/NewGame/GoalieInputSpec.hs

@@ -0,0 +1,291 @@
+{-
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+module Actions.NewGame.GoalieInputSpec (spec) where
+
+import qualified Data.Map as M
+import Data.Maybe (fromJust)
+import Lens.Micro ((^.), (&), (.~), (?~))
+import Test.Hspec (Spec, context, describe, it, shouldBe)
+
+import Mtlstats.Actions.NewGame.GoalieInput
+import Mtlstats.Types
+import Mtlstats.Util
+
+import qualified TypesSpec as TS
+
+spec :: Spec
+spec = describe "Mtlstats.Actions.GoalieInput" $ do
+  finishGoalieEntrySpec
+  recordGoalieStatsSpec
+  setGameGoalieSpec
+
+finishGoalieEntrySpec :: Spec
+finishGoalieEntrySpec = describe "finishGoalieEntry" $ do
+  let
+    progState stats = newProgState
+      & progMode.gameStateL.gameGoalieStats .~ stats
+      & finishGoalieEntry
+
+  context "no goalie data" $
+    it "should not set goaliesRecorded" $ let
+      s = progState M.empty
+      in s^.progMode.gameStateL.gameGoaliesRecorded `shouldBe` False
+
+  context "goalie data" $
+    it "should set goaliesRecorded" $ let
+      s = progState $ M.fromList [(1, newGoalieStats)]
+      in s^.progMode.gameStateL.gameGoaliesRecorded `shouldBe` True
+
+recordGoalieStatsSpec :: Spec
+recordGoalieStatsSpec = describe "recordGoalieStats" $ let
+  goalieStats games mins goals = newGoalieStats
+    & gsGames        .~ games
+    & gsMinsPlayed   .~ mins
+    & gsGoalsAllowed .~ goals
+
+  joe = newGoalie 2 "Joe"
+    & gYtd      .~ goalieStats 10 11 12
+    & gLifetime .~ goalieStats 20 21 22
+
+  bob = newGoalie 3 "Bob"
+    & gYtd      .~ goalieStats 30 31 32
+    & gLifetime .~ goalieStats 40 41 42
+
+  gameState n mins goals = newGameState
+    & gameGoalieStats      .~ M.fromList [(1, goalieStats 1 2 3)]
+    & gameSelectedGoalie   .~ n
+    & gameGoalieMinsPlayed .~ mins
+    & gameGoalsAllowed     .~ goals
+
+  progState n mins goals = newProgState
+    & database.dbGoalies  .~ [joe, bob]
+    & progMode.gameStateL .~ gameState n mins goals
+
+  in mapM_
+    (\(setName, setGid, mins, goals, joeData, bobData, reset) -> let
+      s = recordGoalieStats $ progState setGid mins goals
+      in context setName $ do
+
+        mapM_
+          (\( chkName
+            , chkGid
+            , ( gGames
+              , gMins
+              , gGoals
+              , ytdGames
+              , ytdMins
+              , ytdGoals
+              , ltGames
+              , ltMins
+              , ltGoals
+              )
+            ) -> context chkName $ do
+              let
+                gs     = s^.progMode.gameStateL.gameGoalieStats
+                game   = M.findWithDefault newGoalieStats chkGid gs
+                goalie = fromJust $ nth chkGid $ s^.database.dbGoalies
+                ytd    = goalie^.gYtd
+                lt     = goalie^.gLifetime
+
+              context "game" $
+                game `TS.compareTest` goalieStats gGames gMins gGoals
+
+              context "year-to-date" $
+                ytd `TS.compareTest` goalieStats ytdGames ytdMins ytdGoals
+
+              context "lifetime" $
+                lt `TS.compareTest` goalieStats ltGames ltMins ltGoals)
+
+          [ ( "checking Joe", 0, joeData )
+          , ( "checking Bob", 1, bobData )
+          ]
+
+        context "selected goalie" $ let
+          expected = if reset then Nothing else setGid
+          in it ("should be " ++ show expected) $
+            (s^.progMode.gameStateL.gameSelectedGoalie) `shouldBe` expected
+
+        context "minutes played" $ let
+          expected = if reset then Nothing else mins
+          in it ("should be " ++ show expected) $
+            (s^.progMode.gameStateL.gameGoalieMinsPlayed) `shouldBe` expected
+
+        context "goals allowed" $ let
+          expected = if reset then Nothing else goals
+          in it ("should be " ++ show expected) $
+            (s^.progMode.gameStateL.gameGoalsAllowed) `shouldBe` expected)
+
+    [ ( "updating Joe"
+      , Just 0
+      , Just 1
+      , Just 2
+      , (1, 1, 2, 11, 12, 14, 21, 22, 24)
+      , (1, 2, 3, 30, 31, 32, 40, 41, 42)
+      , True
+      )
+    , ( "updating Bob"
+      , Just 1
+      , Just 1
+      , Just 2
+      , (0, 0, 0, 10, 11, 12, 20, 21, 22)
+      , (1, 3, 5, 30, 32, 34, 40, 42, 44)
+      , True
+      )
+    , ( "goalie out of bounds"
+      , Just 2
+      , Just 1
+      , Just 2
+      , (0, 0, 0, 10, 11, 12, 20, 21, 22)
+      , (1, 2, 3, 30, 31, 32, 40, 41, 42)
+      , False
+      )
+    , ( "missing goalie"
+      , Nothing
+      , Just 1
+      , Just 2
+      , (0, 0, 0, 10, 11, 12, 20, 21, 22)
+      , (1, 2, 3, 30, 31, 32, 40, 41, 42)
+      , False
+      )
+    , ( "missing minutes"
+      , Just 0
+      , Nothing
+      , Just 1
+      , (0, 0, 0, 10, 11, 12, 20, 21, 22)
+      , (1, 2, 3, 30, 31, 32, 40, 41, 42)
+      , False
+      )
+    , ( "missing goals"
+      , Just 0
+      , Just 1
+      , Nothing
+      , (0, 0, 0, 10, 11, 12, 20, 21, 22)
+      , (1, 2, 3, 30, 31, 32, 40, 41, 42)
+      , False
+      )
+    ]
+
+setGameGoalieSpec :: Spec
+setGameGoalieSpec = describe "setGameGoalie" $ let
+
+  goalieStats w l t = newGoalieStats
+    & gsWins   .~ w
+    & gsLosses .~ l
+    & gsTies   .~ t
+
+  bob = newGoalie 2 "Bob"
+    & gYtd      .~ goalieStats 10 11 12
+    & gLifetime .~ goalieStats 20 21 22
+
+  joe = newGoalie 3 "Joe"
+    & gYtd      .~ goalieStats 30 31 32
+    & gLifetime .~ goalieStats 40 41 42
+
+  gameState h a ot = newGameState
+    & gameType        ?~ HomeGame
+    & homeScore       ?~ h
+    & awayScore       ?~ a
+    & overtimeFlag    ?~ ot
+
+  winningGame = gameState 1 0 False
+  losingGame  = gameState 0 1 False
+  tiedGame    = gameState 0 1 True
+
+  in mapM_
+    (\(setLabel, gs, setGid, bobData, joeData) -> context setLabel $ let
+
+      progState = newProgState
+        & database.dbGoalies  .~ [bob, joe]
+        & progMode.gameStateL .~ gs
+        & setGameGoalie setGid
+
+      in mapM_
+        (\( chkLabel
+          , chkGid
+          , ( gWins
+            , gLosses
+            , gTies
+            , ytdWins
+            , ytdLosses
+            , ytdTies
+            , ltWins
+            , ltLosses
+            , ltTies
+            )
+          ) -> context chkLabel $ do
+            let
+              goalie = (progState^.database.dbGoalies) !! chkGid
+              gameStats = progState^.progMode.gameStateL.gameGoalieStats
+              game      = M.findWithDefault newGoalieStats chkGid gameStats
+              ytd       = goalie^.gYtd
+              lifetime  = goalie^.gLifetime
+
+            mapM_
+              (\(label', expected, actual) -> context label' $
+                expected `TS.compareTest` actual)
+              [ ( "game stats",     game,     goalieStats gWins   gLosses   gTies   )
+              , ( "YTD stats",      ytd,      goalieStats ytdWins ytdLosses ytdTies )
+              , ( "lifetime stats", lifetime, goalieStats ltWins  ltLosses  ltTies  )
+              ]
+
+            it "should set the gameGoalieAssigned flag" $
+              progState^.progMode.gameStateL.gameGoalieAssigned `shouldBe` True)
+        [ ( "checking Bob", 0, bobData )
+        , ( "checking Joe", 1, joeData )
+        ])
+    [ ( "Bob wins"
+      , winningGame
+      , 0
+      , ( 1, 0, 0, 11, 11, 12, 21, 21, 22 )
+      , ( 0, 0, 0, 30, 31, 32, 40, 41, 42 )
+      )
+    , ( "Bob loses"
+      , losingGame
+      , 0
+      , ( 0, 1, 0, 10, 12, 12, 20, 22, 22 )
+      , ( 0, 0, 0, 30, 31, 32, 40, 41, 42 )
+      )
+    , ( "Bob ties"
+      , tiedGame
+      , 0
+      , ( 0, 0, 1, 10, 11, 13, 20, 21, 23 )
+      , ( 0, 0, 0, 30, 31, 32, 40, 41, 42 )
+      )
+    , ( "Joe wins"
+      , winningGame
+      , 1
+      , ( 0, 0, 0, 10, 11, 12, 20, 21, 22 )
+      , ( 1, 0, 0, 31, 31, 32, 41, 41, 42 )
+      )
+    , ( "Joe loses"
+      , losingGame
+      , 1
+      , ( 0, 0, 0, 10, 11, 12, 20, 21, 22 )
+      , ( 0, 1, 0, 30, 32, 32, 40, 42, 42 )
+      )
+    , ( "Joe ties"
+      , tiedGame
+      , 1
+      , ( 0, 0, 0, 10, 11, 12, 20, 21, 22 )
+      , ( 0, 0, 1, 30, 31, 33, 40, 41, 43 )
+      )
+    ]

test/Actions/NewGameSpec.hs

@@ -0,0 +1,483 @@
+{-
+
+mtlstats
+Copyright (C) 2019 Rhéal Lamothe
+<rheal.lamothe@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+-}
+
+module Actions.NewGameSpec (spec) where
+
+import Control.Monad (replicateM)
+import qualified Data.Map as M
+import Data.Maybe (fromJust)
+import Lens.Micro ((^.), (&), (.~), (?~), (%~))
+import Test.Hspec (Spec, context, describe, it, runIO, shouldBe)
+
+import Mtlstats.Actions.NewGame
+import Mtlstats.Types
+import Mtlstats.Util
+
+import qualified Actions.NewGame.GoalieInputSpec as GoalieInput
+import qualified TypesSpec as TS
+
+spec :: Spec
+spec = describe "NewGame" $ do
+  overtimeCheckSpec
+  updateGameStatsSpec
+  validateGameDateSpec
+  recordGoalAssistsSpec
+  awardGoalSpec
+  awardAssistSpec
+  resetGoalDataSpec
+  assignPMinsSpec
+  GoalieInput.spec
+
+overtimeCheckSpec :: Spec
+overtimeCheckSpec = describe "overtimeCheck" $ do
+
+  context "tie game" $ do
+    let
+      s = newProgState
+        & progMode.gameStateL
+          %~ (gameType  ?~ HomeGame)
+          .  (homeScore ?~ 1)
+          .  (awayScore ?~ 1)
+        & overtimeCheck
+
+    it "should clear the home score" $
+      s^.progMode.gameStateL.homeScore `shouldBe` Nothing
+
+    it "should clear the away score" $
+      s^.progMode.gameStateL.awayScore `shouldBe` Nothing
+
+    it "should leave the overtimeFlag blank" $
+      s^.progMode.gameStateL.overtimeFlag `shouldBe` Nothing
+
+  context "game won" $ do
+    let
+      s = newProgState
+        & progMode.gameStateL
+          %~ (gameType  ?~ HomeGame)
+          .  (homeScore ?~ 2)
+          .  (awayScore ?~ 1)
+        & overtimeCheck
+
+    it "should not change the home score" $
+      s^.progMode.gameStateL.homeScore `shouldBe` Just 2
+
+    it "should not change the away score" $
+      s^.progMode.gameStateL.awayScore `shouldBe` Just 1
+
+    it "should set the overtimeCheck flag to False" $
+      s^.progMode.gameStateL.overtimeFlag `shouldBe` Just False
+
+  context "game lost" $ do
+    let
+      s = newProgState
+        & progMode.gameStateL
+          %~ (gameType  ?~ HomeGame)
+          .  (homeScore ?~ 1)
+          .  (awayScore ?~ 2)
+        & overtimeCheck
+
+    it "should not change the home score" $
+      s^.progMode.gameStateL.homeScore `shouldBe` Just 1
+
+    it "should not change the away score" $
+      s^.progMode.gameStateL.awayScore `shouldBe` Just 2
+
+    it "should leave the overtimeCheck flag blank" $
+      s^.progMode.gameStateL.overtimeFlag `shouldBe` Nothing
+
+updateGameStatsSpec :: Spec
+updateGameStatsSpec = describe "updateGameStats" $ do
+  let
+
+    baseStats = newGameStats
+      & gmsWins         .~ 1
+      & gmsLosses       .~ 1
+      & gmsOvertime     .~ 1
+      & gmsGoalsFor     .~ 1
+      & gmsGoalsAgainst .~ 1
+
+    s t h a o = newProgState
+      & progMode.gameStateL
+        %~ (gameType     .~ t)
+        .  (homeScore    .~ h)
+        .  (awayScore    .~ a)
+        .  (overtimeFlag .~ o)
+      & database
+        %~ (dbHomeGameStats .~ baseStats)
+        .  (dbAwayGameStats .~ baseStats)
+
+    db hw hl ho hf ha aw al ao af aa = newDatabase
+      & dbHomeGameStats
+        %~ (gmsWins         .~ hw)
+        .  (gmsLosses       .~ hl)
+        .  (gmsOvertime     .~ ho)
+        .  (gmsGoalsFor     .~ hf)
+        .  (gmsGoalsAgainst .~ ha)
+      & dbAwayGameStats
+        %~ (gmsWins         .~ aw)
+        .  (gmsLosses       .~ al)
+        .  (gmsOvertime     .~ ao)
+        .  (gmsGoalsFor     .~ af)
+        .  (gmsGoalsAgainst .~ aa)
+
+  context "home win" $
+    it "should record a home win" $ let
+      s'  = s (Just HomeGame) (Just 2) (Just 1) (Just False)
+      db' = updateGameStats s' ^. database
+      in db' `shouldBe` db 2 1 1 3 2 1 1 1 1 1
+
+  context "home loss" $
+    it "should record a home loss" $ let
+      s'  = s (Just HomeGame) (Just 1) (Just 2) (Just False)
+      db' = updateGameStats s' ^. database
+      in db' `shouldBe` db 1 2 1 2 3 1 1 1 1 1
+
+  context "home overtime loss" $
+    it "should record a home overtime" $ let
+      s'  = s (Just HomeGame) (Just 1) (Just 2) (Just True)
+      db' = updateGameStats s' ^. database
+      in db' `shouldBe` db 1 1 2 2 3 1 1 1 1 1
+
+  context "away win" $
+    it "should record an away win" $ let
+      s'  = s (Just AwayGame) (Just 1) (Just 2) (Just False)
+      db' = updateGameStats s' ^. database
+      in db' `shouldBe` db 1 1 1 1 1 2 1 1 3 2
+
+  context "away loss" $
+    it "should record an away loss" $ let
+      s'  = s (Just AwayGame) (Just 2) (Just 1) (Just False)
+      db' = updateGameStats s' ^. database
+      in db' `shouldBe` db 1 1 1 1 1 1 2 1 2 3
+
+  context "away overtime loss" $
+    it "should record an away overtime" $ let
+      s'  = s (Just AwayGame) (Just 2) (Just 1) (Just True)
+      db' = updateGameStats s' ^. database
+      in db' `shouldBe` db 1 1 1 1 1 1 1 2 2 3
+
+  context "missing game type" $
+    it "should not change anything" $ let
+      s'  = s Nothing (Just 1) (Just 2) (Just True)
+      db' = updateGameStats s' ^. database
+      in db' `shouldBe` db 1 1 1 1 1 1 1 1 1 1
+
+  context "missing home score" $
+    it "should not change anything" $ let
+      s'  = s (Just HomeGame) Nothing (Just 1) (Just True)
+      db' = updateGameStats s' ^. database
+      in db' `shouldBe` db 1 1 1 1 1 1 1 1 1 1
+
+  context "missing away score" $
+    it "should not change anything" $ let
+      s'  = s (Just HomeGame) (Just 1) Nothing (Just True)
+      db' = updateGameStats s' ^. database
+      in db' `shouldBe` db 1 1 1 1 1 1 1 1 1 1
+
+  context "missing overtime flag" $
+    it "should not change anything" $ let
+      s'  = s (Just HomeGame) (Just 1) (Just 2) Nothing
+      db' = updateGameStats s' ^. database
+      in db' `shouldBe` db 1 1 1 1 1 1 1 1 1 1
+
+validateGameDateSpec :: Spec
+validateGameDateSpec = describe "validateGameDate" $ do
+
+  context "valid date" $
+    it "should leave the date unchanged" $ do
+      let
+        s = newProgState
+          & progMode.gameStateL
+            %~ (gameYear  ?~ 2019)
+            .  (gameMonth ?~ 6)
+            .  (gameDay   ?~ 25)
+          & validateGameDate
+      s^.progMode.gameStateL.gameYear  `shouldBe` Just 2019
+      s^.progMode.gameStateL.gameMonth `shouldBe` Just 6
+      s^.progMode.gameStateL.gameDay   `shouldBe` Just 25
+
+  context "invalid date" $
+    it "should clear the date" $ do
+      let
+        s = newProgState
+          & progMode.gameStateL
+            %~ (gameYear  ?~ 2019)
+            .  (gameMonth ?~ 2)
+            .  (gameDay   ?~ 30)
+          & validateGameDate
+      s^.progMode.gameStateL.gameYear  `shouldBe` Nothing
+      s^.progMode.gameStateL.gameMonth `shouldBe` Nothing
+      s^.progMode.gameStateL.gameDay   `shouldBe` Nothing
+
+  context "missing day" $
+    it "should not change anything" $ do
+      let
+
+        gs = newGameState
+          & gameYear  ?~ 2019
+          & gameMonth ?~ 6
+
+        s = newProgState
+          & progMode.gameStateL .~ gs
+          & validateGameDate
+
+      s^.progMode.gameStateL.gameYear  `shouldBe` Just 2019
+      s^.progMode.gameStateL.gameMonth `shouldBe` Just 6
+      s^.progMode.gameStateL.gameDay   `shouldBe` Nothing
+
+recordGoalAssistsSpec :: Spec
+recordGoalAssistsSpec = describe "recordGoalAssists" $ do
+  let
+    joe   = newPlayer 1 "Joe"   "centre"
+    bob   = newPlayer 2 "Bob"   "defense"
+    steve = newPlayer 3 "Steve" "forward"
+    dave  = newPlayer 4 "Dave"  "somewhere"
+    frank = newPlayer 5 "Frank" "elsewhere"
+    ps
+      = newProgState
+      & database.dbPlayers .~ [joe, bob, steve, dave, frank]
+      & progMode.gameStateL
+        %~ (goalBy              ?~ 0)
+        .  (assistsBy           .~ [1, 2])
+        .  (confirmGoalDataFlag .~ True)
+      & recordGoalAssists
+
+  mapM_
+    (\(name, n, goals, assists) -> context name $ do
+      let
+        player = (ps^.database.dbPlayers) !! n
+        stats  = M.findWithDefault newPlayerStats n $
+          ps^.progMode.gameStateL.gamePlayerStats
+
+      it ("should set the year-to-date goals to " ++ show goals) $
+        player^.pYtd.psGoals `shouldBe` goals
+
+      it ("should set the lifetime goals to " ++ show goals) $
+        player^.pLifetime.psGoals `shouldBe` goals
+
+      it ("should set the game goals to " ++ show goals) $
+        stats^.psAssists `shouldBe` assists
+
+      it ("should set the year-to-date assists to " ++ show assists) $
+        player^.pYtd.psAssists `shouldBe` assists
+
+      it ("should set the lifetime assists to " ++ show assists) $
+        player^.pLifetime.psAssists `shouldBe` assists
+
+      it ("should set the game assists to " ++ show assists) $
+        stats^.psAssists `shouldBe` assists)
+
+    --  name,    index, goals, assists
+    [ ( "Joe",   0,     1,     0       )
+    , ( "Bob",   1,     0,     1       )
+    , ( "Steve", 2,     0,     1       )
+    , ( "Dave",  3,     0,     0       )
+    ]
+
+  it "should clear the goalBy value" $
+    ps^.progMode.gameStateL.goalBy `shouldBe` Nothing
+
+  it "should clear the assistsBy list" $
+    ps^.progMode.gameStateL.assistsBy `shouldBe` []
+
+  it "should increment the pointsAccounted counter" $
+    ps^.progMode.gameStateL.pointsAccounted `shouldBe` 1
+
+  it "should clear the confirmGoalDataFlag" $
+    ps^.progMode.gameStateL.confirmGoalDataFlag `shouldBe` False
+
+awardGoalSpec :: Spec
+awardGoalSpec = describe "awardGoal" $ do
+  let
+    joe
+      = newPlayer 2 "Joe" "centre"
+      & pYtd.psGoals      .~ 1
+      & pLifetime.psGoals .~ 2
+    bob
+      = newPlayer 3 "Bob" "defense"
+      & pYtd.psGoals      .~ 3
+      & pLifetime.psGoals .~ 4
+    db
+      = newDatabase
+      & dbPlayers .~ [joe, bob]
+    joeStats
+      = newPlayerStats
+      & psGoals .~ 1
+    ps
+      = newProgState
+      & progMode.gameStateL.gamePlayerStats .~ M.singleton 0 joeStats
+      & database .~ db
+
+  mapM_
+    (\(name, pid, ytd, lt, game) ->
+      context name $ do
+        let
+          ps'    = awardGoal pid ps
+          player = (ps'^.database.dbPlayers) !! pid
+          gStats = (ps'^.progMode.gameStateL.gamePlayerStats) M.! pid
+
+        it ("should increment " ++ name ++ "'s year-to-date goals") $
+          player^.pYtd.psGoals `shouldBe` ytd
+
+        it ("should increment " ++ name ++ "'s lifetime goals") $
+          player^.pLifetime.psGoals `shouldBe` lt
+
+        it ("should increment " ++ name ++ "'s game goals") $
+          gStats^.psGoals `shouldBe` game)
+    --  player name, player id, ytd goals, lifetime goals, game goals
+    [ ( "Joe",       0,         2,         3,              2          )
+    , ( "Bob",       1,         4,         5,              1          )
+    ]
+
+  context "invalid index" $ let
+    ps' = awardGoal 2 ps
+    in it "should not change the database" $
+      ps'^.database `shouldBe` db
+
+  context "negative index" $ let
+    ps' = awardGoal (-1) ps
+    in it "should not change the database" $
+      ps'^.database `shouldBe` db
+
+awardAssistSpec :: Spec
+awardAssistSpec = describe "awardAssist" $ do
+  let
+    joe
+      = newPlayer 1 "Joe" "centre"
+      & pYtd.psAssists      .~ 1
+      & pLifetime.psAssists .~ 2
+    bob
+      = newPlayer 2 "Bob" "defense"
+      & pYtd.psAssists      .~ 3
+      & pLifetime.psAssists .~ 4
+    joeStats
+      = newPlayerStats
+      & psAssists .~ 1
+    ps
+      = newProgState
+      & progMode.gameStateL.gamePlayerStats .~ M.singleton 0 joeStats
+      & database.dbPlayers .~ [joe, bob]
+
+  mapM_
+    (\(name, pid, ytd, lt, game) ->
+      context name $ do
+        let
+          ps' = awardAssist pid ps
+          player = (ps'^.database.dbPlayers) !! pid
+          gStats = (ps'^.progMode.gameStateL.gamePlayerStats) M.! pid
+
+        it ("should increment " ++ name ++ "'s year-to-date assists") $
+          player^.pYtd.psAssists `shouldBe` ytd
+
+        it ("should increment " ++ name ++ "'s lifetime assists") $
+          player^.pLifetime.psAssists `shouldBe` lt
+
+        it ("should increment " ++ name ++ "'s game assists") $
+          gStats^.psAssists `shouldBe` game)
+    --  player name, player id, ytd assists, lifetime assists, game assists
+    [ ( "Joe",       0,         2,           3,                2            )
+    , ( "Bob",       1,         4,           5,                1            )
+    ]
+
+  context "invalid index" $ let
+    ps' = awardAssist (-1) ps
+    in it "should not change anything" $
+      ps'^.database.dbPlayers `shouldBe` ps^.database.dbPlayers
+
+resetGoalDataSpec :: Spec
+resetGoalDataSpec = describe "resetGoalData" $ do
+  players <- runIO $ replicateM 5 TS.makePlayer
+  let
+    gs
+      = newGameState
+      & goalBy              ?~ 1
+      & assistsBy           .~ [2, 3]
+      & confirmGoalDataFlag .~ True
+    ps
+      = newProgState
+      & database.dbPlayers  .~ players
+      & progMode.gameStateL .~ gs
+      & resetGoalData
+
+  it "should clear the goalBy value" $
+    ps^.progMode.gameStateL.goalBy `shouldBe` Nothing
+
+  it "should clear the assists by list" $
+    ps^.progMode.gameStateL.assistsBy `shouldBe` []
+
+  it "should clear confirmGoalDataFlag" $
+    ps^.progMode.gameStateL.confirmGoalDataFlag `shouldBe` False
+
+assignPMinsSpec :: Spec
+assignPMinsSpec = describe "assignPMins" $ let
+
+  bob = newPlayer 2 "Bob" "centre"
+    & pYtd.psPMin      .~ 3
+    & pLifetime.psPMin .~ 4
+
+  joe = newPlayer 3 "Joe" "defense"
+    & pYtd.psPMin      .~ 5
+    & pLifetime.psPMin .~ 6
+
+  ps pid = newProgState
+    & database.dbPlayers .~ [bob, joe]
+    & progMode.gameStateL
+      %~ (gamePlayerStats .~ M.fromList [(0, newPlayerStats & psPMin .~ 2)])
+      .  (gameSelectedPlayer .~ pid)
+
+  in mapM_
+    (\(pid, bobLt, bobYtd, bobGame, joeLt, joeYtd, joeGame) ->
+      context ("selectedPlayer = " ++ show pid) $ do
+        let ps' = assignPMins 2 $ ps pid
+
+        mapM_
+          (\(name, pid', lt, ytd, game) -> context name $ do
+            let
+              player = fromJust $ nth pid' $ ps'^.database.dbPlayers
+              gStats = ps'^.progMode.gameStateL.gamePlayerStats
+              pStats = M.findWithDefault newPlayerStats pid' gStats
+
+            context "lifetime penalty minutes" $
+              it ("should be " ++ show lt) $
+                player^.pLifetime.psPMin `shouldBe` lt
+
+            context "year-to-date penalty minutes" $
+              it ("should be " ++ show ytd) $
+                player^.pYtd.psPMin `shouldBe` ytd
+
+            context "game penalty minutes" $
+              it ("should be " ++ show game) $
+                pStats^.psPMin `shouldBe` game)
+
+          --  name,  index, lifetime, ytd,    game
+          [ ( "Bob", 0,     bobLt,    bobYtd, bobGame )
+          , ( "Joe", 1,     joeLt,    joeYtd, joeGame )
+          ]
+
+        it "should set selectedPlayer to Nothing" $
+          ps'^.progMode.gameStateL.gameSelectedPlayer `shouldBe` Nothing)
+
+    --  index,   bob lt, bob ytd, bob game, joe lt, joe ytd, joe game
+    [ ( Just 0,  6,      5,       4,        6,      5,       0        )
+    , ( Just 1,  4,      3,       2,        8,      7,       2        )
+    , ( Just 2,  4,      3,       2,        6,      5,       0        )
+    , ( Nothing, 4,      3,       2,        6,      5,       0        )
+    ]

test/ActionsSpec.hs

@@ -24,16 +24,12 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 module ActionsSpec (spec) where
 
 import Control.Monad (replicateM)
-import qualified Data.Map as M
+import Lens.Micro ((^.), (&), (.~), (?~))
-import Data.Maybe (fromJust)
-import Lens.Micro ((^.), (&), (.~), (?~), (%~))
-import System.Random (randomRIO)
 import Test.Hspec
   ( Spec
   , context
   , describe
   , it
-  , runIO
   , shouldBe
   , shouldNotBe
   , shouldSatisfy
@@ -41,28 +37,32 @@ import Test.Hspec
 
 import Mtlstats.Actions
 import Mtlstats.Types
-import Mtlstats.Util
+
+import qualified Actions.EditGoalieSpec as EditGoalie
+import qualified Actions.NewGameSpec as NewGame
+import qualified TypesSpec as TS
 
 spec :: Spec
 spec = describe "Mtlstats.Actions" $ do
   startNewSeasonSpec
   startNewGameSpec
   resetYtdSpec
+  resetStandingsSpec
   addCharSpec
   removeCharSpec
-  overtimeCheckSpec
-  updateGameStatsSpec
-  validateGameDateSpec
   createPlayerSpec
+  createGoalieSpec
+  editPlayerSpec
+  editGoalieSpec
   addPlayerSpec
-  recordGoalAssistsSpec
+  addGoalieSpec
-  awardGoalSpec
+  resetCreatePlayerStateSpec
-  awardAssistSpec
+  resetCreateGoalieStateSpec
-  resetGoalDataSpec
-  assignPMinsSpec
   backHomeSpec
   scrollUpSpec
   scrollDownSpec
+  NewGame.spec
+  EditGoalie.spec
 
 startNewSeasonSpec :: Spec
 startNewSeasonSpec = describe "startNewSeason" $ do
@@ -90,8 +90,8 @@ startNewGameSpec = describe "startNewGame" $ do
 resetYtdSpec :: Spec
 resetYtdSpec = describe "resetYtd" $
   it "should reset the year-to-date stats for all players" $ do
-    ps <- replicateM 2 makePlayer
+    ps <- replicateM 2 TS.makePlayer
-    gs <- replicateM 2 makeGoalie
+    gs <- replicateM 2 TS.makeGoalie
     let
       s = newProgState
         & database . dbPlayers .~ ps
@@ -117,19 +117,52 @@ resetYtdSpec = describe "resetYtd" $
         ytd ^. gsGames        `shouldBe`    0
         ytd ^. gsMinsPlayed   `shouldBe`    0
         ytd ^. gsGoalsAllowed `shouldBe`    0
-        ytd ^. gsGoalsAgainst `shouldBe`    0
         ytd ^. gsWins         `shouldBe`    0
         ytd ^. gsLosses       `shouldBe`    0
         ytd ^. gsTies         `shouldBe`    0
         lt ^. gsGames         `shouldNotBe` 0
         lt ^. gsMinsPlayed    `shouldNotBe` 0
         lt ^. gsGoalsAllowed  `shouldNotBe` 0
-        lt ^. gsGoalsAgainst  `shouldNotBe` 0
         lt ^. gsWins          `shouldNotBe` 0
         lt ^. gsLosses        `shouldNotBe` 0
         lt ^. gsTies          `shouldNotBe` 0) $
       s ^. database . dbGoalies
 
+resetStandingsSpec :: Spec
+resetStandingsSpec = describe "resetStandings" $ do
+  let
+    home = GameStats
+      { _gmsWins         = 1
+      , _gmsLosses       = 2
+      , _gmsOvertime     = 3
+      , _gmsGoalsFor     = 4
+      , _gmsGoalsAgainst = 5
+      }
+
+    away = GameStats
+      { _gmsWins         = 6
+      , _gmsLosses       = 7
+      , _gmsOvertime     = 8
+      , _gmsGoalsFor     = 9
+      , _gmsGoalsAgainst = 10
+      }
+
+    db = newDatabase
+      & dbHomeGameStats .~ home
+      & dbAwayGameStats .~ away
+
+    ps = newProgState
+      & database .~ db
+      & resetStandings
+
+  context "home standings" $
+    it "should be reset" $
+      ps^.database.dbHomeGameStats `shouldBe` newGameStats
+
+  context "away standings" $
+    it "should be reset" $
+      ps^.database.dbAwayGameStats `shouldBe` newGameStats
+
 addCharSpec :: Spec
 addCharSpec = describe "addChar" $
   it "should add the character to the input buffer" $ let
@@ -153,208 +186,30 @@ removeCharSpec = describe "removeChar" $ do
         & removeChar
       in s ^. inputBuffer `shouldBe` "fo"
 
-overtimeCheckSpec = describe "overtimeCheck" $ do
-
-  context "tie game" $ do
-    let
-      s = newProgState
-        & progMode.gameStateL
-          %~ (gameType  ?~ HomeGame)
-          .  (homeScore ?~ 1)
-          .  (awayScore ?~ 1)
-        & overtimeCheck
-
-    it "should clear the home score" $
-      s^.progMode.gameStateL.homeScore `shouldBe` Nothing
-
-    it "should clear the away score" $
-      s^.progMode.gameStateL.awayScore `shouldBe` Nothing
-
-    it "should leave the overtimeFlag blank" $
-      s^.progMode.gameStateL.overtimeFlag `shouldBe` Nothing
-
-  context "game won" $ do
-    let
-      s = newProgState
-        & progMode.gameStateL
-          %~ (gameType  ?~ HomeGame)
-          .  (homeScore ?~ 2)
-          .  (awayScore ?~ 1)
-        & overtimeCheck
-
-    it "should not change the home score" $
-      s^.progMode.gameStateL.homeScore `shouldBe` Just 2
-
-    it "should not change the away score" $
-      s^.progMode.gameStateL.awayScore `shouldBe` Just 1
-
-    it "should set the overtimeCheck flag to False" $
-      s^.progMode.gameStateL.overtimeFlag `shouldBe` Just False
-
-  context "game lost" $ do
-    let
-      s = newProgState
-        & progMode.gameStateL
-          %~ (gameType  ?~ HomeGame)
-          .  (homeScore ?~ 1)
-          .  (awayScore ?~ 2)
-        & overtimeCheck
-
-    it "should not change the home score" $
-      s^.progMode.gameStateL.homeScore `shouldBe` Just 1
-
-    it "should not change the away score" $
-      s^.progMode.gameStateL.awayScore `shouldBe` Just 2
-
-    it "should leave the overtimeCheck flag blank" $
-      s^.progMode.gameStateL.overtimeFlag `shouldBe` Nothing
-
-updateGameStatsSpec :: Spec
-updateGameStatsSpec = describe "updateGameStats" $ do
-  let
-
-    baseStats = newGameStats
-      & gmsWins         .~ 1
-      & gmsLosses       .~ 1
-      & gmsOvertime     .~ 1
-      & gmsGoalsFor     .~ 1
-      & gmsGoalsAgainst .~ 1
-
-    s t h a o = newProgState
-      & progMode.gameStateL
-        %~ (gameType     .~ t)
-        .  (homeScore    .~ h)
-        .  (awayScore    .~ a)
-        .  (overtimeFlag .~ o)
-      & database
-        %~ (dbHomeGameStats .~ baseStats)
-        .  (dbAwayGameStats .~ baseStats)
-
-    db hw hl ho hf ha aw al ao af aa = newDatabase
-      & dbHomeGameStats
-        %~ (gmsWins         .~ hw)
-        .  (gmsLosses       .~ hl)
-        .  (gmsOvertime     .~ ho)
-        .  (gmsGoalsFor     .~ hf)
-        .  (gmsGoalsAgainst .~ ha)
-      & dbAwayGameStats
-        %~ (gmsWins         .~ aw)
-        .  (gmsLosses       .~ al)
-        .  (gmsOvertime     .~ ao)
-        .  (gmsGoalsFor     .~ af)
-        .  (gmsGoalsAgainst .~ aa)
-
-  context "home win" $
-    it "should record a home win" $ let
-      s'  = s (Just HomeGame) (Just 2) (Just 1) (Just False)
-      db' = updateGameStats s' ^. database
-      in db' `shouldBe` db 2 1 1 3 2 1 1 1 1 1
-
-  context "home loss" $
-    it "should record a home loss" $ let
-      s'  = s (Just HomeGame) (Just 1) (Just 2) (Just False)
-      db' = updateGameStats s' ^. database
-      in db' `shouldBe` db 1 2 1 2 3 1 1 1 1 1
-
-  context "home overtime loss" $
-    it "should record a home overtime" $ let
-      s'  = s (Just HomeGame) (Just 1) (Just 2) (Just True)
-      db' = updateGameStats s' ^. database
-      in db' `shouldBe` db 1 1 2 2 3 1 1 1 1 1
-
-  context "away win" $
-    it "should record an away win" $ let
-      s'  = s (Just AwayGame) (Just 1) (Just 2) (Just False)
-      db' = updateGameStats s' ^. database
-      in db' `shouldBe` db 1 1 1 1 1 2 1 1 3 2
-
-  context "away loss" $
-    it "should record an away loss" $ let
-      s'  = s (Just AwayGame) (Just 2) (Just 1) (Just False)
-      db' = updateGameStats s' ^. database
-      in db' `shouldBe` db 1 1 1 1 1 1 2 1 2 3
-
-  context "away overtime loss" $
-    it "should record an away overtime" $ let
-      s'  = s (Just AwayGame) (Just 2) (Just 1) (Just True)
-      db' = updateGameStats s' ^. database
-      in db' `shouldBe` db 1 1 1 1 1 1 1 2 2 3
-
-  context "missing game type" $
-    it "should not change anything" $ let
-      s'  = s Nothing (Just 1) (Just 2) (Just True)
-      db' = updateGameStats s' ^. database
-      in db' `shouldBe` db 1 1 1 1 1 1 1 1 1 1
-
-  context "missing home score" $
-    it "should not change anything" $ let
-      s'  = s (Just HomeGame) Nothing (Just 1) (Just True)
-      db' = updateGameStats s' ^. database
-      in db' `shouldBe` db 1 1 1 1 1 1 1 1 1 1
-
-  context "missing away score" $
-    it "should not change anything" $ let
-      s'  = s (Just HomeGame) (Just 1) Nothing (Just True)
-      db' = updateGameStats s' ^. database
-      in db' `shouldBe` db 1 1 1 1 1 1 1 1 1 1
-
-  context "missing overtime flag" $
-    it "should not change anything" $ let
-      s'  = s (Just HomeGame) (Just 1) (Just 2) Nothing
-      db' = updateGameStats s' ^. database
-      in db' `shouldBe` db 1 1 1 1 1 1 1 1 1 1
-
-validateGameDateSpec :: Spec
-validateGameDateSpec = describe "validateGameDate" $ do
-
-  context "valid date" $
-    it "should leave the date unchanged" $ do
-      let
-        s = newProgState
-          & progMode.gameStateL
-            %~ (gameYear  ?~ 2019)
-            .  (gameMonth ?~ 6)
-            .  (gameDay   ?~ 25)
-          & validateGameDate
-      s^.progMode.gameStateL.gameYear  `shouldBe` Just 2019
-      s^.progMode.gameStateL.gameMonth `shouldBe` Just 6
-      s^.progMode.gameStateL.gameDay   `shouldBe` Just 25
-
-  context "invalid date" $
-    it "should clear the date" $ do
-      let
-        s = newProgState
-          & progMode.gameStateL
-            %~ (gameYear  ?~ 2019)
-            .  (gameMonth ?~ 2)
-            .  (gameDay   ?~ 30)
-          & validateGameDate
-      s^.progMode.gameStateL.gameYear  `shouldBe` Nothing
-      s^.progMode.gameStateL.gameMonth `shouldBe` Nothing
-      s^.progMode.gameStateL.gameDay   `shouldBe` Nothing
-
-  context "missing day" $
-    it "should not change anything" $ do
-      let
-
-        gs = newGameState
-          & gameYear  ?~ 2019
-          & gameMonth ?~ 6
-
-        s = newProgState
-          & progMode.gameStateL .~ gs
-          & validateGameDate
-
-      s^.progMode.gameStateL.gameYear  `shouldBe` Just 2019
-      s^.progMode.gameStateL.gameMonth `shouldBe` Just 6
-      s^.progMode.gameStateL.gameDay   `shouldBe` Nothing
-
 createPlayerSpec :: Spec
 createPlayerSpec = describe "createPlayer" $
   it "should change the mode appropriately" $ let
     s = createPlayer newProgState
     in show (s^.progMode) `shouldBe` "CreatePlayer"
 
+createGoalieSpec :: Spec
+createGoalieSpec = describe "createGoalie" $
+  it "should change the mode appropriately" $ let
+    s = createGoalie newProgState
+    in show (s^.progMode) `shouldBe` "CreateGoalie"
+
+editPlayerSpec :: Spec
+editPlayerSpec = describe "editPlayer" $
+  it "should change the mode appropriately" $ let
+    s = editPlayer newProgState
+    in show (s^.progMode) `shouldBe` "EditPlayer"
+
+editGoalieSpec :: Spec
+editGoalieSpec = describe "editGoalie" $
+  it "should change the mode appropriately" $ let
+    s = editGoalie newProgState
+    in show (s^.progMode) `shouldBe` "EditGoalie"
+
 addPlayerSpec :: Spec
 addPlayerSpec = describe "addPlayer" $ do
   let
@@ -379,281 +234,47 @@ addPlayerSpec = describe "addPlayer" $ do
       s' = addPlayer $ s MainMenu
       in s'^.database.dbPlayers `shouldBe` [p1]
 
-recordGoalAssistsSpec :: Spec
+addGoalieSpec :: Spec
-recordGoalAssistsSpec = describe "recordGoalAssists" $ do
+addGoalieSpec = describe "addGoalie" $ do
   let
-    joe   = newPlayer 1 "Joe"   "centre"
+    g1 = newGoalie 2 "Joe"
-    bob   = newPlayer 2 "Bob"   "defense"
+    g2 = newGoalie 3 "Bob"
-    steve = newPlayer 3 "Steve" "forward"
+    db = newDatabase
-    dave  = newPlayer 4 "Dave"  "somewhere"
+      & dbGoalies .~ [g1]
-    frank = newPlayer 5 "Frank" "elsewhere"
+    s pm = newProgState
-    ps
-      = newProgState
-      & database.dbPlayers .~ [joe, bob, steve, dave, frank]
-      & progMode.gameStateL
-        %~ (goalBy              ?~ 0)
-        .  (assistsBy           .~ [1, 2])
-        .  (confirmGoalDataFlag .~ True)
-      & recordGoalAssists
-
-  mapM_
-    (\(name, n, goals, assists) -> context name $ do
-      let
-        player = (ps^.database.dbPlayers) !! n
-        stats  = M.findWithDefault newPlayerStats n $
-          ps^.progMode.gameStateL.gamePlayerStats
-
-      it ("should set the year-to-date goals to " ++ show goals) $
-        player^.pYtd.psGoals `shouldBe` goals
-
-      it ("should set the lifetime goals to " ++ show goals) $
-        player^.pLifetime.psGoals `shouldBe` goals
-
-      it ("should set the game goals to " ++ show goals) $
-        stats^.psAssists `shouldBe` assists
-
-      it ("should set the year-to-date assists to " ++ show assists) $
-        player^.pYtd.psAssists `shouldBe` assists
-
-      it ("should set the lifetime assists to " ++ show assists) $
-        player^.pLifetime.psAssists `shouldBe` assists
-
-      it ("should set the game assists to " ++ show assists) $
-        stats^.psAssists `shouldBe` assists)
-
-    --  name,    index, goals, assists
-    [ ( "Joe",   0,     1,     0       )
-    , ( "Bob",   1,     0,     1       )
-    , ( "Steve", 2,     0,     1       )
-    , ( "Dave",  3,     0,     0       )
-    ]
-
-  it "should clear the goalBy value" $
-    ps^.progMode.gameStateL.goalBy `shouldBe` Nothing
-
-  it "should clear the assistsBy list" $
-    ps^.progMode.gameStateL.assistsBy `shouldBe` []
-
-  it "should increment the pointsAccounted counter" $
-    ps^.progMode.gameStateL.pointsAccounted `shouldBe` 1
-
-  it "should clear the confirmGoalDataFlag" $
-    ps^.progMode.gameStateL.confirmGoalDataFlag `shouldBe` False
-
-awardGoalSpec :: Spec
-awardGoalSpec = describe "awardGoal" $ do
-  let
-    joe
-      = newPlayer 2 "Joe" "centre"
-      & pYtd.psGoals      .~ 1
-      & pLifetime.psGoals .~ 2
-    bob
-      = newPlayer 3 "Bob" "defense"
-      & pYtd.psGoals      .~ 3
-      & pLifetime.psGoals .~ 4
-    db
-      = newDatabase
-      & dbPlayers .~ [joe, bob]
-    joeStats
-      = newPlayerStats
-      & psGoals .~ 1
-    ps
-      = newProgState
-      & progMode.gameStateL.gamePlayerStats .~ M.singleton 0 joeStats
       & database .~ db
+      & progMode .~ pm
 
-  mapM_
+  context "data available" $
-    (\(pName, pid, ytd, lt, game) ->
+    it "should create the goalie" $ let
-      context pName $ do
+      s' = addGoalie $ s $ CreateGoalie $ newCreateGoalieState
-        let
+        & cgsNumber ?~ 3
-          ps'    = awardGoal pid ps
+        & cgsName   .~ "Bob"
-          player = (ps'^.database.dbPlayers) !! pid
+      in s'^.database.dbGoalies `shouldBe` [g1, g2]
-          gStats = (ps'^.progMode.gameStateL.gamePlayerStats) M.! pid
 
-        it ("should increment " ++ pName ++ "'s year-to-date goals") $
+  context "data unavailable" $
-          player^.pYtd.psGoals `shouldBe` ytd
+    it "should not create the goalie" $ let
+      s' = addGoalie $ s MainMenu
+      in s'^.database.dbGoalies `shouldBe` [g1]
 
-        it ("should increment " ++ pName ++ "'s lifetime goals") $
+resetCreatePlayerStateSpec :: Spec
-          player^.pLifetime.psGoals `shouldBe` lt
+resetCreatePlayerStateSpec = describe "resetCreatePlayerState" $ let
+  cps = newCreatePlayerState
+    & cpsNumber   ?~ 1
+    & cpsName     .~ "Joe"
+    & cpsPosition .~ "centre"
+  ps  = resetCreatePlayerState $
+    newProgState & progMode.createPlayerStateL .~ cps
+  in TS.compareTest (ps^.progMode.createPlayerStateL) newCreatePlayerState
 
-        it ("should increment " ++ pName ++ "'s game goals") $
+resetCreateGoalieStateSpec :: Spec
-          gStats^.psGoals `shouldBe` game)
+resetCreateGoalieStateSpec = describe "resetCreateGoalieState" $ let
-    --  player name, player id, ytd goals, lifetime goals, game goals
+  cgs = newCreateGoalieState
-    [ ( "Joe",       0,         2,         3,              2          )
+    & cgsNumber ?~ 1
-    , ( "Bob",       1,         4,         5,              1          )
+    & cgsName   .~ "Joe"
-    ]
+  ps = resetCreateGoalieState $
-
+    newProgState & progMode.createGoalieStateL .~ cgs
-  context "invalid index" $ let
+  in TS.compareTest (ps^.progMode.createGoalieStateL) newCreateGoalieState
-    ps' = awardGoal 2 ps
-    in it "should not change the database" $
-      ps'^.database `shouldBe` db
-
-  context "negative index" $ let
-    ps' = awardGoal (-1) ps
-    in it "should not change the database" $
-      ps'^.database `shouldBe` db
-
-awardAssistSpec :: Spec
-awardAssistSpec = describe "awardAssist" $ do
-  let
-    joe
-      = newPlayer 1 "Joe" "centre"
-      & pYtd.psAssists      .~ 1
-      & pLifetime.psAssists .~ 2
-    bob
-      = newPlayer 2 "Bob" "defense"
-      & pYtd.psAssists      .~ 3
-      & pLifetime.psAssists .~ 4
-    joeStats
-      = newPlayerStats
-      & psAssists .~ 1
-    ps
-      = newProgState
-      & progMode.gameStateL.gamePlayerStats .~ M.singleton 0 joeStats
-      & database.dbPlayers .~ [joe, bob]
-
-  mapM_
-    (\(pName, pid, ytd, lt, game) ->
-      context pName $ do
-        let
-          ps' = awardAssist pid ps
-          player = (ps'^.database.dbPlayers) !! pid
-          gStats = (ps'^.progMode.gameStateL.gamePlayerStats) M.! pid
-
-        it ("should increment " ++ pName ++ "'s year-to-date assists") $
-          player^.pYtd.psAssists `shouldBe` ytd
-
-        it ("should increment " ++ pName ++ "'s lifetime assists") $
-          player^.pLifetime.psAssists `shouldBe` lt
-
-        it ("should increment " ++ pName ++ "'s game assists") $
-          gStats^.psAssists `shouldBe` game)
-    --  player name, player id, ytd assists, lifetime assists, game assists
-    [ ( "Joe",       0,         2,           3,                2            )
-    , ( "Bob",       1,         4,           5,                1            )
-    ]
-
-  context "invalid index" $ let
-    ps' = awardAssist (-1) ps
-    in it "should not change anything" $
-      ps'^.database.dbPlayers `shouldBe` ps^.database.dbPlayers
-
-resetGoalDataSpec :: Spec
-resetGoalDataSpec = describe "resetGoalData" $ do
-  players <- runIO $ replicateM 5 makePlayer
-  let
-    gs
-      = newGameState
-      & goalBy              ?~ 1
-      & assistsBy           .~ [2, 3]
-      & confirmGoalDataFlag .~ True
-    ps
-      = newProgState
-      & database.dbPlayers  .~ players
-      & progMode.gameStateL .~ gs
-      & resetGoalData
-
-  it "should clear the goalBy value" $
-    ps^.progMode.gameStateL.goalBy `shouldBe` Nothing
-
-  it "should clear the assists by list" $
-    ps^.progMode.gameStateL.assistsBy `shouldBe` []
-
-  it "should clear confirmGoalDataFlag" $
-    ps^.progMode.gameStateL.confirmGoalDataFlag `shouldBe` False
-
-assignPMinsSpec :: Spec
-assignPMinsSpec = describe "assignPMins" $ let
-
-  bob = newPlayer 2 "Bob" "centre"
-    & pYtd.psPMin      .~ 3
-    & pLifetime.psPMin .~ 4
-
-  joe = newPlayer 3 "Joe" "defense"
-    & pYtd.psPMin      .~ 5
-    & pLifetime.psPMin .~ 6
-
-  ps pid = newProgState
-    & database.dbPlayers .~ [bob, joe]
-    & progMode.gameStateL
-      %~ (gamePlayerStats .~ M.fromList [(0, newPlayerStats & psPMin .~ 2)])
-      .  (selectedPlayer  .~ pid)
-
-  in mapM_
-    (\(pid, bobLt, bobYtd, bobGame, joeLt, joeYtd, joeGame) ->
-      context ("selectedPlayer = " ++ show pid) $ do
-        let ps' = assignPMins 2 $ ps pid
-
-        mapM_
-          (\(name, pid', lt, ytd, game) -> context name $ do
-            let
-              player = fromJust $ nth pid' $ ps'^.database.dbPlayers
-              gStats = ps'^.progMode.gameStateL.gamePlayerStats
-              pStats = M.findWithDefault newPlayerStats pid' gStats
-
-            context "lifetime penalty minutes" $
-              it ("should be " ++ show lt) $
-                player^.pLifetime.psPMin `shouldBe` lt
-
-            context "year-to-date penalty minutes" $
-              it ("should be " ++ show ytd) $
-                player^.pYtd.psPMin `shouldBe` ytd
-
-            context "game penalty minutes" $
-              it ("should be " ++ show game) $
-                pStats^.psPMin `shouldBe` game)
-
-          --  name,  index, lifetime, ytd,    game
-          [ ( "Bob", 0,     bobLt,    bobYtd, bobGame )
-          , ( "Joe", 1,     joeLt,    joeYtd, joeGame )
-          ]
-
-        it "should set selectedPlayer to Nothing" $
-          ps'^.progMode.gameStateL.selectedPlayer `shouldBe` Nothing)
-
-    --  index,   bob lt, bob ytd, bob game, joe lt, joe ytd, joe game
-    [ ( Just 0,  6,      5,       4,        6,      5,       0        )
-    , ( Just 1,  4,      3,       2,        8,      7,       2        )
-    , ( Just 2,  4,      3,       2,        6,      5,       0        )
-    , ( Nothing, 4,      3,       2,        6,      5,       0        )
-    ]
-
-makePlayer :: IO Player
-makePlayer = Player
-  <$> makeNum
-  <*> makeName
-  <*> makeName
-  <*> makePlayerStats
-  <*> makePlayerStats
-
-makeGoalie :: IO Goalie
-makeGoalie = Goalie
-  <$> makeNum
-  <*> makeName
-  <*> makeGoalieStats
-  <*> makeGoalieStats
-
-makePlayerStats :: IO PlayerStats
-makePlayerStats = PlayerStats
-  <$> makeNum
-  <*> makeNum
-  <*> makeNum
-
-makeGoalieStats :: IO GoalieStats
-makeGoalieStats = GoalieStats
-  <$> makeNum
-  <*> makeNum
-  <*> makeNum
-  <*> makeNum
-  <*> makeNum
-  <*> makeNum
-  <*> makeNum
-
-makeNum :: IO Int
-makeNum = randomRIO (1, 10)
-
-makeName :: IO String
-makeName = replicateM 10 $ randomRIO ('A', 'Z')
 
 backHomeSpec :: Spec
 backHomeSpec = describe "backHome" $ do
@@ -695,6 +316,7 @@ scrollUpSpec = describe "scrollUp" $ do
       ps' = scrollUp ps
       in ps'^.scrollOffset `shouldBe` 0
 
+scrollDownSpec :: Spec
 scrollDownSpec = describe "scrollDown" $
   it "should increase the scroll offset" $ let
     ps  = newProgState & scrollOffset .~ 10

test/ReportSpec.hs

@@ -21,7 +21,7 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 module ReportSpec (spec) where
 
-import Lens.Micro ((&), (?~), (%~))
+import Lens.Micro ((&), (?~))
 import Test.Hspec (Spec, context, describe, it, shouldBe)
 
 import Mtlstats.Report

test/TypesSpec.hs

@@ -21,13 +21,21 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 {-# LANGUAGE OverloadedStrings, RankNTypes #-}
 
-module TypesSpec (spec) where
+module TypesSpec
+  ( Comparable (..)
+  , spec
+  , makePlayer
+  , makeGoalie
+  , makePlayerStats
+  , makeGoalieStats
+  ) where
 
+import Control.Monad (replicateM)
 import Data.Aeson (FromJSON, ToJSON, decode, encode, toJSON)
 import Data.Aeson.Types (Value (Object))
-import Data.ByteString.Lazy (ByteString)
 import qualified Data.HashMap.Strict as HM
 import Lens.Micro (Lens', (&), (^.), (.~), (?~))
+import System.Random (randomRIO)
 import Test.Hspec (Spec, context, describe, it, shouldBe)
 
 import Mtlstats.Config
@@ -35,6 +43,9 @@ import Mtlstats.Types
 
 import qualified Types.MenuSpec as Menu
 
+class Comparable a where
+  compareTest :: a -> a -> Spec
+
 spec :: Spec
 spec = describe "Mtlstats.Types" $ do
   playerSpec
@@ -43,6 +54,9 @@ spec = describe "Mtlstats.Types" $ do
   databaseSpec
   gameStateLSpec
   createPlayerStateLSpec
+  createGoalieStateLSpec
+  editPlayerStateLSpec
+  editGoalieStateLSpec
   teamScoreSpec
   otherScoreSpec
   homeTeamSpec
@@ -58,9 +72,13 @@ spec = describe "Mtlstats.Types" $ do
   playerSearchExactSpec
   modifyPlayerSpec
   playerSummarySpec
+  playerDetailsSpec
   playerIsActiveSpec
   psPointsSpec
   addPlayerStatsSpec
+  goalieSearchSpec
+  goalieSearchExactSpec
+  goalieSummarySpec
   Menu.spec
 
 playerSpec :: Spec
@@ -79,43 +97,96 @@ databaseSpec = describe "Database" $ jsonSpec db dbJSON
 gameStateLSpec :: Spec
 gameStateLSpec = describe "gameStateL" $ lensSpec gameStateL
   -- getters
-  [ ( MainMenu,              newGameState )
+  [ ( "missing state", MainMenu,              newGameState )
-  , ( NewGame $ gs HomeGame, gs HomeGame  )
+  , ( "home game",     NewGame $ gs HomeGame, gs HomeGame  )
+  , ( "away game",     NewGame $ gs AwayGame, gs AwayGame  )
   ]
   -- setters
-  [ ( MainMenu,              gs HomeGame  )
+  [ ( "set home",     MainMenu,              gs HomeGame  )
-  , ( NewGame $ gs HomeGame, gs AwayGame  )
+  , ( "home to away", NewGame $ gs HomeGame, gs AwayGame  )
-  , ( NewGame $ gs HomeGame, newGameState )
+  , ( "away to home", NewGame $ gs AwayGame, gs HomeGame  )
+  , ( "clear home",   NewGame $ gs HomeGame, newGameState )
+  , ( "clear away",   NewGame $ gs AwayGame, newGameState )
   ]
   where gs t = newGameState & gameType ?~ t
 
 createPlayerStateLSpec :: Spec
-createPlayerStateLSpec = describe "createPlayerStateL" $ do
+createPlayerStateLSpec = describe "createPlayerStateL" $
-  context "getters" $ do
+  lensSpec createPlayerStateL
-    context "state missing" $ let
+  -- getters
-      pm  = MainMenu
+  [ ( "missing state", MainMenu,          newCreatePlayerState )
-      cps = pm^.createPlayerStateL
+  , ( "with state",    CreatePlayer cps1, cps1                 )
-      in it "should not have a number" $
+  ]
-        cps^.cpsNumber `shouldBe` Nothing
+  -- setters
+  [ ( "missing state", MainMenu,          cps1                 )
+  , ( "change state",  CreatePlayer cps1, cps2                 )
+  , ( "clear state",   CreatePlayer cps1, newCreatePlayerState )
+  ]
+  where
+    cps1 = newCreatePlayerState
+      & cpsNumber    ?~ 1
+      & cpsName      .~ "Joe"
+      & cpsPosition  .~ "centre"
+    cps2 = newCreatePlayerState
+      & cpsNumber   ?~ 2
+      & cpsName     .~ "Bob"
+      & cpsPosition .~ "defense"
 
-    context "existing state" $ let
+createGoalieStateLSpec :: Spec
-      pm  = CreatePlayer $ newCreatePlayerState & cpsNumber ?~ 1
+createGoalieStateLSpec = describe "createGoalieStateL" $
-      cps = pm^.createPlayerStateL
+  lensSpec createGoalieStateL
-      in it "should have a number of 1" $
+  -- getters
-        cps^.cpsNumber `shouldBe` Just 1
+  [ ( "missing state", MainMenu,          newCreateGoalieState )
+  , ( "with state",    CreateGoalie cgs1, cgs1                 )
+  ]
+  -- setters
+  [ ( "set state",    MainMenu,          cgs1                 )
+  , ( "change state", CreateGoalie cgs1, cgs2                 )
+  , ( "clear state",  CreateGoalie cgs1, newCreateGoalieState )
+  ]
+  where
+    cgs1 = newCreateGoalieState
+      & cgsNumber    ?~ 1
+      & cgsName      .~ "Joe"
+    cgs2 = newCreateGoalieState
+      & cgsNumber ?~ 2
+      & cgsName   .~ "Bob"
 
-  context "setters" $ do
+editPlayerStateLSpec :: Spec
-    context "state missing" $ let
+editPlayerStateLSpec = describe "editPlayerStateL" $
-      pm  = MainMenu
+  lensSpec editPlayerStateL
-      pm' = pm & createPlayerStateL.cpsNumber ?~ 1
+  -- getters
-      in it "should set the player number to 1" $
+  [ ( "missing state", MainMenu,        newEditPlayerState )
-        pm'^.createPlayerStateL.cpsNumber `shouldBe` Just 1
+  , ( "withState",     EditPlayer eps1, eps1               )
+  ]
+  -- setters
+  [ ( "set state",    MainMenu,        eps1               )
+  , ( "change state", EditPlayer eps1, eps2               )
+  , ( "clear state",  EditPlayer eps1, newEditPlayerState )
+  ]
+  where
+    eps1 = newEditPlayerState
+      & epsSelectedPlayer ?~ 1
+    eps2 = newEditPlayerState
+      & epsSelectedPlayer ?~ 2
 
-    context "existing state" $ let
+editGoalieStateLSpec :: Spec
-      pm  = CreatePlayer $ newCreatePlayerState & cpsNumber ?~ 1
+editGoalieStateLSpec = describe "editGoalieStateL" $
-      pm' = pm & createPlayerStateL.cpsNumber ?~ 2
+  lensSpec editGoalieStateL
-      in it "should set the player number to 2" $
+  -- getters
-        pm'^.createPlayerStateL.cpsNumber `shouldBe` Just 2
+  [ ( "missing state", MainMenu,        newEditGoalieState )
+  , ( "with state",    EditGoalie egs1, egs1               )
+  ]
+  -- setters
+  [ ( "set state",    MainMenu,        egs1               )
+  , ( "change state", EditGoalie egs1, egs2               )
+  , ( "clear state",  EditGoalie egs1, newEditGoalieState )
+  ]
+  where
+    egs1 = newEditGoalieState
+      & egsSelectedGoalie ?~ 1
+    egs2 = newEditGoalieState
+      & egsSelectedGoalie ?~ 2
 
 teamScoreSpec :: Spec
 teamScoreSpec = describe "teamScore" $ do
@@ -177,24 +248,23 @@ jsonSpec x j = do
       decode (encode x) `shouldBe` Just x
 
 lensSpec
-  :: (Eq a, Show s, Show a)
+  :: Comparable a
   => Lens' s a
-  -> [(s, a)]
+  -> [(String, s, a)]
-  -> [(s, a)]
+  -> [(String, s, a)]
   -> Spec
-lensSpec l gs ss = do
+lensSpec lens getters setters = do
 
   context "getters" $ mapM_
-    (\(s, x) -> context (show s) $
+    (\(label, s, x) -> context label $
-      it ("should be " ++ show x) $
+      compareTest (s^.lens) x)
-        s ^. l `shouldBe` x)
+    getters
-    gs
 
   context "setters" $ mapM_
-    (\(s, x) -> context (show s) $
+    (\(label, s, x) -> context label $ let
-      it ("should set to " ++ show x) $
+      s' = s & lens .~ x
-        (s & l .~ x) ^. l `shouldBe` x)
+      in compareTest (s'^.lens) x)
-    ss
+    setters
 
 player :: Player
 player = newPlayer 1 "Joe" "centre"
@@ -241,20 +311,18 @@ goalieStats n = newGoalieStats
   & gsGames        .~ n
   & gsMinsPlayed   .~ n + 1
   & gsGoalsAllowed .~ n + 2
-  & gsGoalsAgainst .~ n + 3
+  & gsWins         .~ n + 3
-  & gsWins         .~ n + 4
+  & gsLosses       .~ n + 4
-  & gsLosses       .~ n + 5
+  & gsTies         .~ n + 5
-  & gsTies         .~ n + 6
 
 goalieStatsJSON :: Int -> Value
 goalieStatsJSON n = Object $ HM.fromList
   [ ( "games",         toJSON n       )
   , ( "mins_played",   toJSON $ n + 1 )
   , ( "goals_allowed", toJSON $ n + 2 )
-  , ( "goals_against", toJSON $ n + 3 )
+  , ( "wins",          toJSON $ n + 3 )
-  , ( "wins",          toJSON $ n + 4 )
+  , ( "losses",        toJSON $ n + 4 )
-  , ( "losses",        toJSON $ n + 5 )
+  , ( "ties",          toJSON $ n + 5 )
-  , ( "ties",          toJSON $ n + 6 )
   ]
 
 gameStats :: Int -> GameStats
@@ -540,22 +608,22 @@ playerSearchExactSpec = describe "playerSearchExact" $ mapM_
 
 modifyPlayerSpec :: Spec
 modifyPlayerSpec = describe "modifyPlayer" $ mapM_
-  (\(pName, j, b, s) -> let
+  (\(name, j, b, s) -> let
     modifier = pLifetime.psGoals .~ 1
-    players = modifyPlayer modifier pName [joe, bob, steve]
+    players = modifyPlayer modifier name [joe, bob, steve]
-    in context ("modify " ++ pName) $ do
+    in context ("modify " ++ name) $ do
 
       context "Joe's lifetime goals" $
         it ("should be " ++ show j) $
-          head players ^. pLifetime.psGoals `shouldBe` j
+          head players^.pLifetime.psGoals `shouldBe` j
 
       context "Bob's lifetime goals" $
         it ("should be " ++ show b) $
-          (players !! 1) ^. pLifetime.psGoals `shouldBe` b
+          (players !! 1)^.pLifetime.psGoals `shouldBe` b
 
       context "Steve's lifetime goals" $
         it ("should be " ++ show s) $
-          last players ^. pLifetime.psGoals `shouldBe` s)
+          last players^.pLifetime.psGoals `shouldBe` s)
   --  player name, Joe's goals, Bob's goals, Steve's goals
   [ ( "Joe",       1,           0,           0             )
   , ( "Bob",       0,           1,           0             )
@@ -568,24 +636,54 @@ playerSummarySpec = describe "playerSummary" $
   it "should be \"Joe (2) center\"" $
     playerSummary joe `shouldBe` "Joe (2) center"
 
+playerDetailsSpec :: Spec
+playerDetailsSpec = describe "playerDetails" $
+  it "should give a detailed description" $ let
+
+    p = newPlayer 1 "Joe" "centre"
+      & pYtd .~ PlayerStats
+        { _psGoals   = 2
+        , _psAssists = 3
+        , _psPMin    = 4
+        }
+      & pLifetime .~ PlayerStats
+        { _psGoals   = 5
+        , _psAssists = 6
+        , _psPMin    = 7
+        }
+
+    expected = unlines
+      [ "               Number: 1"
+      , "                 Name: Joe"
+      , "             Position: centre"
+      , "            YTD goals: 2"
+      , "          YTD assists: 3"
+      , "     YTD penalty mins: 4"
+      , "       Lifetime goals: 5"
+      , "     Lifetime assists: 6"
+      , "Lifetime penalty mins: 7"
+      ]
+
+    in playerDetails p `shouldBe` expected
+
 playerIsActiveSpec :: Spec
 playerIsActiveSpec = describe "playerIsActive" $ do
   let
-    pState = newPlayerStats
+    pStats = newPlayerStats
       & psGoals   .~ 10
       & psAssists .~ 11
       & psPMin    .~ 12
-    player = newPlayer 1 "Joe" "centre" & pLifetime .~ pState
+    p = newPlayer 1 "Joe" "centre" & pLifetime .~ pStats
 
   mapM_
-    (\(label, player', expected) -> context label $
+    (\(label, p', expected) -> context label $
       it ("should be " ++ show expected) $
-        playerIsActive player' `shouldBe` expected)
+        playerIsActive p' `shouldBe` expected)
-    --  label,                player,                       expected
+    --  label,                player,                  expected
-    [ ( "not active",         player,                       False    )
+    [ ( "not active",         p,                       False    )
-    , ( "has goal",           player & pYtd.psGoals   .~ 1, True     )
+    , ( "has goal",           p & pYtd.psGoals   .~ 1, True     )
-    , ( "has assist",         player & pYtd.psAssists .~ 1, True     )
+    , ( "has assist",         p & pYtd.psAssists .~ 1, True     )
-    , ( "has penalty minute", player & pYtd.psPMin    .~ 1, True     )
+    , ( "has penalty minute", p & pYtd.psPMin    .~ 1, True     )
     ]
 
 psPointsSpec :: Spec
@@ -633,6 +731,57 @@ addPlayerStatsSpec = describe "addPlayerStats" $ do
     it "should be 9" $
       s3^.psPMin `shouldBe` 9
 
+goalieSearchSpec :: Spec
+goalieSearchSpec = describe "goalieSearch" $ do
+  let
+    goalies =
+      [ newGoalie 2 "Joe"
+      , newGoalie 3 "Bob"
+      , newGoalie 5 "Steve"
+      ]
+    result n = (n, goalies!!n)
+
+  context "partial match" $
+    it "should return Joe and Steve" $
+      goalieSearch "e" goalies `shouldBe` [result 0, result 2]
+
+  context "no match" $
+    it "should return an empty list" $
+      goalieSearch "x" goalies `shouldBe` []
+
+  context "exact match" $
+    it "should return Steve" $
+      goalieSearch "Bob" goalies `shouldBe` [result 1]
+
+goalieSearchExactSpec :: Spec
+goalieSearchExactSpec = describe "goalieSearchExact" $ do
+  let
+    goalies =
+      [ newGoalie 2 "Joe"
+      , newGoalie 3 "Bob"
+      , newGoalie 5 "Steve"
+      ]
+    result n = (n, goalies!!n)
+
+  mapM_
+    (\(name, num) -> context name $
+      it ("should return " ++ name) $
+        goalieSearchExact name goalies `shouldBe` Just (result num))
+    --  name,    num
+    [ ( "Joe",   0   )
+    , ( "Bob",   1   )
+    , ( "Steve", 2   )
+    ]
+
+  context "Greg" $
+    it "should return Nothing" $
+      goalieSearchExact "Greg" goalies `shouldBe` Nothing
+
+goalieSummarySpec :: Spec
+goalieSummarySpec = describe "goalieSummary" $
+  it "should provide a summary string" $
+    goalieSummary (newGoalie 2 "Joe") `shouldBe` "Joe (2)"
+
 joe :: Player
 joe = newPlayer 2 "Joe" "center"
 
@@ -641,3 +790,111 @@ bob = newPlayer 3 "Bob" "defense"
 
 steve :: Player
 steve = newPlayer 5 "Steve" "forward"
+
+-- | Creates a 'Player'
+makePlayer :: IO Player
+makePlayer = Player
+  <$> makeNum
+  <*> makeName
+  <*> makeName
+  <*> makePlayerStats
+  <*> makePlayerStats
+
+-- | Creates a 'Goalie'
+makeGoalie :: IO Goalie
+makeGoalie = Goalie
+  <$> makeNum
+  <*> makeName
+  <*> makeGoalieStats
+  <*> makeGoalieStats
+
+-- | Creates a 'PlayerStats' value
+makePlayerStats :: IO PlayerStats
+makePlayerStats = PlayerStats
+  <$> makeNum
+  <*> makeNum
+  <*> makeNum
+
+-- | Creates a 'GoalieStats' value
+makeGoalieStats :: IO GoalieStats
+makeGoalieStats = GoalieStats
+  <$> makeNum
+  <*> makeNum
+  <*> makeNum
+  <*> makeNum
+  <*> makeNum
+  <*> makeNum
+
+
+makeNum :: IO Int
+makeNum = randomRIO (1, 10)
+
+makeName :: IO String
+makeName = replicateM 10 $ randomRIO ('A', 'Z')
+
+instance Comparable GoalieStats where
+  compareTest actual expected = mapM_
+    (\(name, lens) -> describe name $
+      it ("should be " ++ show (expected^.lens)) $
+        actual^.lens `shouldBe` expected^.lens)
+    --  name,             lens
+    [ ( "gsGames",        gsGames        )
+    , ( "gsMinsPlayed",   gsMinsPlayed   )
+    , ( "gsGoalsAllowed", gsGoalsAllowed )
+    , ( "gsWins",         gsWins         )
+    , ( "gsLosses",       gsLosses       )
+    , ( "gsTies",         gsTies         )
+    ]
+
+instance Comparable GameState where
+  compareTest actual expected =
+    it ("should be " ++ show expected) $
+      actual `shouldBe` expected
+
+instance Comparable CreatePlayerState where
+  compareTest actual expected = do
+
+    describe "cpsNumber" $
+      it ("should be " ++ show (expected^.cpsNumber)) $
+        actual^.cpsNumber `shouldBe` expected^.cpsNumber
+
+    describe "cpsName" $
+      it ("should be " ++ expected^.cpsName) $
+        actual^.cpsName `shouldBe` expected^.cpsName
+
+    describe "cpsPosition" $
+      it ("should be " ++ expected^.cpsPosition) $
+        actual^.cpsPosition `shouldBe` expected^.cpsPosition
+
+instance Comparable EditPlayerState where
+  compareTest actual expected = do
+
+    describe "epsSelectedPlayer" $
+      it ("should be " ++ show (expected^.epsSelectedPlayer)) $
+        actual^.epsSelectedPlayer `shouldBe` expected^.epsSelectedPlayer
+
+    describe "epsMode" $
+      it ("should be " ++ show (expected^.epsMode)) $
+        actual^.epsMode `shouldBe` expected^.epsMode
+
+instance Comparable EditGoalieState where
+  compareTest actual expected = do
+
+    describe "egsSelectedGoalie" $
+      it ("should be " ++ show (expected^.egsSelectedGoalie)) $
+        actual^.egsSelectedGoalie `shouldBe` expected^.egsSelectedGoalie
+
+    describe "egsMode" $
+      it ("should be " ++ show (expected^.egsMode)) $
+        actual^.egsMode `shouldBe` expected^.egsMode
+
+instance Comparable CreateGoalieState where
+  compareTest actual expected = do
+
+    describe "cgsNuber" $
+      it("should be " ++ show (expected^.cgsNumber)) $
+        actual^.cgsNumber `shouldBe` expected^.cgsNumber
+
+    describe "cgsName" $
+      it ("should be " ++ expected^.cgsName) $
+        actual^.cgsName `shouldBe` expected^.cgsName

test/UtilSpec.hs

@@ -49,18 +49,19 @@ nthSpec = describe "nth" $ mapM_
 
 modifyNthSpec  :: Spec
 modifyNthSpec = describe "modifyNth" $ do
+  let list = [1, 2, 3] :: [Int]
 
   context "in bounds" $
     it "should modify the value" $
-      modifyNth 1 succ [1, 2, 3] `shouldBe` [1, 3, 3]
+      modifyNth 1 succ list `shouldBe` [1, 3, 3]
 
   context "out of bounds" $
     it "should not modify the value" $
-      modifyNth 3 succ [1, 2, 3] `shouldBe` [1, 2, 3]
+      modifyNth 3 succ list `shouldBe` [1, 2, 3]
 
   context "negative index" $
     it "should not modify the value" $
-      modifyNth (-1) succ [1, 2, 3] `shouldBe` [1, 2, 3]
+      modifyNth (-1) succ list `shouldBe` [1, 2, 3]
 
 updateMapSpec :: Spec
 updateMapSpec = describe "updateMap" $ do
@@ -68,7 +69,7 @@ updateMapSpec = describe "updateMap" $ do
     input = M.fromList [(1, 2), (3, 5)]
 
   context "key found" $ let
-    expected = M.fromList [(1, 3), (3, 5)]
+    expected = M.fromList [(1, 3), (3, 5)] :: M.Map Int Int
     in it "should update the value" $
       updateMap 1 10 succ input `shouldBe` expected
 
@@ -79,7 +80,7 @@ updateMapSpec = describe "updateMap" $ do
 
 sliceSpec :: Spec
 sliceSpec = describe "slice" $ do
-  let list = [2, 4, 6, 8]
+  let list = [2, 4, 6, 8] :: [Int]
 
   context "sublist" $
     it "should return the sublist" $