Refactor and document code

Author: Jana Chadt

plugins/hls-cabal-plugin/src/Ide/Plugin/Cabal.hs

@@ -50,6 +50,7 @@ import           Language.LSP.VFS                (VirtualFile)
 import qualified Language.LSP.VFS                as VFS
 import qualified Text.Fuzzy.Parallel             as Fuzzy
 
+
 data Log
   = LogModificationTime NormalizedFilePath FileVersion
   | LogShake Shake.Log
@@ -288,56 +289,68 @@ completion _ide _ complParams = do
     result Nothing _ = J.List []
     result (Just pfix) cnts
       | pos ^. JL.line == 0 = J.List [buildCompletion (fst cabalVersionKeyword)]
-      | Just ctx@(Stanza s kwContext) <- context =
-        case (Map.lookup s stanzaKeywordMap) of
-          Nothing ->
-            case kwContext of
-              None ->
-                J.List $
-                  makeCompletionItems pfix topLevelKeywords
-              KeyWord kw -> J.List $ makeCompletionItems pfix (getPossibleValuesForKeyWord kw ctx)
-          Just m ->
-            case kwContext of
-              None -> J.List $ (makeCompletionItems pfix (Map.keys m)) ++ (makeCompletionItems pfix $ Map.keys stanzaKeywordMap)
-              KeyWord kw -> J.List $ makeCompletionItems pfix (getPossibleValuesForKeyWord kw ctx)
-      | Just ctx@(TopLevel kwContext) <- context =
-        case kwContext of
-          None -> J.List $ makeCompletionItems pfix topLevelKeywords
-          KeyWord kw -> J.List $ makeCompletionItems pfix (getPossibleValuesForKeyWord kw ctx)
+      | Just ctx <- context  = J.List $ makeCompletionItems pfix (getCompletionsForContext ctx)
       | otherwise = J.List []
       where
         pos = VFS.cursorPos pfix
-        topLevelKeywords = Map.keys cabalKeywords ++ Map.keys stanzaKeywordMap
-        context = findCurrentContext pos (cnts ^. VFS.file_text)
-
-getPossibleValuesForKeyWord :: T.Text -> Context -> [T.Text]
-getPossibleValuesForKeyWord kw (TopLevel _) =
+        context = getContext pos (Rope.lines $ cnts ^. VFS.file_text)
+
+-- | Takes a context and returns all possible completions within that context
+getCompletionsForContext :: Context -> [T.Text]
+-- if we are in the top level of the cabal file and not in a keyword context,
+-- we can write any toplevel keywords or a stanza declaration
+getCompletionsForContext (TopLevel, None) =
+  Map.keys cabalKeywords ++ Map.keys stanzaKeywordMap
+-- if we are in a keyword context in the toplevel,
+-- we look up that keyword in the toplevel context and can complete its possible values
+getCompletionsForContext (TopLevel, KeyWord kw) =
   case Map.lookup kw cabalKeywords of
     Nothing -> []
     Just l  -> l
-getPossibleValuesForKeyWord kw (Stanza s _) =
+-- if we are in a stanza and not in a keyword context,
+-- we can write any of the stanza's keywords or a stanza declaration
+getCompletionsForContext (Stanza s, None) =
+  case Map.lookup s stanzaKeywordMap of
+    Nothing -> []
+    Just l  -> Map.keys l ++ Map.keys stanzaKeywordMap
+-- if we are in a stanza's keyword's context we can complete possible values of that keyword
+getCompletionsForContext (Stanza s, KeyWord kw) =
   case Map.lookup s stanzaKeywordMap of
     Nothing -> []
     Just m -> case Map.lookup kw m of
       Nothing -> []
       Just l  -> l
 
