version 0.12.0

allow dashes in database backup files

ChangeLog.md

@@ -1,5 +1,11 @@
 # Changelog for mtlstats
 
+## 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

package.yaml

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

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
@@ -43,20 +38,13 @@ import Mtlstats.Types
 -- run
 dispatch :: ProgState -> Controller
 dispatch s = case s^.progMode of
-  TitleScreen    -> titleScreenC
+  TitleScreen         -> titleScreenC
-  MainMenu       -> mainMenuC
+  MainMenu            -> mainMenuC
-  NewSeason flag -> newSeasonC flag
+  NewSeason flag      -> newSeasonC flag
-  NewGame gs     -> newGameC gs
+  NewGame gs          -> newGameC gs
-  EditMenu       -> editMenuC
+  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,84 @@
+{- |
+
+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 (join)
+import Control.Monad.Trans.State (gets, modify)
+import Data.Maybe (fromJust)
+import Lens.Micro ((^.), (.~), (?~), (%~), to)
+import qualified UI.NCurses as C
+
+import Mtlstats.Actions
+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
+  | otherwise             = confirmCreateGoalieC
+
+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
+        gid <- gets (^.database.dbGoalies.to length)
+        cb  <- gets (^.progMode.createGoalieStateL.cgsSuccessCallback)
+        modify
+          $ (progMode.editGoalieStateL
+            %~ (egsSelectedGoalie ?~ gid)
+            .  (egsMode .~ EGLtGames True)
+            .  (egsCallback .~ cb))
+          . addGoalie
+      Just False ->
+        join $ gets (^.progMode.createGoalieStateL.cgsFailureCallback)
+      Nothing -> return ()
+    return True
+  }

src/Mtlstats/Control/CreatePlayer.hs

@@ -0,0 +1,91 @@
+{- |
+
+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 (join)
+import Control.Monad.Trans.State (gets, modify)
+import Data.Maybe (fromJust)
+import Lens.Micro ((^.), (.~), (?~), (%~), to)
+import qualified UI.NCurses as C
+
+import Mtlstats.Actions
+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
+  | otherwise               = confirmCreatePlayerC
+
+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
+        pid <- gets (^.database.dbPlayers.to length)
+        cb  <- gets (^.progMode.createPlayerStateL.cpsSuccessCallback)
+        modify
+          $ (progMode.editPlayerStateL
+            %~ (epsSelectedPlayer ?~ pid)
+            .  (epsMode .~ EPLtGoals True)
+            .  (epsCallback .~ cb))
+          . addPlayer
+      Just False ->
+        join $ gets (^.progMode.createPlayerStateL.cpsFailureCallback)
+      Nothing -> return ()
+    return True
+  }

src/Mtlstats/Control/EditGoalie.hs

