Refactor PSCI parser module to use new directive utilities

panhania · panhania · commit 6291fa00c577 · 2015-03-11T00:06:32.000+01:00
diff --git a/psci/Parser.hs b/psci/Parser.hs
@@ -19,10 +19,10 @@ module Parser (
 
 import Prelude hiding (lex)
 
-import Commands
+import qualified Commands as C
+import qualified Directive as D
 
 import Data.Char (isSpace)
-import Data.List (isPrefixOf)
 
 import Control.Applicative hiding (many)
 
@@ -34,24 +34,11 @@ import qualified Language.PureScript.Parser.Common as C (mark, same)
 -- |
 -- Parses PSCI metacommands or expressions input from the user.
 --
-parseCommand :: String -> Either String Command
+parseCommand :: String -> Either String C.Command
 parseCommand cmdString =
-  case splitCommand cmdString of
-    Just (cmd, arg)
-      | matches "?" -> return Help
-      | matches "help" -> return Help
-      | matches "quit" -> return Quit
-      | matches "reset" -> return Reset
-      | matches "import" -> Import <$> parseRest P.moduleName arg
-      | matches "browse" -> Browse <$> parseRest P.moduleName arg
-      | matches "module" -> return $ LoadFile (trimEnd arg)
-      | matches "show" -> return $ Show (trimEnd cmd)
-      | matches "type" -> TypeOf <$> parseRest P.parseValue arg
-      | matches "kind" -> KindOf <$> parseRest P.parseType arg
-      | otherwise -> Left $ "Unrecognized command. Type :? for help."
-      where
-      matches = isPrefixOf cmd
-    Nothing -> parseRest (psciLet <|> psciExpression) cmdString
+  case cmdString of
+    (':' : cmd) -> parseDirective cmd
+    _ -> parseRest (psciLet <|> psciExpression) cmdString
   where
   parseRest :: P.TokenParser a -> String -> Either String a
   parseRest p s = either (Left . show) Right $ do
@@ -64,29 +51,35 @@ parseCommand cmdString =
   trimEnd :: String -> String
   trimEnd = reverse . trimStart . reverse
 
-  -- |
-  -- Tries to split a command into a directive and the argument.
-  --
-  splitCommand :: String -> Maybe (String, String)
-  splitCommand (':' : cmd) = Just (directive, trimStart arg)
-    where
-    (directive, arg) = break isSpace cmd
-  splitCommand _ = Nothing
+  parseDirective :: String -> Either String C.Command
+  parseDirective cmd =
+    case D.parseDirective dstr of
+      Just D.Help -> return C.Help
+      Just D.Quit -> return C.Quit
+      Just D.Reset -> return C.Reset
+      Just D.Import -> C.Import <$> parseRest P.moduleName arg
+      Just D.Browse -> C.Browse <$> parseRest P.moduleName arg
+      Just D.Load -> return $ C.LoadFile (trimEnd arg)
+      Just D.Show -> return $ C.Show (trimEnd arg)
+      Just D.Type -> C.TypeOf <$> parseRest P.parseValue arg
+      Just D.Kind -> C.KindOf <$> parseRest P.parseType arg
+      Nothing -> Left $ "Unrecognized command. Type :? for help."
+    where (dstr, arg) = break isSpace cmd
 
   -- |
   -- Parses expressions entered at the PSCI repl.
   --
-  psciExpression :: P.TokenParser Command
-  psciExpression = Expression <$> P.parseValue
+  psciExpression :: P.TokenParser C.Command
+  psciExpression = C.Expression <$> P.parseValue
 
   -- |
   -- PSCI version of @let@.
   -- This is essentially let from do-notation.
   -- However, since we don't support the @Eff@ monad,
   -- we actually want the normal @let@.
   --
-  psciLet :: P.TokenParser Command
-  psciLet = Let <$> (P.reserved "let" *> P.indented *> manyDecls)
+  psciLet :: P.TokenParser C.Command
+  psciLet = C.Let <$> (P.reserved "let" *> P.indented *> manyDecls)
     where
     manyDecls :: P.TokenParser [P.Declaration]
     manyDecls = C.mark (many1 (C.same *> P.parseDeclaration))