-findCurrentContext :: Position -> Rope.Rope -> Maybe Context
-findCurrentContext pos rope =
-  case outerContext of
-    TopLevel _ -> TopLevel <$> getKeyWordContext cabalKeywords
-    Stanza s _ ->
-      case traceShowId (Map.lookup (traceShowId s) stanzaKeywordMap) of
-        Nothing -> pure $ Stanza s None
-        Just m  -> traceShowId $ Stanza s <$> getKeyWordContext m
-  where
-    outerContext = findCurrentLevel (getPreviousLines pos rope) None
-    currentLine = traceShowId $ (Rope.lines rope) Extra.!? (fromIntegral $ pos ^. JL.line)
-    getKeyWordContext keywords = do
+-- | Takes a position and a list of lines (representing a file)
+--   and returns the context of the current position
+--   can return Nothing if an error occurs
+getContext :: Position -> [T.Text] -> Maybe Context
+getContext pos ls =
+  case lvlContext of
+    TopLevel -> do
+      kwContext <- getKeyWordContext pos ls cabalKeywords
+      pure (TopLevel, kwContext)
+    Stanza s ->
+      case Map.lookup (traceShowId s) stanzaKeywordMap of
+        Nothing -> do
+          pure (Stanza s, None)
+        Just m -> do
+          kwContext <- getKeyWordContext pos ls m
+          pure (Stanza s, kwContext)
+    where
+      lvlContext = findCurrentLevel (ls)
+
+-- | Takes a position, a list of lines (representing a file) and a map of keywords as keys
+--   and returns a keyword context if there is a keyword from the map before the current position
+--   in the given line list
+getKeyWordContext :: Position -> [T.Text] -> Map T.Text a -> Maybe KeyWordContext
+getKeyWordContext pos ls keywords = do
       curLine <- fmap T.stripStart currentLine
-      case List.find (\kw -> traceShowId kw `T.isPrefixOf` curLine) (traceShowId $ Map.keys keywords) of
+      case List.find (`T.isPrefixOf` curLine) (Map.keys keywords) of
         Nothing -> Just None
         Just kw -> Just $ KeyWord kw
+  where
+    currentLine = ls Extra.!? (fromIntegral $ pos ^. JL.line)
 
 -- | Takes info about the current cursor position and a set of possible keywords
 --   and creates completion suggestions that fit the current input from the given list
@@ -350,11 +363,11 @@ makeCompletionItems pfix l =
 -- | Parse the given set of lines (starting before current cursor position
 --   up to the start of the file) to find the nearest stanza declaration,
 --   if none is found we are in the top level
-findCurrentLevel :: [T.Text] -> KeyWordContext -> Context
-findCurrentLevel [] kwContext = TopLevel kwContext
-findCurrentLevel (cur : xs) kwContext
-  | Just s <- stanza = Stanza s kwContext
-  | otherwise = findCurrentLevel xs kwContext
+findCurrentLevel :: [T.Text] -> LevelContext
+findCurrentLevel [] = TopLevel
+findCurrentLevel (cur : xs)
+  | Just s <- stanza = Stanza s
+  | otherwise = findCurrentLevel xs
   where
     stanza = List.find (`T.isPrefixOf` cur) (Map.keys stanzaKeywordMap)
 
@@ -366,19 +379,25 @@ getPreviousLines pos rope = reverse $ take (fromIntegral currentLine) allLines
     allLines = Rope.lines rope
     currentLine = pos ^. JL.line
 
-data Context
-  = TopLevel KeyWordContext
-  -- ^ top level context in a cabal file such as 'author'
-  | Stanza T.Text KeyWordContext
-  -- ^ nested context in a cabal file, such as 'library', which has nested keywords, specific to the stanza
+-- | The context a cursor can be in within a cabal file,
+--   we can be in stanzas or the toplevel,
+--   and additionally we can be in a context where we have already written a keyword
+--   but no value for it yet
+type Context = (LevelContext, KeyWordContext)
+
+data LevelContext
+  = TopLevel
+  -- ^ Top level context in a cabal file such as 'author'
+  | Stanza T.Text
+  -- ^ Nested context in a cabal file, such as 'library', which has nested keywords, specific to the stanza
   deriving (Eq, Show)
 
 -- | Keyword context in cabal file
 data KeyWordContext
   = KeyWord T.Text
-  -- ^ we are in a line with the given keyword before our cursor
+  -- ^ We are in a line with the given keyword before our cursor
   | None
-  -- ^ we are in a line with no keyword context
+  -- ^ We are in a line with no keyword context
   deriving (Eq, Show)
 
 -- | Keyword for cabal version required to be the top line in a cabal file