version 0.14.0

output report to a text file (report.txt)

.gitignore

@@ -1,3 +1,6 @@
 .stack-work/
 mtlstats.cabal
+.vagrant
+data
+*.log
 *~

ChangeLog.md

@@ -1,5 +1,21 @@
 # Changelog for mtlstats
 
+## 0.14.0
+- Fixed a bug that was causing shutouts to not be recorded
+- Output report to a text file (report.txt)
+
+## 0.13.0
+- Added autocomplete to player position prompt
+- Don't prompt for lifetime stats on rookie player/goalie creation
+- Ask whether a player/goalie is active on creation
+- Don't ask which goalie to assign the game to when there's only one
+
+## 0.12.0
+- Edit lifetime stats on new player/goalie creation
+- Sort goalies by minutes played
+- Subsort players by lifetime points
+- Changed wording on edit menus
+
 ## 0.11.0
 - Added active flag to players/goalies
 - Clear rookie flag on new (regular) season

Vagrantfile

@@ -0,0 +1,10 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.configure("2") do |config|
+  config.vm.box = "ubuntu/xenial64"
+  config.vm.provision "shell", path: "vagrant/provision.sh"
+  config.vm.provider :virtualbox do |v|
+    v.customize ["modifyvm", :id, "--memory", 4096]
+  end
+end

package.yaml

@@ -1,5 +1,5 @@
 name:                mtlstats
-version:             0.11.0
+version:             0.14.0
 github:              "mtlstats/mtlstats"
 license:             GPL-3
 author:              "Jonathan Lamothe"

src/Mtlstats/Actions.hs

@@ -162,10 +162,14 @@ addPlayer :: ProgState -> ProgState
 addPlayer s = fromMaybe s $ do
   let cps = s^.progMode.createPlayerStateL
   num   <- cps^.cpsNumber
+  rFlag <- cps^.cpsRookieFlag
+  aFlag <- cps^.cpsActiveFlag
   let
     name   = cps^.cpsName
     pos    = cps^.cpsPosition
     player = newPlayer num name pos
+      & pRookie .~ rFlag
+      & pActive .~ aFlag
   Just $ s & database.dbPlayers
     %~ (++[player])
 
@@ -174,9 +178,13 @@ addGoalie :: ProgState -> ProgState
 addGoalie s = fromMaybe s $ do
   let cgs = s^.progMode.createGoalieStateL
   num   <- cgs^.cgsNumber
+  rFlag <- cgs^.cgsRookieFlag
+  aFlag <- cgs^.cgsActiveFlag
   let
     name   = cgs^.cgsName
     goalie = newGoalie num name
+      & gRookie .~ rFlag
+      & gActive .~ aFlag
   Just $ s & database.dbGoalies
     %~ (++[goalie])
 

src/Mtlstats/Actions/NewGame.hs

@@ -124,12 +124,13 @@ awardGoal n ps = ps
     (\m -> let
       stats = M.findWithDefault newPlayerStats n m
       in M.insert n (stats & psGoals %~ succ) m)
-  & database.dbPlayers %~ map
+  & database.dbPlayers %~ zipWith
-    (\(i, p) -> if i == n
+    (\i p -> if i == n
       then p
         & pYtd.psGoals      %~ succ
         & pLifetime.psGoals %~ succ
-      else p) . zip [0..]
+      else p)
+    [0..]
 
 -- | Awards an assist to a player
 awardAssist
@@ -142,12 +143,13 @@ awardAssist n ps = ps
     (\m -> let
       stats = M.findWithDefault newPlayerStats n m
       in M.insert n (stats & psAssists %~ succ) m)
-  & database.dbPlayers %~ map
+  & database.dbPlayers %~ zipWith
-    (\(i, p) -> if i == n
+    (\i p -> if i == n
       then p
         & pYtd.psAssists      %~ succ
         & pLifetime.psAssists %~ succ
-      else p) . zip [0..]
+      else p)
+    [0..]
 
 -- | Resets the entered data for the current goal
 resetGoalData :: ProgState -> ProgState

src/Mtlstats/Actions/NewGame/GoalieInput.hs

@@ -36,8 +36,12 @@ import Mtlstats.Util
 
 -- | Attempts to finish game goalie entry
 finishGoalieEntry :: ProgState -> ProgState
-finishGoalieEntry s = s & progMode.gameStateL.gameGoaliesRecorded
+finishGoalieEntry s = case M.toList $ s^.progMode.gameStateL.gameGoalieStats of
-  .~ not (null $ s^.progMode.gameStateL.gameGoalieStats)
+  []         -> s
+  [(gid, _)] -> setGameGoalie gid s'
+  _          -> s'
+  where
+    s' = s & progMode.gameStateL.gameGoaliesRecorded .~ True
 
 -- | Records the goalie's game stats
 recordGoalieStats :: ProgState -> ProgState
@@ -86,15 +90,19 @@ setGameGoalie gid s = fromMaybe s $ do
   won     <- gameWon gs
   lost    <- gameLost gs
   tied    <- gs^.overtimeFlag
+  shutout <- (==0) <$> otherScore gs
+
   let
     w  = if won then 1 else 0
     l  = if lost then 1 else 0
     t  = if tied then 1 else 0
+    so = if shutout then 1 else 0
 
     updateStats
       = (gsWins     +~ w)
       . (gsLosses   +~ l)
       . (gsTies     +~ t)
+      . (gsShutouts +~ so)
 
     updateGoalie
       = (gYtd      %~ updateStats)

src/Mtlstats/Config.hs

@@ -44,3 +44,11 @@ maxAssists = 2
 -- | The length of a typical game (in minutes)
 gameLength :: Int
 gameLength = 60
+
+-- | Report output filename
+reportFilename :: FilePath
+reportFilename = "report.txt"
+
+-- | Number of columns in report file
+reportCols :: Int
+reportCols = 79

src/Mtlstats/Control.hs

@@ -21,20 +21,15 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 module Mtlstats.Control (dispatch) where
 
-import Control.Monad (join)
-import Control.Monad.Trans.State (gets, modify)
-import Data.Maybe (fromJust)
 import Lens.Micro ((^.))
-import Lens.Micro.Extras (view)
-import qualified UI.NCurses as C
 
-import Mtlstats.Actions
+import Mtlstats.Control.CreateGoalie
-import Mtlstats.Control.TitleScreen
+import Mtlstats.Control.CreatePlayer
 import Mtlstats.Control.EditGoalie
 import Mtlstats.Control.EditPlayer
 import Mtlstats.Control.EditStandings
 import Mtlstats.Control.NewGame
-import Mtlstats.Handlers
+import Mtlstats.Control.TitleScreen
 import Mtlstats.Menu
 import Mtlstats.Prompt
 import Mtlstats.Types
@@ -48,15 +43,8 @@ dispatch s = case s^.progMode of
   NewSeason flag      -> newSeasonC flag
   NewGame gs          -> newGameC gs
   EditMenu            -> editMenuC
-  CreatePlayer cps
+  CreatePlayer cps    -> createPlayerC cps
-    | null $ cps^.cpsNumber   -> getPlayerNumC
+  CreateGoalie cgs    -> createGoalieC cgs
-    | 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
   (EditStandings esm) -> editStandingsC esm
@@ -73,85 +61,3 @@ newSeasonC True  = menuController newSeasonMenu
 
 editMenuC :: Controller
 editMenuC = menuController editMenu