@@ -39,89 +39,103 @@ 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 =
-  EGMenu          -> menuC
+  ( \case
-  EGNumber        -> numberC
+    EGMenu          -> menuC
-  EGName          -> nameC
+    EGNumber        -> numberC
-  EGYtd           -> ytdMenuC
+    EGName          -> nameC
-  EGLifetime      -> lifetimeMenuC
+    EGYtd           -> ytdMenuC
-  EGYtdGames b    -> ytdGamesC b
+    EGLifetime      -> lifetimeMenuC
-  EGYtdMins b     -> ytdMinsC b
+    EGYtdGames b    -> ytdGamesC b
-  EGYtdGoals b    -> ytdGoalsC b
+    EGYtdMins b     -> ytdMinsC b
-  EGYtdShutouts b -> ytdShutoutsC b
+    EGYtdGoals b    -> ytdGoalsC b
-  EGYtdWins b     -> ytdWinsC b
+    EGYtdShutouts b -> ytdShutoutsC b
-  EGYtdLosses b   -> ytdLossesC b
+    EGYtdWins b     -> ytdWinsC b
-  EGYtdTies       -> ytdTiesC
+    EGYtdLosses b   -> ytdLossesC b
-  EGLtGames b     -> ltGamesC b
+    EGYtdTies       -> ytdTiesC
-  EGLtMins b      -> ltMinsC b
+    EGLtGames b     -> ltGamesC b
-  EGLtGoals b     -> ltGoalsC b
+    EGLtMins b      -> ltMinsC b
-  EGLtShutouts b  -> ltShutoutsC b
+    EGLtGoals b     -> ltGoalsC b
-  EGLtWins b      -> ltWinsC b
+    EGLtShutouts b  -> ltShutoutsC b
-  EGLtLosses b    -> ltLossesC b
+    EGLtWins b      -> ltWinsC b
-  EGLtTies        -> ltTiesC
+    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,58 +37,64 @@ import Mtlstats.Util
 editPlayerC :: EditPlayerState -> Controller
 editPlayerC eps
   | null $ eps^.epsSelectedPlayer = selectPlayerC
-  | otherwise = case eps^.epsMode of
+  | otherwise =
-    EPMenu         -> menuC
+    ( case eps^.epsMode of
-    EPNumber       -> numberC
+      EPMenu         -> menuC
-    EPName         -> nameC
+      EPNumber       -> numberC
-    EPPosition     -> positionC
+      EPName         -> nameC
-    EPYtd          -> ytdC
+      EPPosition     -> positionC
-    EPLifetime     -> lifetimeC
+      EPYtd          -> ytdC
-    EPYtdGoals   b -> ytdGoalsC   b
+      EPLifetime     -> lifetimeC
-    EPYtdAssists b -> ytdAssistsC b
+      EPYtdGoals   b -> ytdGoalsC   b
-    EPYtdPMin      -> ytdPMinC
+      EPYtdAssists b -> ytdAssistsC b
-    EPLtGoals    b -> ltGoalsC    b
+      EPYtdPMin      -> ytdPMinC
-    EPLtAssists  b -> ltAssistsC  b
+      EPLtGoals    b -> ltGoalsC    b
-    EPLtPMin       -> ltPMinC
+      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/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              )
   ]
 
@@ -71,16 +71,16 @@ editGoalieYtdMenu = editMenu "EDIT GOALTENDER YEAR-TO-DATE"
 editGoalieLtMenu :: Menu ()
 editGoalieLtMenu = editMenu
   "EDIT GOALTENDER LIFETIME"
-  --  key, label,                   value
+  --  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             )
+  , ( 'R', "RETURN TO EDIT MENU", EGMenu             )
   ]
 
 editMenu :: String -> [(Char, String, EditGoalieMode)] -> Menu ()

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

@@ -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

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
+    then goto EGMenu
-  else doEdit EGMenu $ gName .~ name
+    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
+    then goto EPMenu
-  else doEdit EPMenu $ pName .~ name
+    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 = ucStrPrompt "Player position: " $ \pos -> do
   if null pos
-  then goto EPMenu
+    then goto EPMenu
-  else doEdit EPMenu $ pPosition .~ pos
+    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
 
@@ -261,8 +261,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 +289,7 @@ goalieReport width showTotals lineNumbers goalieData = let
       [ CellText $ show (goalie^.gNumber) ++ " "
       , CellText $ goalieName goalie
       ] ++ rowCells stats)
-    goalieData
+    goalieData'
 
   separator
     =  replicate 2 (CellText "")
@@ -309,6 +311,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 +329,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

@@ -98,9 +98,11 @@ module Mtlstats.Types (
   -- ** EditPlayerState Lenses
   epsSelectedPlayer,
   epsMode,
+  epsCallback,
   -- ** EditGoalieState Lenses
   egsSelectedGoalie,
   egsMode,
+  egsCallback,
   -- ** Database Lenses
   dbPlayers,
   dbGoalies,
@@ -350,6 +352,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 +377,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
@@ -818,6 +825,7 @@ newEditPlayerState :: EditPlayerState
 newEditPlayerState = EditPlayerState
   { _epsSelectedPlayer = Nothing
   , _epsMode           = EPMenu
+  , _epsCallback       = return ()
   }
 
 -- | Constructor for an 'EditGoalieState' value
@@ -825,6 +833,7 @@ newEditGoalieState :: EditGoalieState
 newEditGoalieState = EditGoalieState
   { _egsSelectedGoalie = Nothing
   , _egsMode           = EGMenu
+  , _egsCallback       = return ()
   }
 
 -- | Constructor for a 'Database'