Refactor files (#52)

Author: jhb563

app/Main.hs

@@ -5,8 +5,11 @@ import           Data.Tuple.Extra   (uncurry3)
 import           System.Environment
 import           System.IO
 
-import           Config
+import           Constants
+import           LoadConfig
 import           RunCommands
+import           TerminalUtils
+import           Types
 import           Watcher
 
 main :: IO ()

haskellings.cabal

@@ -21,12 +21,15 @@ source-repository head
 
 library
   exposed-modules:
-      Config
+      Constants
       DirectoryUtils
       ExerciseList
       ExecutableExercises
+      LoadConfig
+      Processor
       RunCommands
-      Utils
+      TerminalUtils
+      Types
       Watcher
   other-modules:
       Paths_haskellings
@@ -47,14 +50,16 @@ library
     , time
     , yaml
   default-language: Haskell2010
+  ghc-options:
+    -fwarn-unused-imports
 
 executable haskellings
   main-is: Main.hs
   other-modules:
       Paths_haskellings
   hs-source-dirs:
       app
-  ghc-options: -threaded -rtsopts -with-rtsopts=-N
+  ghc-options: -fwarn-unused-imports -threaded -rtsopts -with-rtsopts=-N
   build-depends:
       base >=4.7 && <5
     , containers
@@ -67,7 +72,7 @@ test-suite haskellings-tests
   type: exitcode-stdio-1.0
   hs-source-dirs:
       tests
-  ghc-options: -threaded -rtsopts -with-rtsopts=-N
+  ghc-options: -fwarn-unused-imports -threaded -rtsopts -with-rtsopts=-N
   build-depends:
       base >=4.7 && <5
     , containers

src/Constants.hs

@@ -0,0 +1,43 @@
+{- Constants used throughout the program,
+   often related to configuration.
+-}
+module Constants where
+
+import           Data.Maybe
+import           System.Environment
+
+ghcVersion :: String
+ghcVersion = "ghc-8.10.4"
+
+ghcVersionNumber :: String
+ghcVersionNumber = "8.10.4"
+
+projectRootDirName :: String
+projectRootDirName = "haskellings"
+
+configFileName :: String
+configFileName = "config.yaml"
+
+-- On CircleCI, the root directory shows up as "project'
+ciEnvName :: String
+ciEnvName = "HASKELLINGS_CI_ENV"
+
+envIsCi :: IO Bool
+envIsCi = isJust <$> lookupEnv ciEnvName
+
+ciProjectRootDirName :: String
+ciProjectRootDirName = "project"
+
+haskellingsVersion :: String
+haskellingsVersion = "0.8.0.0"
+
+mainProjectExercisesDir :: String
+mainProjectExercisesDir = "exercises"
+
+-- A listing of packages required by exercises, so we can use them
+-- to filter Stack snapshots
+haskellingsRequiredLibs :: [String]
+haskellingsRequiredLibs =
+  [ "tasty"
+  , "tasty-hunit"
+  ]

src/DirectoryUtils.hs

@@ -1,23 +1,72 @@
+{- Utility functions for manipulating filepaths and directories.
+-}
 module DirectoryUtils where
 
-import           Control.Exception (Exception, catch)
-import           Data.List         (dropWhileEnd, isInfixOf, isSuffixOf)
-import           Data.List.Extra   (takeWhileEnd)
-import qualified Data.Sequence     as S
+import           Control.Concurrent
+import           Control.Exception  (catch)
+import           Data.Char
+import           Data.List          (isSuffixOf)
+import           Data.List.Extra    (upper)
+import qualified Data.Map           as M
+import qualified Data.Sequence      as S
 import           System.Directory
-import           System.FilePath   (takeDirectory, takeFileName, (</>))
-import           System.Info       (os)
+import           System.FilePath    (takeBaseName, takeFileName, (</>))
+import           System.Info        (os)
+
+import           Types
 
 isWindows :: Bool
 isWindows = os `notElem` ["linux", "unix", "darwin"]
 
+isHaskellFile :: FilePath -> Bool
+isHaskellFile = isSuffixOf ".hs"
+
+-- Probably a good idea to first check that it is a Haskell file first
+haskellModuleName :: FilePath -> FilePath
+haskellModuleName = takeBaseName
+
+haskellFileName :: FilePath -> FilePath
+haskellFileName exName = exName ++ ".hs"
+
+fileContainsNotDone :: FilePath -> IO Bool
+fileContainsNotDone fullFp = do
+  fileLines <- lines <$> readFile fullFp
+  return (any isDoneLine fileLines)
+  where
+    isDoneLine :: String -> Bool
+    isDoneLine l = (upper . filter (not . isSpace) $ l) == "--IAMNOTDONE"
+
+fullExerciseFp :: FilePath -> FilePath -> ExerciseInfo -> FilePath
+fullExerciseFp projectRoot exercisesExt (ExerciseInfo exName exDir _ _) =
+  projectRoot </> exercisesExt </> exDir </> haskellFileName exName
+
+withFileLock :: FilePath -> ProgramConfig -> IO a -> IO a
+withFileLock fp config action = case M.lookup fp (fileLocks config) of
+  Nothing -> action
+  Just lock -> do
+    putMVar lock ()
+    result <- action
+    takeMVar lock
+    return result
+
+-- Create a directory. Run the action depending on that directory,
+-- and then clean the directory up.
+withDirectory :: FilePath -> IO a -> IO a
+withDirectory dirPath action = do
+  createDirectoryIfMissing True dirPath
+  res <- action
+  removeDirectoryRecursive dirPath
+  return res
+
 returnIfDirExists :: FilePath -> IO (Maybe FilePath)
 returnIfDirExists fp = do
   exists <- doesDirectoryExist fp
   if exists
     then return (Just fp)
     else return Nothing
 
+---------- Directory Search Functions ----------
+
 searchForDirectoryContaining :: FilePath -> String -> IO (Maybe FilePath)
 searchForDirectoryContaining searchRoot directoryToFind = fpBFS predicate (S.singleton searchRoot)
   where

src/ExecutableExercises.hs

@@ -1,3 +1,6 @@
+{- Lists inputs and output predicates for
+   executable exercises.
+-}
 module ExecutableExercises where
 
 import           Data.List (isPrefixOf)

src/ExerciseList.hs

@@ -1,39 +1,10 @@
+{- Definitive list of exercises in Haskellings -}
 module ExerciseList where
 
 import qualified Data.Map            as M
 
 import           ExecutableExercises
-
--- There are three types of exercises.
--- 1. Some succeed once they have compiled (CompileOnly).
--- 2. Some require that unit tests pass on the exercise functions (UnitTests)
--- 3. Others involve some degree of IO. The User can use 'haskellings exec' on
---    these. There is one set of inputs and expected outputs as a quick test,
---    when the exercise is run via 'haskellings run' or the Watcher.
-data ExerciseType =
-  CompileOnly |
-  UnitTests |
-  -- One set of expected input lines and predicate for output lines.
-  Executable [String] ([String] -> Bool)
-
--- Manual instances needed because 'Executable' contains a function.
-instance Eq ExerciseType where
-  CompileOnly == CompileOnly = True
-  UnitTests == UnitTests = True
-  (Executable _ _) == (Executable _ _) = True
-  _ == _ = False
-
-instance Show ExerciseType where
-  show CompileOnly      = "CompileOnly"
-  show UnitTests        = "UnitTests"
-  show (Executable _ _) = "Executable"
-
-data ExerciseInfo = ExerciseInfo
-  { exerciseName      :: String
-  , exerciseDirectory :: String
-  , exerciseType      :: ExerciseType
-  , exerciseHint      :: String
-  } deriving (Show, Eq)
+import           Types
 
 allExercises :: [ExerciseInfo]
 allExercises =