-
-getPlayerNumC :: Controller
-getPlayerNumC = Controller
-  { drawController   = drawPrompt playerNumPrompt
-  , handleController = \e -> do
-    promptHandler playerNumPrompt e
-    return True
-  }
-
-getPlayerNameC :: Controller
-getPlayerNameC = Controller
-  { drawController   = drawPrompt playerNamePrompt
-  , handleController = \e -> do
-    promptHandler playerNamePrompt e
-    return True
-  }
-
-getPlayerPosC :: Controller
-getPlayerPosC = Controller
-  { drawController   = drawPrompt playerPosPrompt
-  , handleController = \e -> do
-    promptHandler playerPosPrompt e
-    return True
-  }
-
-confirmCreatePlayerC :: Controller
-confirmCreatePlayerC = Controller
-  { drawController = \s -> do
-    let cps = s^.progMode.createPlayerStateL
-    C.drawString $ "  Player number: " ++ show (fromJust $ cps^.cpsNumber) ++ "\n"
-    C.drawString $ "    Player name: " ++ cps^.cpsName ++ "\n"
-    C.drawString $ "Player position: " ++ cps^.cpsPosition ++ "\n\n"
-    C.drawString "Create player: are you sure?  (Y/N)"
-    return C.CursorInvisible
-  , handleController = \e -> do
-    case ynHandler e of
-      Just True -> do
-        modify addPlayer
-        join $ gets $ view $ progMode.createPlayerStateL.cpsSuccessCallback
-      Just False ->
-        join $ gets $ view $ progMode.createPlayerStateL.cpsFailureCallback
-      Nothing -> return ()
-    return True
-  }
-
-getGoalieNumC :: Controller
-getGoalieNumC = Controller
-  { drawController = drawPrompt goalieNumPrompt
-  , handleController = \e -> do
-    promptHandler goalieNumPrompt e
-    return True
-  }
-
-getGoalieNameC :: Controller
-getGoalieNameC = Controller
-  { drawController = drawPrompt goalieNamePrompt
-  , handleController = \e -> do
-    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/CreateGoalie.hs

@@ -0,0 +1,107 @@
+{- |
+
+mtlstats
+Copyright (C) 1984, 1985, 2019, 2020 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.CreateGoalie (createGoalieC) where
+
+import Control.Monad.Trans.State (gets, modify)
+import Lens.Micro ((^.), (.~), (?~), (%~), to)
+import qualified UI.NCurses as C
+
+import Mtlstats.Actions
+import Mtlstats.Format
+import Mtlstats.Handlers
+import Mtlstats.Prompt
+import Mtlstats.Types
+
+-- | Handles goalie creation
+createGoalieC :: CreateGoalieState -> Controller
+createGoalieC cgs
+  | null $ cgs^.cgsNumber     = getGoalieNumC
+  | null $ cgs^.cgsName       = getGoalieNameC
+  | null $ cgs^.cgsRookieFlag = getRookieFlagC
+  | null $ cgs^.cgsActiveFlag = getActiveFlagC
+  | otherwise                 = confirmCreateGoalieC
+
+getGoalieNumC :: Controller
+getGoalieNumC = promptController goalieNumPrompt
+
+getGoalieNameC :: Controller
+getGoalieNameC = promptController goalieNamePrompt
+
+getRookieFlagC :: Controller
+getRookieFlagC = Controller
+  { drawController = const $ do
+    C.drawString "Is this goalie a rookie? (Y/N)"
+    return C.CursorInvisible
+  , handleController = \e -> do
+    modify $ case ynHandler e of
+      Just True -> progMode.createGoalieStateL
+        %~ (cgsRookieFlag ?~ True)
+        .  (cgsActiveFlag ?~ True)
+      rf -> progMode.createGoalieStateL.cgsRookieFlag .~ rf
+    return True
+  }
+
+getActiveFlagC :: Controller
+getActiveFlagC = Controller
+  { drawController = const $ do
+    C.drawString "Is this goalie active? (Y/N)"
+    return C.CursorInvisible
+  , handleController = \e -> do
+    modify $ progMode.createGoalieStateL.cgsActiveFlag .~ ynHandler e
+    return True
+  }
+
+confirmCreateGoalieC :: Controller
+confirmCreateGoalieC = Controller
+  { drawController = \s -> do
+    let cgs = s^.progMode.createGoalieStateL
+    C.drawString $ unlines
+      $  labelTable
+         [ ( "Goalie number", maybe "?" show $ cgs^.cgsNumber     )
+         , ( "Goalie name",   cgs^.cgsName                        )
+         , ( "Rookie",        maybe "?" show $ cgs^.cgsRookieFlag )
+         , ( "Active",        maybe "?" show $ cgs^.cgsActiveFlag )
+         ]
+      ++ [ ""
+         , "Create goalie: are you sure?  (Y/N)"
+         ]
+    return C.CursorInvisible
+  , handleController = \e -> do
+    cgs <- gets (^.progMode.createGoalieStateL)
+    let
+      success = cgs^.cgsSuccessCallback
+      failure = cgs^.cgsFailureCallback
+    case ynHandler e of
+      Just True -> do
+        gid <- gets (^.database.dbGoalies.to length)
+        let rookie = cgs^.cgsRookieFlag == Just True
+        modify addGoalie
+        if rookie
+          then success
+          else modify $ progMode.editGoalieStateL
+            %~ (egsSelectedGoalie ?~ gid)
+            .  (egsMode           .~ EGLtGames True)
+            .  (egsCallback       .~ success)
+      Just False -> failure
+      Nothing    -> return ()
+    return True
+  }

src/Mtlstats/Control/CreatePlayer.hs

@@ -0,0 +1,112 @@
+{- |
+
+mtlstats
+Copyright (C) 1984, 1985, 2019, 2020 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.CreatePlayer (createPlayerC) where
+
+import Control.Monad.Trans.State (gets, modify)
+import Lens.Micro ((^.), (.~), (?~), (%~), to)
+import qualified UI.NCurses as C
+
+import Mtlstats.Actions
+import Mtlstats.Format
+import Mtlstats.Handlers
+import Mtlstats.Prompt
+import Mtlstats.Types
+
+-- | Handles player creation
+createPlayerC :: CreatePlayerState -> Controller
+createPlayerC cps
+  | null $ cps^.cpsNumber     = getPlayerNumC
+  | null $ cps^.cpsName       = getPlayerNameC
+  | null $ cps^.cpsPosition   = getPlayerPosC
+  | null $ cps^.cpsRookieFlag = getRookieFlagC
+  | null $ cps^.cpsActiveFlag = getActiveFlagC
+  | otherwise                 = confirmCreatePlayerC
+
+getPlayerNumC :: Controller
+getPlayerNumC = promptController playerNumPrompt
+
+getPlayerNameC :: Controller
+getPlayerNameC = promptController playerNamePrompt
+
+getPlayerPosC :: Controller
+getPlayerPosC = promptController playerPosPrompt
+
+getRookieFlagC :: Controller
+getRookieFlagC = Controller
+  { drawController = const $ do
+    C.drawString "Is this player a rookie? (Y/N)"
+    return C.CursorInvisible
+  , handleController = \e -> do
+    modify $ case ynHandler e of
+      Just True -> progMode.createPlayerStateL
+        %~ (cpsRookieFlag ?~ True)
+        .  (cpsActiveFlag ?~ True)
+      rf -> progMode.createPlayerStateL.cpsRookieFlag .~ rf
+    return True
+  }
+
+getActiveFlagC :: Controller
+getActiveFlagC = Controller
+  { drawController = const $ do
+    C.drawString "Is the player active? (Y/N)"
+    return C.CursorInvisible
+  , handleController = \e -> do
+    modify $ progMode.createPlayerStateL.cpsActiveFlag .~ ynHandler e
+    return True
+  }
+
+confirmCreatePlayerC :: Controller
+confirmCreatePlayerC = Controller
+  { drawController = \s -> do
+    let cps = s^.progMode.createPlayerStateL
+    C.drawString $ unlines
+      $  labelTable
+         [ ( "Player number",   maybe "?" show $ cps^.cpsNumber     )
+         , ( "Player name",     cps^.cpsName                        )
+         , ( "Player position", cps^.cpsPosition                    )
+         , ( "Rookie",          maybe "?" show $ cps^.cpsRookieFlag )
+         , ( "Active",          maybe "?" show $ cps^.cpsActiveFlag )
+         ]
+      ++ [ ""
+         , "Create player: are you sure?  (Y/N)"
+         ]
+    return C.CursorInvisible
+  , handleController = \e -> do
+    cps <- gets (^.progMode.createPlayerStateL)
+    let
+      success = cps^.cpsSuccessCallback
+      failure = cps^.cpsFailureCallback
+    case ynHandler e of
+      Just True -> do
+        pid <- gets (^.database.dbPlayers.to length)
+        let rookie = cps^.cpsRookieFlag == Just True
+        modify addPlayer
+        if rookie
+          then success
+          else modify $ progMode.editPlayerStateL
+            %~ (epsSelectedPlayer ?~ pid)
+            .  (epsMode           .~ EPLtGoals True)
+            .  (epsCallback       .~ success)
+      Just False -> failure
+      Nothing -> return ()
+    return True
+  }

src/Mtlstats/Control/EditGoalie.hs

@@ -39,13 +39,14 @@ import Mtlstats.Util
 editGoalieC :: EditGoalieState -> Controller
 editGoalieC egs
   | null $ egs^.egsSelectedGoalie = selectC
-  | otherwise = editC $ egs^.egsMode
+  | otherwise = editC (egs^.egsCallback) (egs^.egsMode)
 
 selectC :: Controller
 selectC = promptController goalieToEditPrompt
 
-editC :: EditGoalieMode -> Controller
+editC :: Action () -> EditGoalieMode -> Controller
-editC = \case
+editC cb =
+  ( \case
     EGMenu          -> menuC
     EGNumber        -> numberC
     EGName          -> nameC
@@ -65,63 +66,76 @@ editC = \case
     EGLtWins b      -> ltWinsC b
     EGLtLosses b    -> ltLossesC b
     EGLtTies        -> ltTiesC
+  ) <*> return cb
 
-menuC :: Controller
+menuC :: Action () -> Controller
-menuC = menuControllerWith header editGoalieMenu
+menuC _ = menuControllerWith header editGoalieMenu
 
-numberC :: Controller
+numberC :: Action () -> Controller
-numberC = promptController editGoalieNumberPrompt
+numberC = promptController . editGoalieNumberPrompt
 
-nameC :: Controller
+nameC :: Action () -> Controller
-nameC = promptController editGoalieNamePrompt
+nameC = promptController . editGoalieNamePrompt
 
-ytdMenuC :: Controller
+ytdMenuC :: Action () -> Controller
-ytdMenuC = menuControllerWith header editGoalieYtdMenu
+ytdMenuC _ = menuControllerWith header editGoalieYtdMenu
 
-lifetimeMenuC :: Controller
+lifetimeMenuC :: Action () -> Controller
-lifetimeMenuC = menuControllerWith header editGoalieLtMenu
+lifetimeMenuC _ = menuControllerWith header editGoalieLtMenu
 
-ytdGamesC :: Bool -> Controller
+ytdGamesC :: Bool -> Action () -> Controller
-ytdGamesC = promptController . editGoalieYtdGamesPrompt
+ytdGamesC = curry $ promptController .
+  uncurry editGoalieYtdGamesPrompt
 
-ytdMinsC :: Bool -> Controller
+ytdMinsC :: Bool -> Action () -> Controller
-ytdMinsC = promptController . editGoalieYtdMinsPrompt
+ytdMinsC = curry $ promptController .
+  uncurry editGoalieYtdMinsPrompt
 
-ytdGoalsC :: Bool -> Controller
+ytdGoalsC :: Bool -> Action () -> Controller
-ytdGoalsC = promptController . editGoalieYtdGoalsPrompt
+ytdGoalsC = curry $ promptController .
+  uncurry editGoalieYtdGoalsPrompt
 
-ytdShutoutsC :: Bool -> Controller
+ytdShutoutsC :: Bool -> Action () -> Controller
-ytdShutoutsC = promptController . editGoalieYtdShutoutsPrompt
+ytdShutoutsC = curry $ promptController .
+  uncurry editGoalieYtdShutoutsPrompt
 
-ytdWinsC :: Bool -> Controller
+ytdWinsC :: Bool -> Action () -> Controller
-ytdWinsC = promptController . editGoalieYtdWinsPrompt
+ytdWinsC = curry $ promptController .
+  uncurry editGoalieYtdWinsPrompt
 
-ytdLossesC :: Bool -> Controller
+ytdLossesC :: Bool -> Action () -> Controller
-ytdLossesC = promptController . editGoalieYtdLossesPrompt
+ytdLossesC = curry $ promptController .
+  uncurry editGoalieYtdLossesPrompt
 
-ytdTiesC :: Controller
+ytdTiesC :: Action () -> Controller
-ytdTiesC = promptController editGoalieYtdTiesPrompt
+ytdTiesC = promptController . editGoalieYtdTiesPrompt
 
-ltGamesC :: Bool -> Controller
+ltGamesC :: Bool -> Action () -> Controller
-ltGamesC = promptController . editGoalieLtGamesPrompt
+ltGamesC = curry $ promptController .
+  uncurry editGoalieLtGamesPrompt
 
-ltMinsC :: Bool -> Controller
+ltMinsC :: Bool -> Action () -> Controller
-ltMinsC = promptController . editGoalieLtMinsPrompt
+ltMinsC = curry $ promptController .
+  uncurry editGoalieLtMinsPrompt
 
-ltGoalsC :: Bool -> Controller
+ltGoalsC :: Bool -> Action() -> Controller
-ltGoalsC = promptController . editGoalieLtGoalsPrompt
+ltGoalsC = curry $ promptController .
+  uncurry editGoalieLtGoalsPrompt
 
-ltShutoutsC :: Bool -> Controller
+ltShutoutsC :: Bool -> Action () -> Controller
-ltShutoutsC = promptController . editGoalieLtShutoutsPrompt
+ltShutoutsC = curry $ promptController .
+  uncurry editGoalieLtShutoutsPrompt
 
-ltWinsC :: Bool -> Controller
+ltWinsC :: Bool -> Action () -> Controller
-ltWinsC = promptController . editGoalieLtWinsPrompt
+ltWinsC = curry $ promptController .
+  uncurry editGoalieLtWinsPrompt
 
-ltLossesC :: Bool -> Controller
+ltLossesC :: Bool -> Action () -> Controller
-ltLossesC = promptController . editGoalieLtLossesPrompt
+ltLossesC = curry $ promptController .
+  uncurry editGoalieLtLossesPrompt
 
-ltTiesC :: Controller
+ltTiesC :: Action () -> Controller
-ltTiesC = promptController editGoalieLtTiesPrompt
+ltTiesC = promptController . editGoalieLtTiesPrompt
 
 header :: ProgState -> C.Update ()
 header s = C.drawString $ fromMaybe "" $ do

src/Mtlstats/Control/EditPlayer.hs

@@ -37,7 +37,8 @@ import Mtlstats.Util
 editPlayerC :: EditPlayerState -> Controller
 editPlayerC eps
   | null $ eps^.epsSelectedPlayer = selectPlayerC
-  | otherwise = case eps^.epsMode of
+  | otherwise =
+    ( case eps^.epsMode of
       EPMenu         -> menuC
       EPNumber       -> numberC
       EPName         -> nameC
@@ -50,45 +51,50 @@ editPlayerC eps
       EPLtGoals    b -> ltGoalsC    b
       EPLtAssists  b -> ltAssistsC  b
       EPLtPMin       -> ltPMinC
+    ) $ eps^.epsCallback
 
 selectPlayerC :: Controller
 selectPlayerC = promptController playerToEditPrompt
 
-menuC :: Controller
+menuC :: Action () -> Controller
-menuC = menuControllerWith header editPlayerMenu
+menuC _ = menuControllerWith header editPlayerMenu
 
-numberC :: Controller
+numberC :: Action () -> Controller
-numberC = promptController editPlayerNumPrompt
+numberC = promptController . editPlayerNumPrompt
 
-nameC :: Controller
+nameC :: Action () -> Controller
-nameC = promptController editPlayerNamePrompt
+nameC = promptController . editPlayerNamePrompt
 
-positionC :: Controller
+positionC :: Action () -> Controller
-positionC = promptController editPlayerPosPrompt
+positionC = promptController . editPlayerPosPrompt
 
-ytdC :: Controller
+ytdC :: Action () -> Controller
-ytdC = menuControllerWith header editPlayerYtdMenu
+ytdC _ = menuControllerWith header editPlayerYtdMenu
 
-lifetimeC :: Controller
+lifetimeC :: Action () -> Controller
-lifetimeC = menuControllerWith header editPlayerLtMenu
+lifetimeC _ = menuControllerWith header editPlayerLtMenu
 
-ytdGoalsC :: Bool -> Controller
+ytdGoalsC :: Bool -> Action () -> Controller
-ytdGoalsC = promptController . editPlayerYtdGoalsPrompt
+ytdGoalsC batchMode callback = promptController $
+  editPlayerYtdGoalsPrompt batchMode callback
 
-ytdAssistsC :: Bool -> Controller
+ytdAssistsC :: Bool -> Action () -> Controller
-ytdAssistsC = promptController . editPlayerYtdAssistsPrompt
+ytdAssistsC batchMode callback = promptController $
+  editPlayerYtdAssistsPrompt batchMode callback
 
-ytdPMinC :: Controller
+ytdPMinC :: Action () -> Controller
-ytdPMinC = promptController editPlayerYtdPMinPrompt
+ytdPMinC = promptController . editPlayerYtdPMinPrompt
 
-ltGoalsC :: Bool -> Controller
+ltGoalsC :: Bool -> Action () -> Controller
-ltGoalsC = promptController . editPlayerLtGoalsPrompt
+ltGoalsC batchMode callback = promptController $
+  editPlayerLtGoalsPrompt batchMode callback
 
-ltAssistsC :: Bool -> Controller
+ltAssistsC :: Bool -> Action () -> Controller
-ltAssistsC = promptController . editPlayerLtAssistsPrompt
+ltAssistsC batchMode callback = promptController $
+  editPlayerLtAssistsPrompt batchMode callback
 
-ltPMinC :: Controller
+ltPMinC :: Action () -> Controller
-ltPMinC = promptController editPlayerLtPMinPrompt
+ltPMinC = promptController . editPlayerLtPMinPrompt
 
 header :: ProgState -> C.Update ()
 header s = C.drawString $ fromMaybe "" $ do

src/Mtlstats/Control/NewGame.hs

@@ -21,13 +21,15 @@ 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 Control.Monad.IO.Class (liftIO)
+import Control.Monad.Trans.State (get, 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.Config
 import Mtlstats.Control.NewGame.GoalieInput
 import Mtlstats.Format
 import Mtlstats.Handlers
@@ -211,8 +213,11 @@ reportC = Controller
       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
+      C.EventCharacter '\n' -> do
+        get >>= liftIO . writeFile reportFilename . unlines . report reportCols
+        modify backHome
+
       _ -> return ()
     return True
   }

src/Mtlstats/Helpers/Position.hs

@@ -0,0 +1,89 @@
+{- |
+
+mtlstats
+Copyright (C) 1984, 1985, 2019, 2020 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.Helpers.Position
+  ( posSearch
+  , posSearchExact
+  , posCallback
+  , getPositions
+  ) where
+
+import Control.Monad.Trans.State (gets)
+import Data.Char (toUpper)
+import Data.List (isInfixOf)
+import Data.Maybe (fromMaybe)
+import qualified Data.Set as S
+import Lens.Micro ((^.), to)
+
+import Mtlstats.Types
+import Mtlstats.Util
+
+-- | Searches the 'Database' for all the positions used
+posSearch
+  :: String
+  -- ^ The search string
+  -> Database
+  -- ^ The database
+  -> [(Int, String)]
+  -- ^ A list of result indices and their values
+posSearch sStr db = filter sFunc $ zip [0..] ps
+  where
+    sFunc (_, pos) = map toUpper sStr `isInfixOf` map toUpper pos
+    ps = getPositions db
+
+-- | Searches the 'Database' for an exact position
+posSearchExact
+  :: String
+  -- ^ The search string
+  -> Database
+  -- ^ The database
+  -> Maybe Int
+  -- ^ The index of the result (or 'Nothing' if not found)
+posSearchExact sStr db = case filter sFunc $ zip [0..] ps of
+  []      -> Nothing
+  (n,_):_ -> Just n
+  where
+    sFunc (_, pos) = sStr == pos
+    ps = getPositions db
+
+-- | Builds a callback function for when a 'Player' position is
+-- selected
+posCallback
+  :: (String -> Action ())
+  -- ^ The raw callback function
+  -> Maybe Int
+  -- ^ The index number of the position selected or 'Nothing' if blank
+  -> Action ()
+  -- ^ The action to perform
+posCallback callback = \case
+  Nothing -> callback ""
+  Just n  -> do
+    ps <- gets (^.database.to getPositions)
+    let pos = fromMaybe "" $ nth n ps
+    callback pos
+
+-- | Extracts a list of positions from a 'Database'
+getPositions :: Database -> [String]
+getPositions = do
+  raw <- map (^.pPosition) . (^.dbPlayers)
+  return $ S.toList $ S.fromList raw

src/Mtlstats/Menu.hs

@@ -170,10 +170,11 @@ gameGoalieMenu s = let
       goalie <- nth n $ s^.database.dbGoalies
       Just (n, goalie))
     gids
-  in Menu title () $ map
+  in Menu title () $ zipWith
-    (\(ch, (gid, goalie)) -> MenuItem ch (goalieSummary goalie) $
+    (\ch (gid, goalie) -> MenuItem ch (goalieSummary goalie) $
-      modify $ GI.setGameGoalie gid) $
+      modify $ GI.setGameGoalie gid)
-    zip ['1'..] goalies
+    ['1'..]
+    goalies
 
 -- | The edit menu
 editMenu :: Menu ()

src/Mtlstats/Menu/EditGoalie.hs

@@ -38,12 +38,12 @@ editGoalieMenu = Menu "EDIT GOALTENDER" () $ map
   (\(ch, label, action) -> MenuItem ch label $ modify action)
 
   --  key, label,                 value
-  [ ( 'A', "EDIT NUMBER",         set EGNumber   )
+  [ ( 'A', "NUMBER",              set EGNumber   )
-  , ( 'B', "EDIT NAME",           set EGName     )
+  , ( 'B', "NAME",                set EGName     )
-  , ( 'C', "TOGGLE ROOKIE FLAG",  toggleRookie   )
+  , ( 'C', "ROOKIE FLAG",         toggleRookie   )
-  , ( 'D', "TOGGLE ACTIVE FLAG",  toggleActive   )
+  , ( 'D', "ACTIVE FLAG",         toggleActive   )
-  , ( 'E', "EDIT YTD STATS",      set EGYtd      )
+  , ( 'E', "YTD STATS",           set EGYtd      )
-  , ( 'F', "EDIT LIFETIME STATS", set EGLifetime )
+  , ( 'F', "LIFETIME STATS",      set EGLifetime )
   , ( 'R', "RETURN TO EDIT MENU", edit           )
   ]
 
@@ -56,14 +56,14 @@ editGoalieMenu = Menu "EDIT GOALTENDER" () $ map
 editGoalieYtdMenu :: Menu ()
 editGoalieYtdMenu = editMenu "EDIT GOALTENDER YEAR-TO-DATE"
   --  key, label,                 value
-  [ ( 'A', "EDIT ALL YTD STATS",  EGYtdGames    True  )
+  [ ( 'A', "ALL YTD STATS",       EGYtdGames    True  )
-  , ( 'B', "EDIT YTD GAMES",      EGYtdGames    False )
+  , ( 'B', "YTD GAMES",           EGYtdGames    False )
-  , ( 'C', "EDIT YTD MINUTES",    EGYtdMins     False )
+  , ( 'C', "YTD MINUTES",         EGYtdMins     False )
-  , ( 'D', "EDIT YTD GOALS",      EGYtdGoals    False )
+  , ( 'D', "YTD GOALS",           EGYtdGoals    False )
-  , ( 'E', "EDIT YTD SHUTOUTS",   EGYtdShutouts False )
+  , ( 'E', "YTD SHUTOUTS",        EGYtdShutouts False )
-  , ( 'F', "EDIT YTD WINS",       EGYtdWins     False )
+  , ( 'F', "YTD WINS",            EGYtdWins     False )
-  , ( 'G', "EDIT YTD LOSSES",     EGYtdLosses   False )
+  , ( 'G', "YTD LOSSES",          EGYtdLosses   False )
-  , ( 'H', "EDIT YTD TIES",       EGYtdTies           )
+  , ( 'H', "YTD TIES",            EGYtdTies           )
   , ( 'R', "RETURN TO EDIT MENU", EGMenu              )
   ]
 
@@ -72,14 +72,14 @@ editGoalieLtMenu :: Menu ()
 editGoalieLtMenu = editMenu
   "EDIT GOALTENDER LIFETIME"
   --  key, label,                 value
-  [ ( 'A', "EDIT ALL LIFETIME STATS", EGLtGames    True  )
+  [ ( 'A', "ALL LIFETIME STATS",  EGLtGames    True  )
-  , ( 'B', "EDIT LIFETIME GAMES",     EGLtGames    False )
+  , ( 'B', "LIFETIME GAMES",      EGLtGames    False )
-  , ( 'C', "EDIT LIFETIME MINUTES",   EGLtMins     False )
+  , ( 'C', "LIFETIME MINUTES",    EGLtMins     False )
-  , ( 'D', "EDIT LIFETIME GOALS",     EGLtGoals    False )
+  , ( 'D', "LIFETIME GOALS",      EGLtGoals    False )
-  , ( 'E', "EDIT LIFETIME SHUTOUTS",  EGLtShutouts False )
+  , ( 'E', "LIFETIME SHUTOUTS",   EGLtShutouts False )
-  , ( 'F', "EDIT LIFETIME WINS",      EGLtWins     False )
+  , ( 'F', "LIFETIME WINS",       EGLtWins     False )
-  , ( 'G', "EDIT LIFETIME LOSSES",    EGLtLosses   False )
+  , ( 'G', "LIFETIME LOSSES",     EGLtLosses   False )
-  , ( 'H', "EDIT LIFETIME TIES",      EGLtTies           )
+  , ( 'H', "LIFETIME TIES",       EGLtTies           )
   , ( 'R', "RETURN TO EDIT MENU", EGMenu             )
   ]
 

src/Mtlstats/Menu/EditPlayer.hs

@@ -38,13 +38,13 @@ editPlayerMenu = Menu "EDIT PLAYER" () $ map
   (\(ch, label, action) -> MenuItem ch label $ modify action)
 
   --  key, label,                 value
-  [ ( 'A', "EDIT NUMBER",         set EPNumber   )
+  [ ( 'A', "NUMBER",              set EPNumber   )
-  , ( 'B', "EDIT NAME",           set EPName     )
+  , ( 'B', "NAME",                set EPName     )
-  , ( 'C', "EDIT POSITION",       set EPPosition )
+  , ( 'C', "POSITION",            set EPPosition )
-  , ( 'D', "TOGGLE ROOKIE FLAG",  toggleRookie   )
+  , ( 'D', "ROOKIE FLAG",         toggleRookie   )
-  , ( 'E', "TOGGLE ACTIVE FLAG",  toggleActive   )
+  , ( 'E', "ACTIVE FLAG",         toggleActive   )
-  , ( 'F', "EDIT YTD STATS",      set EPYtd      )
+  , ( 'F', "YTD STATS",           set EPYtd      )
-  , ( 'G', "EDIT LIFETIME STATS", set EPLifetime )
+  , ( 'G', "LIFETIME STATS",      set EPLifetime )
   , ( 'R', "RETURN TO EDIT MENU", edit           )
   ]
 
@@ -58,10 +58,10 @@ editPlayerYtdMenu :: Menu ()
 editPlayerYtdMenu = editMenu
   "EDIT PLAYER YEAR-TO-DATE"
   --  key, label,                        value
-  [ ( 'A', "EDIT ALL YTD STATS",         EPYtdGoals   True  )
+  [ ( 'A', "ALL YTD STATS",              EPYtdGoals   True  )
-  , ( 'B', "EDIT YTD GOALS",             EPYtdGoals   False )
+  , ( 'B', "YTD GOALS",                  EPYtdGoals   False )
-  , ( 'C', "EDIT YTD ASSISTS",           EPYtdAssists False )
+  , ( 'C', "YTD ASSISTS",                EPYtdAssists False )
-  , ( 'D', "EDIT YTD PENALTY MINS",      EPYtdPMin          )
+  , ( 'D', "YTD PENALTY MINS",           EPYtdPMin          )
   , ( 'R', "RETURN TO PLAYER EDIT MENU", EPMenu             )
   ]
 
@@ -70,10 +70,10 @@ editPlayerLtMenu :: Menu ()
 editPlayerLtMenu = editMenu
   "EDIT PLAYER LIFETIME"
   --  key, label,                        value
-  [ ( 'A', "EDIT ALL LIFETIME STATS",    EPLtGoals   True  )
+  [ ( 'A', "ALL LIFETIME STATS",         EPLtGoals   True  )
-  , ( 'B', "EDIT LIFETIME GOALS",        EPLtGoals   False )
+  , ( 'B', "LIFETIME GOALS",             EPLtGoals   False )
-  , ( 'C', "EDIT LIFETIME ASSITS",       EPLtAssists False )
+  , ( 'C', "LIFETIME ASSITS",            EPLtAssists False )
-  , ( 'D', "EDIT LIFETIME PENALTY MINS", EPLtPMin          )
+  , ( 'D', "LIFETIME PENALTY MINS",      EPLtPMin          )
   , ( 'R', "RETURN TO EDIT PLAYER MENU", EPMenu            )
   ]
 

src/Mtlstats/Prompt.hs

@@ -42,6 +42,7 @@ module Mtlstats.Prompt (
   goalieNamePrompt,
   selectPlayerPrompt,
   selectGoaliePrompt,
+  selectPositionPrompt,
   playerToEditPrompt
 ) where
 
@@ -56,6 +57,7 @@ import qualified UI.NCurses as C
 
 import Mtlstats.Actions
 import Mtlstats.Config
+import Mtlstats.Helpers.Position
 import Mtlstats.Types
 import Mtlstats.Util
 
@@ -162,9 +164,7 @@ numPromptWithFallback pStr fallback act = Prompt
   , promptProcessChar = \ch str -> if isDigit ch
     then str ++ [ch]
     else str
-  , promptAction      = \inStr -> case readMaybe inStr of
+  , promptAction      = maybe fallback act . readMaybe
-      Nothing -> fallback
-      Just n  -> act n
   , promptSpecialKey  = const $ return ()
   }
 
@@ -172,11 +172,12 @@ numPromptWithFallback pStr fallback act = Prompt
 -- to
 newSeasonPrompt :: Prompt
 newSeasonPrompt = prompt
-  { promptProcessChar = \ch str -> if isAlphaNum ch
+  { promptProcessChar = \ch str -> if validChar ch
     then str ++ [toUpper ch]
     else str
   }
   where
+
     prompt = strPrompt "Filename to save database: " $ \fn ->
       if null fn
       then modify backHome
@@ -184,6 +185,8 @@ newSeasonPrompt = prompt
         saveDatabase $ fn ++ ".json"
         modify $ progMode .~ NewSeason True
 
+    validChar = (||) <$> isAlphaNum <*> (=='-')
+
 -- | Builds a selection prompt
 selectPrompt :: SelectParams a -> Prompt
 selectPrompt params = Prompt
@@ -233,7 +236,7 @@ playerNamePrompt = namePrompt "Player name: " $
 
 -- | Prompts for a new player's position
 playerPosPrompt :: Prompt
-playerPosPrompt = ucStrPrompt "Player position: " $
+playerPosPrompt = selectPositionPrompt "Player position: " $
   modify . (progMode.createPlayerStateL.cpsPosition .~)
 
 -- | Prompts tor the goalie's number
@@ -304,6 +307,24 @@ selectGoaliePrompt pStr callback = selectPrompt SelectParams
     modify $ progMode .~ CreateGoalie cgs
   }
 
+-- | Selects (or creates) a player position
+selectPositionPrompt
+  :: String
+  -- ^ The 'Prompt' string
+  -> (String -> Action ())
+  -- ^ The action to perform when a value is entered
+  -> Prompt
+selectPositionPrompt pStr callback = selectPrompt SelectParams
+  { spPrompt = pStr
+  , spSearchHeader = "Positions:"
+  , spSearch = posSearch
+  , spSearchExact = posSearchExact
+  , spElemDesc = id
+  , spProcessChar = \ch -> (++ [toUpper ch])
+  , spCallback = posCallback callback
+  , spNotFound = callback
+  }
+
 playerToEditPrompt :: Prompt
 playerToEditPrompt = selectPlayerPrompt "Player to edit: " $
   modify . (progMode.editPlayerStateL.epsSelectedPlayer .~)

src/Mtlstats/Prompt/EditGoalie.hs

@@ -52,85 +52,119 @@ goalieToEditPrompt = selectGoaliePrompt "Goalie to edit: " $
   modify . (progMode.editGoalieStateL.egsSelectedGoalie .~)
 
 -- | Prompt to edit a goalie's number
-editGoalieNumberPrompt :: Prompt
+editGoalieNumberPrompt
+  :: Action ()
+  -- ^ Action to perform on completion
+  -> Prompt
 editGoalieNumberPrompt = editNum "Goalie number: " EGMenu
   (gNumber .~)
 
 -- | Prompt to edit a goalie's name
-editGoalieNamePrompt :: Prompt
+editGoalieNamePrompt
-editGoalieNamePrompt = namePrompt "Goalie name: " $ \name ->
+  :: Action ()
+  -- ^ Action to perform on completion
+  -> Prompt
+editGoalieNamePrompt cb = namePrompt "Goalie name: " $ \name -> do
   if null name
     then goto EGMenu
     else doEdit EGMenu $ gName .~ name
+  cb
 
 -- | Prompt to edit a goalie's YTD games played
 editGoalieYtdGamesPrompt
   :: Bool
   -- ^ Indicates whether or not we're in batch mode
+  -> Action ()
+  -- ^ Action to perform on completion
   -> Prompt
-editGoalieYtdGamesPrompt batchMode =
+editGoalieYtdGamesPrompt batchMode cb =
   editNum "Year-to-date games played: " mode
-  (gYtd.gsGames .~)
+  (gYtd.gsGames .~) cb'
   where
-    mode = if batchMode then EGYtdMins True else EGYtd
+    (mode, cb') = if batchMode
+      then (EGYtdMins True, return ())
+      else (EGYtd, cb)
 
 -- | Prompt to edit a goalie's YTD minutes played
 editGoalieYtdMinsPrompt
   :: Bool
   -- ^ Indicates whether or not we're in batch mode
+  -> Action ()
+  -- ^ Action to perform on completion
   -> Prompt
-editGoalieYtdMinsPrompt batchMode =
+editGoalieYtdMinsPrompt batchMode cb =
   editNum "Year-to-date minutes played: " mode
-  (gYtd.gsMinsPlayed .~)
+  (gYtd.gsMinsPlayed .~) cb'
   where
-    mode = if batchMode then EGYtdGoals True else EGYtd
+    (mode, cb') = if batchMode
+      then (EGYtdGoals True, return ())
+      else (EGYtd, cb)
 
 -- | Prompt to edit a goalie's YTD goales allowed
 editGoalieYtdGoalsPrompt
   :: Bool
   -- ^ Indicates whether or not we're in batch mode
+  -> Action ()
+  -- ^ Action to perform on completion
   -> Prompt
-editGoalieYtdGoalsPrompt batchMode =
+editGoalieYtdGoalsPrompt batchMode cb =
   editNum "Year-to-date goals allowed: " mode
-  (gYtd.gsGoalsAllowed .~)
+  (gYtd.gsGoalsAllowed .~) cb'
   where
-    mode = if batchMode then EGYtdShutouts True else EGYtd
+    (mode, cb') = if batchMode
+      then (EGYtdShutouts True, return ())
+      else (EGYtd, cb)
 
 -- | Prompt to edit a goalie's YTD shutouts
 editGoalieYtdShutoutsPrompt
   :: Bool
   -- ^ Indicates whether or not we're in batch mode
+  -> Action ()
+  -- ^ Action to perform on completion
   -> Prompt
-editGoalieYtdShutoutsPrompt batchMode =
+editGoalieYtdShutoutsPrompt batchMode cb =
   editNum "Year-to-date shutouts: " mode
-  (gYtd.gsShutouts .~)
+  (gYtd.gsShutouts .~) cb'
   where
-    mode = if batchMode then EGYtdWins True else EGYtd
+    (mode, cb') = if batchMode
+      then (EGYtdWins True, return ())
+      else (EGYtd, cb)
 
 -- | Prompt to edit a goalie's YTD wins
 editGoalieYtdWinsPrompt
   :: Bool
   -- ^ Indicates whether or not we're in batch mode
+  -> Action ()
+  -- ^ Action to perform on completion
   -> Prompt
-editGoalieYtdWinsPrompt batchMode =
+editGoalieYtdWinsPrompt batchMode cb =
   editNum "Year-to-date wins: " mode
-  (gYtd.gsWins .~)
+  (gYtd.gsWins .~) cb'
   where
-    mode = if batchMode then EGYtdLosses True else EGYtd
+    (mode, cb') = if batchMode
+      then (EGYtdLosses True, return ())
+      else (EGYtd, cb)
 
 -- | Prompt to edit a goalie's YTD losses
 editGoalieYtdLossesPrompt
   :: Bool
   -- ^ Indicates whether or not we're in batch mode
+  -> Action ()
+  -- ^ Action to perform on completion
   -> Prompt
-editGoalieYtdLossesPrompt batchMode =
+editGoalieYtdLossesPrompt batchMode cb =
   editNum "Year-to-date losses: " mode
-  (gYtd.gsLosses .~)
+  (gYtd.gsLosses .~) cb'
   where
-    mode = if batchMode then EGYtdTies else EGYtd
+    (mode, cb') = if batchMode
+      then (EGYtdTies, return ())
+      else (EGYtd, cb)
 
 -- | Prompt to edit a goalie's YTD ties
-editGoalieYtdTiesPrompt :: Prompt
+editGoalieYtdTiesPrompt
+  :: Action ()
+  -- ^ Action to perform on completion
+  -> Prompt
 editGoalieYtdTiesPrompt = editNum "Year-to-date ties: " EGYtd
   (gYtd.gsTies .~)
 
@@ -138,70 +172,97 @@ editGoalieYtdTiesPrompt = editNum "Year-to-date ties: " EGYtd
 editGoalieLtGamesPrompt
   :: Bool
   -- ^ Indicates whether or not we're in batch mode
+  -> Action ()
+  -- ^ Action to perform on completion
   -> Prompt
-editGoalieLtGamesPrompt batchMode =
+editGoalieLtGamesPrompt batchMode cb =
   editNum "Lifetime games played: " mode
-  (gLifetime.gsGames .~)
+  (gLifetime.gsGames .~) cb'
   where
-    mode = if batchMode then EGLtMins True else EGLifetime
+    (mode, cb') = if batchMode
+      then (EGLtMins True, return ())
+      else (EGLifetime, cb)
 
 -- | Prompt to edit a goalie's lifetime minutes played
 editGoalieLtMinsPrompt
   :: Bool
   -- ^ Indicates whether or not we're in batch mode
+  -> Action ()
+  -- ^ Action to perform on completion
   -> Prompt
-editGoalieLtMinsPrompt batchMode =
+editGoalieLtMinsPrompt batchMode cb =
   editNum "Lifetime minutes played: " mode
-  (gLifetime.gsMinsPlayed .~)
+  (gLifetime.gsMinsPlayed .~) cb'
   where
-    mode = if batchMode then EGLtGoals True else EGLifetime
+    (mode, cb') = if batchMode
+      then (EGLtGoals True, return ())
+      else (EGLifetime, cb)
 
 -- | Prompt to edit a goalie's lifetime goals allowed
 editGoalieLtGoalsPrompt
   :: Bool
   -- ^ Indicates whether or not we're in batch mode
+  -> Action ()
+  -- ^ Action to perform on completion
   -> Prompt
-editGoalieLtGoalsPrompt batchMode =
+editGoalieLtGoalsPrompt batchMode cb =
   editNum "Lifetime goals allowed: " mode
-  (gLifetime.gsGoalsAllowed .~)
+  (gLifetime.gsGoalsAllowed .~) cb'
   where
-    mode = if batchMode then EGLtShutouts True else EGLifetime
+    (mode, cb') = if batchMode
+      then (EGLtShutouts True, return ())
+      else (EGLifetime, cb)
 
 -- | Prompt to edit a goalie's lifetime shutouts
 editGoalieLtShutoutsPrompt
   :: Bool
   -- ^ Indicates whether or not we're in batch mode
+  -> Action ()
+  -- ^ Action to perform on completion
   -> Prompt
-editGoalieLtShutoutsPrompt batchMode =
+editGoalieLtShutoutsPrompt batchMode cb =
   editNum "Lifetime shutouts: " mode
-  (gLifetime.gsShutouts .~)
+  (gLifetime.gsShutouts .~) cb'
   where
-    mode = if batchMode then EGLtWins True else EGLifetime
+    (mode, cb') = if batchMode
+      then (EGLtWins True, return ())
+      else (EGLifetime, cb)
 
 -- | Prompt to edit a goalie's lifetime wins
 editGoalieLtWinsPrompt
   :: Bool
   -- ^ Indicates whether or not we're in batch mode
+  -> Action ()
+  -- ^ Action to perform on completion
   -> Prompt
-editGoalieLtWinsPrompt batchMode =
+editGoalieLtWinsPrompt batchMode cb =
   editNum "Lifetime wins: " mode
-  (gLifetime.gsWins .~)
+  (gLifetime.gsWins .~) cb'
   where
-    mode = if batchMode then EGLtLosses True else EGLifetime
+    (mode, cb') = if batchMode
+      then (EGLtLosses True, return ())
+      else (EGLifetime, cb)
 
 -- | Prompt to edit a goalie's lifetime losses
 editGoalieLtLossesPrompt
   :: Bool
   -- ^ Indicates whether or not we're in batch mode
+  -> Action ()
+  -- ^ Action to perform on completion
   -> Prompt
-editGoalieLtLossesPrompt batchMode =
+editGoalieLtLossesPrompt batchMode cb =
   editNum "Lifetime losses: " mode
-  (gLifetime.gsLosses .~)
+  (gLifetime.gsLosses .~) cb'
   where
-    mode = if batchMode then EGLtTies else EGLifetime
+    (mode, cb') = if batchMode
+      then (EGLtTies, return ())
+      else (EGLifetime, cb)
 
 -- | Prompt to edit a goalie's lifetime ties
-editGoalieLtTiesPrompt :: Prompt
+editGoalieLtTiesPrompt
+  :: Action ()
+  -- ^ Action to perform on completion
+  -> Prompt
 editGoalieLtTiesPrompt = editNum "Lifetime ties: " EGLifetime
   (gLifetime.gsTies .~)
 
@@ -209,10 +270,13 @@ editNum
   :: String
   -> EditGoalieMode
   -> (Int -> Goalie -> Goalie)
+  -> Action ()
   -> Prompt
-editNum pStr mode f = numPromptWithFallback pStr
+editNum pStr mode f cb = numPromptWithFallback pStr
-  (goto mode)
+  (goto mode >> cb)
-  (doEdit mode . f)
+  (\num -> do
+    doEdit mode $ f num
+    cb)
 
 doEdit :: EditGoalieMode -> (Goalie -> Goalie) -> Action ()
 doEdit mode f = do

src/Mtlstats/Prompt/EditPlayer.hs

@@ -39,46 +39,68 @@ import Mtlstats.Prompt
 import Mtlstats.Types
 
 -- | Prompt to edit a player's number
-editPlayerNumPrompt :: Prompt
+editPlayerNumPrompt
+  :: Action ()
+  -- ^ The action to be performed upon completion
+  -> Prompt
 editPlayerNumPrompt = editNum "Player number: " EPMenu
   (pNumber .~)
 
 -- | Prompt to edit a player's name
-editPlayerNamePrompt :: Prompt
+editPlayerNamePrompt
-editPlayerNamePrompt = namePrompt "Player name: " $ \name ->
+  :: Action ()
+  -- ^ The action to be performed upon completion
+  -> Prompt
+editPlayerNamePrompt callback = namePrompt "Player name: " $ \name -> do
   if null name
     then goto EPMenu
     else doEdit EPMenu $ pName .~ name
+  callback
 
 -- | Prompt to edit a player's position
-editPlayerPosPrompt :: Prompt
+editPlayerPosPrompt
-editPlayerPosPrompt = ucStrPrompt "Player position: " $ \pos ->
+  :: Action ()
+  -- ^ The action to be performed upon completion
+  -> Prompt
+editPlayerPosPrompt callback = selectPositionPrompt "Player position: " $ \pos -> do
   if null pos
     then goto EPMenu
     else doEdit EPMenu $ pPosition .~ pos
+  callback
 
 -- | Prompt to edit a player's year-to-date goals
 editPlayerYtdGoalsPrompt
   :: Bool
   -- ^ Indicates wheter or not we're editing in batch mode
+  -> Action ()
+  -- ^ The action to be performed upon completion
   -> Prompt
-editPlayerYtdGoalsPrompt batchMode = editNum "Year-to-date goals: " mode
+editPlayerYtdGoalsPrompt batchMode callback = editNum "Year-to-date goals: " mode
-  (pYtd.psGoals .~)
+  (pYtd.psGoals .~) callback'
   where
-    mode = if batchMode then EPYtdAssists True else EPYtd
+    (mode, callback') = if batchMode
+      then (EPYtdAssists True, return ())
+      else (EPYtd, callback)
 
 -- | Prompt to edit a player's year-to-date assists
 editPlayerYtdAssistsPrompt
   :: Bool
   -- ^ Indicates wheter or not we're editing in batch mode
+  -> Action ()
+  -- ^ The action to be performed upon completion
   -> Prompt
-editPlayerYtdAssistsPrompt batchMode = editNum "Year-to-date assists: " mode
+editPlayerYtdAssistsPrompt batchMode callback = editNum "Year-to-date assists: " mode
-  (pYtd.psAssists .~)
+  (pYtd.psAssists .~) callback'
   where
-    mode = if batchMode then EPYtdPMin else EPYtd
+    (mode, callback') = if batchMode
+      then (EPYtdPMin, return ())
+      else (EPYtd, callback)
 
 -- | Prompt to edit a player's year-to-date penalty minutes
-editPlayerYtdPMinPrompt :: Prompt
+editPlayerYtdPMinPrompt
+  :: Action ()
+  -- ^ The action to be performed upon completion
+  -> Prompt
 editPlayerYtdPMinPrompt = editNum "Year-to-date penalty minutes: " EPYtd
   (pYtd.psPMin .~)
 
@@ -86,24 +108,35 @@ editPlayerYtdPMinPrompt = editNum "Year-to-date penalty minutes: " EPYtd
 editPlayerLtGoalsPrompt
   :: Bool
   -- ^ Indicates wheter or not we're editing in batch mode
+  -> Action ()
+  -- ^ The action to be performed upon completion
   -> Prompt
-editPlayerLtGoalsPrompt batchMode = editNum "Lifetime goals: " mode
+editPlayerLtGoalsPrompt batchMode callback = editNum "Lifetime goals: " mode
-  (pLifetime.psGoals .~)
+  (pLifetime.psGoals .~) callback'
   where
-    mode = if batchMode then EPLtAssists True else EPLifetime
+    (mode, callback') = if batchMode
+      then (EPLtAssists True, return ())
+      else (EPLifetime, callback)
 
 -- | Prompt to edit a player's lifetime assists
 editPlayerLtAssistsPrompt
   :: Bool
   -- ^ Indicates wheter or not we're editing in batch mode
+  -> Action ()
+  -- ^ The action to be performed upon completion
   -> Prompt
-editPlayerLtAssistsPrompt batchMode = editNum "Lifetime assists: " mode
+editPlayerLtAssistsPrompt batchMode callback = editNum "Lifetime assists: " mode
-  (pLifetime.psAssists .~)
+  (pLifetime.psAssists .~) callback'
   where
-    mode = if batchMode then EPLtPMin else EPLifetime
+    (mode, callback') = if batchMode
+      then (EPLtPMin, return ())
+      else (EPLifetime, callback)
 
 -- | Prompt to edit a player's lifetime penalty minutes
-editPlayerLtPMinPrompt :: Prompt
+editPlayerLtPMinPrompt
+  :: Action ()
+  -- ^ The action to be performed upon completion
+  -> Prompt
 editPlayerLtPMinPrompt = editNum "Lifetime penalty minutes: " EPLifetime
   (pLifetime.psPMin .~)
 
@@ -111,10 +144,13 @@ editNum
   :: String
   -> EditPlayerMode
   -> (Int -> Player -> Player)
+  -> Action ()
   -> Prompt
-editNum pStr mode f = numPromptWithFallback pStr
+editNum pStr mode f callback = numPromptWithFallback pStr
-  (goto mode)
+  (goto mode >> callback)
-  (doEdit mode . f)
+  (\num -> do
+    doEdit mode $ f num
+    callback)
 
 doEdit :: EditPlayerMode -> (Player -> Player) -> Action ()
 doEdit mode f = do

src/Mtlstats/Report.hs

@@ -117,7 +117,7 @@ gameStatsReport width s = let
   gs = s^.progMode.gameStateL
   db = s^.database
 
-  playerStats = mapMaybe
+  playerStats = sortPlayers $ mapMaybe
     (\(pid, stats) -> do
       p <- nth pid $ db^.dbPlayers
       Just (p, stats))
@@ -139,7 +139,7 @@ yearToDateStatsReport :: Int -> ProgState -> [String]
 yearToDateStatsReport width s = let
   db = s^.database
 
-  playerStats = sortOn (Down . psPoints . snd)
+  playerStats = sortPlayers
     $ map (\p -> (p, p^.pYtd))
     $ filter playerIsActive
     $ db^.dbPlayers
@@ -156,7 +156,7 @@ lifetimeStatsReport :: Int -> ProgState -> [String]
 lifetimeStatsReport width s = let
   db = s^.database
 
-  playerStats = sortOn (Down . psPoints . snd)
+  playerStats = sortPlayers
     $ map (\p -> (p, p^.pLifetime))
     $ db^.dbPlayers
 
@@ -241,8 +241,7 @@ filteredPlayerReport width label criteria showTotals lineNumbers ps = let
     else repeat ""
 
   table = overlayLast olayText
-    $ map (\(ln, line) -> overlay ln $ centre width line)
+    $ zipWith (\ln line -> overlay ln $ centre width line) lnOverlay
-    $ zip lnOverlay
     $ complexTable ([right, left] ++ repeat right)
     $ tHeader : body ++ if showTotals
       then [separator, totals]
@@ -261,8 +260,10 @@ goalieReport width showTotals lineNumbers goalieData = let
     then "GOALTENDING TOTALS"
     else ""
 
+  goalieData' = sortGoalies goalieData
+
   tData = foldl addGoalieStats newGoalieStats
-    $ map snd goalieData
+    $ map snd goalieData'
 
   header =
     [ CellText "NO."
@@ -287,7 +288,7 @@ goalieReport width showTotals lineNumbers goalieData = let
       [ CellText $ show (goalie^.gNumber) ++ " "
       , CellText $ goalieName goalie
       ] ++ rowCells stats)
-    goalieData
+    goalieData'
 
   separator
     =  replicate 2 (CellText "")
@@ -299,8 +300,7 @@ goalieReport width showTotals lineNumbers goalieData = let
     then "" : [right 2 $ show x | x <- [(1 :: Int)..]]
     else repeat ""
 
-  in map (\(ln, line) -> overlay ln $ centre width line)
+  in zipWith (\ln line -> overlay ln $ centre width line) lnOverlay
-    $ zip lnOverlay
     $ overlayLast olayText
     $ complexTable ([right, left] ++ repeat right)
     $ header : body ++ if showTotals
@@ -309,6 +309,8 @@ goalieReport width showTotals lineNumbers goalieData = let
 
 gameGoalieReport :: Int -> [(Goalie, GoalieStats)] -> [String]
 gameGoalieReport width goalieData = let
+  goalieData' = sortGoalies goalieData
+
   header =
     [ CellText "NO."
     , CellText "GOALTENDER"
@@ -325,8 +327,16 @@ gameGoalieReport width goalieData = let
       , CellText $ show $ stats^.gsGoalsAllowed
       , CellText $ showFloating $ gsAverage stats
       ])
-    goalieData
+    goalieData'
 
   in map (centre width)
     $ complexTable ([right, left] ++ repeat right)
     $ header : body
+
+sortPlayers :: [(Player, PlayerStats)] -> [(Player, PlayerStats)]
+sortPlayers = sortOn $ Down . \(p, ps) ->
+  (psPoints ps, psPoints $ p^.pLifetime)
+
+sortGoalies :: [(Goalie, GoalieStats)] -> [(Goalie, GoalieStats)]
+sortGoalies = sortOn $ Down . \(g, gs) ->
+  (gs^.gsMinsPlayed, g^.gLifetime.gsMinsPlayed)

src/Mtlstats/Types.hs

@@ -88,19 +88,25 @@ module Mtlstats.Types (
   cpsNumber,
   cpsName,
   cpsPosition,
+  cpsRookieFlag,
+  cpsActiveFlag,
   cpsSuccessCallback,
   cpsFailureCallback,
   -- ** CreateGoalieState Lenses
   cgsNumber,
   cgsName,
+  cgsRookieFlag,
+  cgsActiveFlag,
   cgsSuccessCallback,
   cgsFailureCallback,
   -- ** EditPlayerState Lenses
   epsSelectedPlayer,
   epsMode,
+  epsCallback,
   -- ** EditGoalieState Lenses
   egsSelectedGoalie,
   egsMode,
+  egsCallback,
   -- ** Database Lenses
   dbPlayers,
   dbGoalies,
@@ -202,9 +208,8 @@ import Data.Aeson
   , (.=)
   )
 import Data.Char (toUpper)
-import Data.List (isInfixOf)
+import Data.List (find, isInfixOf)
 import qualified Data.Map as M
-import Data.Maybe (listToMaybe)
 import Lens.Micro (Lens', lens, (&), (^.), (.~))
 import Lens.Micro.TH (makeLenses)
 import qualified UI.NCurses as C
@@ -326,6 +331,10 @@ data CreatePlayerState = CreatePlayerState
   -- ^ The player's name
   , _cpsPosition        :: String
   -- ^ The player's position
+  , _cpsRookieFlag      :: Maybe Bool
+  -- ^ Indicates whether or not the player is a rookie
+  , _cpsActiveFlag      :: Maybe Bool
+  -- ^ Indicates whether or not the plauer is active
   , _cpsSuccessCallback :: Action ()
   -- ^ The function to call on success
   , _cpsFailureCallback :: Action ()
@@ -338,6 +347,10 @@ data CreateGoalieState = CreateGoalieState
   -- ^ The goalie's number
   , _cgsName            :: String
   -- ^ The goalie's name
+  , _cgsRookieFlag      :: Maybe Bool
+  -- ^ Indicates whether or not the goalie is a rookie
+  , _cgsActiveFlag      :: Maybe Bool
+  -- ^ Indicates whether or not the goalie is active
   , _cgsSuccessCallback :: Action ()
   -- ^ The function to call on success
   , _cgsFailureCallback :: Action ()
@@ -350,6 +363,8 @@ data EditPlayerState = EditPlayerState
   -- ^ The index number of the player being edited
   , _epsMode           :: EditPlayerMode
   -- ^ The editing mode
+  , _epsCallback       :: Action ()
+  -- ^ The action to perform when the edit is complete
   }
 
 -- | Player editing mode
@@ -373,6 +388,9 @@ data EditGoalieState = EditGoalieState
   { _egsSelectedGoalie :: Maybe Int
   -- ^ The index number of the 'Goalie' being edited
   , _egsMode           :: EditGoalieMode
+  -- ^ The editing mode
+  , _egsCallback       :: Action ()
+  -- ^ The action to perform when the edit is complete
   }
 
 -- | 'Goalie' editing mode
@@ -800,6 +818,8 @@ newCreatePlayerState = CreatePlayerState
   { _cpsNumber          = Nothing
   , _cpsName            = ""
   , _cpsPosition        = ""
+  , _cpsRookieFlag      = Nothing
+  , _cpsActiveFlag      = Nothing
   , _cpsSuccessCallback = return ()
   , _cpsFailureCallback = return ()
   }
@@ -809,6 +829,8 @@ newCreateGoalieState :: CreateGoalieState
 newCreateGoalieState = CreateGoalieState
   { _cgsNumber          = Nothing
   , _cgsName            = ""
+  , _cgsRookieFlag      = Nothing
+  , _cgsActiveFlag      = Nothing
   , _cgsSuccessCallback = return ()
   , _cgsFailureCallback = return ()
   }
@@ -818,6 +840,7 @@ newEditPlayerState :: EditPlayerState
 newEditPlayerState = EditPlayerState
   { _epsSelectedPlayer = Nothing
   , _epsMode           = EPMenu
+  , _epsCallback       = return ()
   }
 
 -- | Constructor for an 'EditGoalieState' value
@@ -825,6 +848,7 @@ newEditGoalieState :: EditGoalieState
 newEditGoalieState = EditGoalieState
   { _egsSelectedGoalie = Nothing
   , _egsMode           = EGMenu
+  , _egsCallback       = return ()
   }
 
 -- | Constructor for a 'Database'
@@ -994,7 +1018,7 @@ playerSearchExact
   -> Maybe (Int, Player)
   -- ^ The player's index and value
 playerSearchExact sStr =
-  listToMaybe . filter match . zip [0..]
+  find match . zip [0..]
   where match (_, p) = p^.pName == sStr
 
 -- | Modifies a player with a given name

src/Mtlstats/Util.hs

@@ -52,8 +52,9 @@ modifyNth
   -> [a]
   -- ^ The list
   -> [a]
-modifyNth n f = map (\(i, x) -> if i == n then f x else x)
+modifyNth n f = zipWith
-  . zip [0..]
+  (\i x -> if i == n then f x else x)
+  [0..]
 
 -- | Modify a value indexed by a given key in a map using a default
 -- initial value if not present

test/Actions/NewGame/GoalieInputSpec.hs

@@ -23,7 +23,7 @@ module Actions.NewGame.GoalieInputSpec (spec) where
 
 import qualified Data.Map as M
 import Data.Maybe (fromJust)
-import Lens.Micro ((^.), (&), (.~), (?~))
+import Lens.Micro ((^.), (&), (.~), (?~), (%~))
 import Test.Hspec (Spec, context, describe, it, shouldBe)
 
 import Mtlstats.Actions.NewGame.GoalieInput
@@ -33,27 +33,50 @@ import Mtlstats.Util
 import qualified TypesSpec as TS
 
 spec :: Spec
-spec = describe "Mtlstats.Actions.GoalieInput" $ do
+spec = describe "GoalieInput" $ do
   finishGoalieEntrySpec
   recordGoalieStatsSpec
   setGameGoalieSpec
 
 finishGoalieEntrySpec :: Spec
-finishGoalieEntrySpec = describe "finishGoalieEntry" $ do
+finishGoalieEntrySpec = describe "finishGoalieEntry" $ mapM_
+  (\(label, stats, grFlag, gaFlag) -> context label $ do
     let
-    progState stats = newProgState
+      ps = newProgState
-      & progMode.gameStateL.gameGoalieStats .~ stats
+        & progMode.gameStateL
-      & finishGoalieEntry
+          %~ (gameGoalieStats .~ stats)
+          .  (gameType        ?~ HomeGame)
+          .  (homeScore       ?~ 1)
+          .  (awayScore       ?~ 0)
+          .  (overtimeFlag    ?~ False)
+        & database.dbGoalies .~ goalies
 
-  context "no goalie data" $
+      ps' = finishGoalieEntry ps
-    it "should not set goaliesRecorded" $ let
+      gs  = ps'^.progMode.gameStateL
-      s = progState M.empty
-      in s^.progMode.gameStateL.gameGoaliesRecorded `shouldBe` False
 
-  context "goalie data" $
+    describe "gameGoaliesRecorded" $
-    it "should set goaliesRecorded" $ let
+      it ("should be " ++ show grFlag) $
-      s = progState $ M.fromList [(1, newGoalieStats)]
+        gs^.gameGoaliesRecorded `shouldBe` grFlag
-      in s^.progMode.gameStateL.gameGoaliesRecorded `shouldBe` True
+
+    describe "gameGoalieAssigned" $
+      it ("should be " ++ show gaFlag) $
+        gs^.gameGoalieAssigned `shouldBe` gaFlag)
+
+  --  label,         initial stats, goalies recorded, goalie assigned
+  [ ( "no goalies",  noGoalies,     False,            False           )
+  , ( "one goalie",  oneGoalie,     True,             True            )
+  , ( "two goalies", twoGoalies,    True,             False           )
+  ]
+
+  where
+    goalies    = [joe, bob]
+    joe        = newGoalie 2 "Joe"
+    bob        = newGoalie 3 "Bob"
+    noGoalies  = M.empty
+    oneGoalie  = M.fromList [joeStats]
+    twoGoalies = M.fromList [joeStats, bobStats]
+    joeStats   = (0, newGoalieStats)
+    bobStats   = (1, newGoalieStats)
 
 recordGoalieStatsSpec :: Spec
 recordGoalieStatsSpec = describe "recordGoalieStats" $ let
@@ -185,107 +208,175 @@ recordGoalieStatsSpec = describe "recordGoalieStats" $ let
     ]
 
 setGameGoalieSpec :: Spec
-setGameGoalieSpec = describe "setGameGoalie" $ let
+setGameGoalieSpec = describe "setGameGoalie" $ mapM_
 
-  goalieStats w l t = newGoalieStats
+  (\(label, goalieId, ps, expectedJoe, expectedBob, expectedGStats) ->
-    & gsWins   .~ w
+    context label $ do
-    & 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
+        ps'          = setGameGoalie goalieId ps
-              gameStats = progState^.progMode.gameStateL.gameGoalieStats
+        [joe', bob'] = ps'^.database.dbGoalies
-              game      = M.findWithDefault newGoalieStats chkGid gameStats
+        gStats'      = ps'^.progMode.gameStateL.gameGoalieStats
-              ytd       = goalie^.gYtd
-              lifetime  = goalie^.gLifetime
 
-            mapM_
+      context "Joe" $ joe' `TS.compareTest` expectedJoe
-              (\(label', expected, actual) -> context label' $
+      context "Bob" $ bob' `TS.compareTest` expectedBob
-                expected `TS.compareTest` actual)
+      context "game stats" $ gStats' `TS.compareTest` expectedGStats)
-              [ ( "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" $
+  [ ( "Joe wins - no shutout"
-              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 )
+    , psWin
-      , ( 0, 0, 0, 30, 31, 32, 40, 41, 42 )
+    , joeWin
+    , bob
+    , gsJoeWin
     )
-    , ( "Bob loses"
+
-      , losingGame
+  , ( "Bob wins - no shutout"
-      , 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 )
+    , psWin
-      , ( 1, 0, 0, 31, 31, 32, 41, 41, 42 )
+    , joe
+    , bobWin
+    , gsBobWin
     )
+
+  , ( "Joe wins - shutout"
+    , 0
+    , psWinSO
+    , joeWinSO
+    , bob
+    , gsJoeWinSO
+    )
+
+  , ( "Bob wins - shutout"
+    , 1
+    , psWinSO
+    , joe
+    , bobWinSO
+    , gsBobWinSO
+    )
+
   , ( "Joe loses"
-      , losingGame
+    , 0
-      , 1
+    , psLose
-      , ( 0, 0, 0, 10, 11, 12, 20, 21, 22 )
+    , joeLose
-      , ( 0, 1, 0, 30, 32, 32, 40, 42, 42 )
+    , bob
+    , gsJoeLose
     )
-    , ( "Joe ties"
+
-      , tiedGame
+  , ( "Bob loses"
     , 1
-      , ( 0, 0, 0, 10, 11, 12, 20, 21, 22 )
+    , psLose
-      , ( 0, 0, 1, 30, 31, 33, 40, 41, 43 )
+    , joe
+    , bobLose
+    , gsBobLose
+    )
+
+  , ( "Joe overtime"
+    , 0
+    , psOT
+    , joeOT
+    , bob
+    , gsJoeOT
+    )
+
+  , ( "Bob overtime"
+    , 1
+    , psOT
+    , joe
+    , bobOT
+    , gsBobOT
     )
   ]
+
+  where
+
+    joe
+      = newGoalie 2 "Joe"
+      & gYtd
+        %~ (gsShutouts .~ 11)
+        .  (gsWins     .~ 12)
+        .  (gsLosses   .~ 13)
+        .  (gsTies     .~ 14)
+      & gLifetime
+        %~ (gsShutouts .~ 21)
+        .  (gsWins     .~ 22)
+        .  (gsLosses   .~ 23)
+        .  (gsTies     .~ 24)
+
+    bob
+      = newGoalie 3 "Bob"
+      & gYtd
+        %~ (gsShutouts .~ 31)
+        .  (gsWins     .~ 32)
+        .  (gsLosses   .~ 33)
+        .  (gsTies     .~ 34)
+      & gLifetime
+        %~ (gsShutouts .~ 41)
+        .  (gsWins     .~ 42)
+        .  (gsLosses   .~ 43)
+        .  (gsTies     .~ 44)
+
+    joeWin   = win joe
+    bobWin   = win bob
+    joeWinSO = winSO joe
+    bobWinSO = winSO bob
+    joeLose  = lose joe
+    bobLose  = lose bob
+    joeOT    = tie joe
+    bobOT    = tie bob
+
+    psWin = mkProgState
+      $ (homeScore ?~ 2)
+      . (awayScore ?~ 1)
+
+    psWinSO = mkProgState
+      $ (homeScore ?~ 1)
+      . (awayScore ?~ 0)
+
+    psLose = mkProgState
+      $ (homeScore ?~ 0)
+      . (awayScore ?~ 1)
+
+    psOT = mkProgState
+      $ (homeScore    ?~ 0)
+      . (awayScore    ?~ 1)
+      . (overtimeFlag ?~ True)
+
+    mkProgState f
+      = newProgState
+      & database.dbGoalies  .~ [joe, bob]
+      & progMode.gameStateL
+        %~ f
+        .  (gameType     ?~ HomeGame)
+        .  (overtimeFlag ?~ False)
+
+    gsJoeWin   = mkGameStats 0 incWin
+    gsBobWin   = mkGameStats 1 incWin
+    gsJoeWinSO = mkGameStats 0 $ incWin . incSO
+    gsBobWinSO = mkGameStats 1 $ incWin . incSO
+    gsJoeLose  = mkGameStats 0 incLoss
+    gsBobLose  = mkGameStats 1 incLoss
+    gsJoeOT    = mkGameStats 0 incOT
+    gsBobOT    = mkGameStats 1 incOT
+
+    mkGameStats n f = M.fromList [(n, f newGoalieStats)]
+
+    win
+      = (gYtd      %~ incWin)
+      . (gLifetime %~ incWin)
+
+    winSO
+      = (gYtd      %~ (incWin . incSO))
+      . (gLifetime %~ (incWin . incSO))
+
+    lose
+      = (gYtd      %~ incLoss)
+      . (gLifetime %~ incLoss)
+
+    tie
+      = (gYtd      %~ incOT)
+      . (gLifetime %~ incOT)
+
+    incWin  = gsWins     %~ succ
+    incSO   = gsShutouts %~ succ
+    incLoss = gsLosses   %~ succ
+    incOT   = gsTies     %~ succ

test/ActionsSpec.hs

@@ -312,51 +312,93 @@ editSelectedGoalieSpec = describe "editSelectedGoalie" $ mapM_
     goalie' n      = newGoalie n "foo"
 
 addPlayerSpec :: Spec
-addPlayerSpec = describe "addPlayer" $ do
+addPlayerSpec = describe "addPlayer" $ mapM_
-  let
+  (\(label, expectation, pm, players) -> context label $
-    p1 = newPlayer 1 "Joe" "centre"
+    it expectation $ let
-    p2 = newPlayer 2 "Bob" "defense"
+      ps = newProgState
-    db = newDatabase
-      & dbPlayers .~ [p1]
-    s pm = newProgState
         & progMode           .~ pm
-      & database .~ db
+        & database.dbPlayers .~ [joe]
+      ps' = addPlayer ps
+      in ps'^.database.dbPlayers `shouldBe` players)
 
-  context "data available" $
+  --  label,                 expectation, progMode,  players
-    it "should create the player" $ let
+  [ ( "wrong mode",          failure,     MainMenu,  [joe]          )
-      s' = addPlayer $ s $ CreatePlayer $ newCreatePlayerState
+  , ( "missing number",      failure,     noNum,     [joe]          )
-        & cpsNumber   ?~ 2
+  , ( "missing rookie flag", failure,     noRookie,  [joe]          )
+  , ( "missing active flag", failure,     noActive,  [joe]          )
+  , ( "rookie",              success,     mkRookie,  [joe, rookie]  )
+  , ( "retired",             success,     mkRetired, [joe, retired] )
+  , ( "normal player",       success,     mkNormal,  [joe, normal]  )
+  ]
+
+  where
+    failure   = "should not create the player"
+    success   = "should create the player"
+    noNum     = mkpm Nothing  (Just False) (Just True)
+    noRookie  = mkpm (Just 3) Nothing      (Just True)
+    noActive  = mkpm (Just 3) (Just False) Nothing
+    mkRookie  = mkpm (Just 3) (Just True)  (Just True)
+    mkRetired = mkpm (Just 3) (Just False) (Just False)
+    mkNormal  = mkpm (Just 3) (Just False) (Just True)
+    joe       = newPlayer 2 "Joe" "centre"
+    rookie    = player True  True
+    retired   = player False False
+    normal    = player False True
+
+    player r a = newPlayer 3 "Bob" "defense"
+      & pRookie .~ r
+      & pActive .~ a
+
+    mkpm n r a = CreatePlayer $ newCreatePlayerState
+      & cpsNumber     .~ n
       & cpsName       .~ "Bob"
       & cpsPosition   .~ "defense"
-      in s'^.database.dbPlayers `shouldBe` [p1, p2]
+      & cpsRookieFlag .~ r
-
+      & cpsActiveFlag .~ a
-  context "data unavailable" $
-    it "should not create the player" $ let
-      s' = addPlayer $ s MainMenu
-      in s'^.database.dbPlayers `shouldBe` [p1]
 
 addGoalieSpec :: Spec
-addGoalieSpec = describe "addGoalie" $ do
+addGoalieSpec = describe "addGoalie" $ mapM_
-  let
+  (\(label, expectation, pm, goalies) -> context label $
-    g1 = newGoalie 2 "Joe"
+    it expectation $ let
-    g2 = newGoalie 3 "Bob"
+      ps = newProgState
-    db = newDatabase
-      & dbGoalies .~ [g1]
-    s pm = newProgState
-      & database .~ db
         & progMode           .~ pm
+        & database.dbGoalies .~ [joe]
+      ps' = addGoalie ps
+      in ps'^.database.dbGoalies `shouldBe` goalies)
 
-  context "data available" $
+  --  label,            expectation, progMode,  expected goalies
-    it "should create the goalie" $ let
+  [ ( "wrong mode",     failure,     MainMenu,  [joe]            )
-      s' = addGoalie $ s $ CreateGoalie $ newCreateGoalieState
+  , ( "no number",      failure,     noNum,     [joe]            )
-        & cgsNumber ?~ 3
+  , ( "no rookie flag", failure,     noRookie,  [joe]            )
+  , ( "no active flag", failure,     noActive,  [joe]            )
+  , ( "rookie",         success,     mkRookie,  [joe, rookie]    )
+  , ( "retired",        success,     mkRetired, [joe, retired]   )
+  , ( "normal goalie",  success,     mkNormal,  [joe, normal]    )
+  ]
+
+  where
+    failure   = "should not create the goalie"
+    success   = "should create the goalie"
+    noNum     = cgs Nothing  (Just False) (Just True)
+    noRookie  = cgs (Just 3) Nothing      (Just True)
+    noActive  = cgs (Just 3) (Just False) Nothing
+    mkRookie  = cgs (Just 3) (Just True)  (Just True)
+    mkRetired = cgs (Just 3) (Just False) (Just False)
+    mkNormal  = cgs (Just 3) (Just False) (Just True)
+    joe       = newGoalie 2 "Joe"
+    rookie    = goalie True  True
+    retired   = goalie False False
+    normal    = goalie False True
+
+    goalie r a = newGoalie 3 "Bob"
+      & gRookie .~ r
+      & gActive .~ a
+
+    cgs n r a = CreateGoalie $ newCreateGoalieState
+      & cgsNumber     .~ n
       & cgsName       .~ "Bob"
-      in s'^.database.dbGoalies `shouldBe` [g1, g2]
+      & cgsRookieFlag .~ r
-
+      & cgsActiveFlag .~ a
-  context "data unavailable" $
-    it "should not create the goalie" $ let
-      s' = addGoalie $ s MainMenu
-      in s'^.database.dbGoalies `shouldBe` [g1]
 
 resetCreatePlayerStateSpec :: Spec
 resetCreatePlayerStateSpec = describe "resetCreatePlayerState" $ let

test/Helpers/PositionSpec.hs

@@ -0,0 +1,79 @@
+{-
+
+mtlstats
+Copyright (C) 1984, 1985, 2019, 2020 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 Helpers.PositionSpec (spec) where
+
+import Lens.Micro ((&), (.~))
+import Test.Hspec (Spec, context, describe, it, shouldBe)
+
+import Mtlstats.Helpers.Position
+import Mtlstats.Types
+
+spec :: Spec
+spec = describe "Position" $ do
+  posSearchSpec
+  posSearchExactSpec
+  getPositionsSpec
+
+posSearchSpec :: Spec
+posSearchSpec = describe "posSearch" $ mapM_
+  (\(sStr, expected) -> context ("search string: " ++ show sStr) $
+    it ("should be " ++ show expected) $
+      posSearch sStr db `shouldBe` expected)
+  [ ( "fOo"
+    , [ ( 2, "foo" )
+      ]
+    )
+  , ( "A"
+    , [ ( 0, "bar" )
+      , ( 1, "baz" )
+      ]
+    )
+  ]
+
+posSearchExactSpec :: Spec
+posSearchExactSpec = describe "posSearchExact" $ mapM_
+  (\(input, expected) -> context ("input: " ++ show input) $
+    it ("should be " ++ show expected) $
+      posSearchExact input db `shouldBe` expected)
+
+  --  input,  expected
+  [ ( "foo",  Just 2   )
+  , ( "FOO",  Nothing  )
+  , ( "bar",  Just 0   )
+  , ( "baz",  Just 1   )
+  , ( "a",    Nothing  )
+  , ( "quux", Nothing  )
+  ]
+
+getPositionsSpec :: Spec
+getPositionsSpec = describe "getPositions" $ let
+  expected = ["bar", "baz", "foo"]
+  in it ("should be " ++ show expected) $
+    getPositions db `shouldBe` expected
+
+db :: Database
+db = newDatabase & dbPlayers .~
+  [ newPlayer 2 "Joe"  "foo"
+  , newPlayer 3 "Bob"  "bar"
+  , newPlayer 5 "Bill" "foo"
+  , newPlayer 8 "Ed"   "baz"
+  ]

test/HelpersSpec.hs

@@ -25,8 +25,10 @@ import Test.Hspec (Spec, describe)
 
 import qualified Helpers.GoalieSpec as Goalie
 import qualified Helpers.PlayerSpec as Player
+import qualified Helpers.PositionSpec as Position
 
 spec :: Spec
 spec = describe "Helper" $ do
   Player.spec
   Goalie.spec
+  Position.spec

test/TypesSpec.hs

@@ -19,7 +19,7 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 -}
 
-{-# LANGUAGE OverloadedStrings, RankNTypes #-}
+{-# LANGUAGE FlexibleInstances, OverloadedStrings, RankNTypes #-}
 
 module TypesSpec
   ( Comparable (..)
@@ -33,6 +33,7 @@ module TypesSpec
 import Control.Monad (replicateM)
 import Data.Aeson (FromJSON, ToJSON, decode, encode, toJSON)
 import Data.Aeson.Types (Value (Object))
+import qualified Data.Map.Lazy as M
 import qualified Data.HashMap.Strict as HM
 import Data.Ratio ((%))
 import Lens.Micro (Lens', (&), (^.), (.~), (?~))
@@ -1005,3 +1006,48 @@ instance Comparable EditStandingsMode where
   compareTest actual expected =
     it ("should be " ++ show expected) $
       actual `shouldBe` expected
+
+instance Comparable Goalie where
+  compareTest actual expected = do
+
+    describe "gNumber" $
+      it ("should be " ++ show (expected^.gNumber)) $
+        actual^.gNumber `shouldBe` expected^.gNumber
+
+    describe "gName" $
+      it ("should be " ++ show (expected^.gName)) $
+        actual^.gName `shouldBe` expected^.gName
+
+    describe "gRookie" $
+      it ("should be " ++ show (expected^.gRookie)) $
+        actual^.gRookie `shouldBe` expected^.gRookie
+
+    describe "gActive" $
+      it ("should be " ++ show (expected^.gActive)) $
+        actual^.gActive `shouldBe` expected^.gActive
+
+    describe "gYtd" $
+      (actual^.gYtd) `compareTest` (expected^.gYtd)
+
+    describe "gLifetime" $
+      (actual^.gLifetime) `compareTest` (expected^.gLifetime)
+
+instance Comparable (M.Map Int GoalieStats) where
+  compareTest actual expected = do
+
+    let
+      aList = M.toList actual
+      eList = M.toList expected
+
+    it "should have the correct number of elements" $
+      length aList `shouldBe` length eList
+
+    mapM_
+      (\(n, (ka, va), (ke, ve)) -> context ("element " ++ show n) $ do
+
+        context "key" $
+          it ("should be " ++ show ke) $
+            ka `shouldBe` ke
+
+        context "value" $ va `compareTest` ve)
+      (zip3 ([0..] :: [Int]) aList eList)

vagrant/as_user.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+echo "export PATH=\"$HOME/.local/bin:$PATH\"" >>~vagrant/.bashrc
+mkdir /vagrant/data
+ln -s /vagrant/data ~vagrant/.mtlstats
+
+cd /vagrant
+stack install

vagrant/provision.sh

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+apt-get update
+apt-get upgrade
+apt-get -y install libghc-ncurses-dev
+wget -qO- https://get.haskellstack.org/ | sh
+
+export HOME=/home/vagrant
+
+sudo -u vagrant /vagrant/vagrant/as_user.sh