X-Git-Url: http://git.lukelau.me/?a=blobdiff_plain;f=src%2FLanguage%2FHaskell%2FLSP%2FTest%2FSession.hs;h=d12ed003a2d67e212156c9cbe5810c2ccc17055f;hb=bd6901688e6c9d8332fea161260d32666885f9ed;hp=db8bef5513e2c1e5dad7462d11ff52d400aaa21e;hpb=2ed0dbaf1233ec79ed0801b406ae9fbf4e36e8a4;p=opengl.git

diff --git a/src/Language/Haskell/LSP/Test/Session.hs b/src/Language/Haskell/LSP/Test/Session.hs
index db8bef5..d12ed00 100644
--- a/src/Language/Haskell/LSP/Test/Session.hs
+++ b/src/Language/Haskell/LSP/Test/Session.hs
@@ -1,9 +1,12 @@
 {-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE FlexibleInstances #-}
 
 module Language.Haskell.LSP.Test.Session
   ( Session
-  , SessionState(..)
+  , SessionConfig(..)
   , SessionContext(..)
+  , SessionState(..)
+  , MonadSessionConfig(..)
   , runSessionWithHandles
   , get
   , put
@@ -13,29 +16,63 @@ module Language.Haskell.LSP.Test.Session
 where
 
 import Control.Concurrent hiding (yield)
+import Control.Exception
 import Control.Lens hiding (List)
 import Control.Monad
 import Control.Monad.IO.Class
-import Control.Monad.Trans.Class
+import Control.Monad.Except
 import Control.Monad.Trans.Reader (ReaderT, runReaderT)
 import qualified Control.Monad.Trans.Reader as Reader (ask)
 import Control.Monad.Trans.State (StateT, runStateT)
 import qualified Control.Monad.Trans.State as State (get, put, modify)
 import qualified Data.ByteString.Lazy.Char8 as B
 import Data.Aeson
-import Data.Conduit
+import Data.Conduit hiding (await)
 import Data.Conduit.Parser
+import Data.Default
 import Data.Foldable
 import Data.List
+import qualified Data.Text as T
 import qualified Data.HashMap.Strict as HashMap
 import Language.Haskell.LSP.Messages
+import Language.Haskell.LSP.TH.ClientCapabilities
 import Language.Haskell.LSP.Types
 import Language.Haskell.LSP.VFS
 import Language.Haskell.LSP.Test.Compat
 import Language.Haskell.LSP.Test.Decoding
+import Language.Haskell.LSP.Test.Exceptions
 import System.Directory
 import System.IO
 
+-- | A session representing one instance of launching and connecting to a server.
+-- 
+-- You can send and receive messages to the server within 'Session' via 'getMessage',
+-- 'sendRequest' and 'sendNotification'.
+--
+-- @
+-- runSession \"path\/to\/root\/dir\" $ do
+--   docItem <- getDocItem "Desktop/simple.hs" "haskell"
+--   sendNotification TextDocumentDidOpen (DidOpenTextDocumentParams docItem)
+--   diagnostics <- getMessage :: Session PublishDiagnosticsNotification
+-- @
+type Session = ParserStateReader FromServerMessage SessionState SessionContext IO
+
+-- | Stuff you can configure for a 'Session'.
+data SessionConfig = SessionConfig
+  {
+    capabilities :: ClientCapabilities, -- ^ Specific capabilities the client should advertise.
+    timeout :: Int -- ^ Maximum time to wait for a request in seconds.
+  }
+
+instance Default SessionConfig where
+  def = SessionConfig def 60
+
+class Monad m => MonadSessionConfig m where
+  sessionConfig :: m SessionConfig
+
+instance Monad m => MonadSessionConfig (StateT SessionState (ReaderT SessionContext m)) where
+  sessionConfig = config <$> lift Reader.ask
+
 data SessionContext = SessionContext
   {
     serverIn :: Handle
@@ -43,6 +80,7 @@ data SessionContext = SessionContext
   , messageChan :: Chan FromServerMessage
   , requestMap :: MVar RequestMap
   , initRsp :: MVar InitializeResponse
+  , config :: SessionConfig
   }
 
 data SessionState = SessionState
@@ -53,24 +91,32 @@ data SessionState = SessionState
 
 type ParserStateReader a s r m = ConduitParser a (StateT s (ReaderT r m))
 
--- | A session representing one instance of launching and connecting to a server.
--- 
--- You can send and receive messages to the server within 'Session' via 'getMessage',
--- 'sendRequest' and 'sendNotification'.
---
--- @
--- runSession \"path\/to\/root\/dir\" $ do
---   docItem <- getDocItem "Desktop/simple.hs" "haskell"
---   sendNotification TextDocumentDidOpen (DidOpenTextDocumentParams docItem)
---   diagnostics <- getMessage :: Session PublishDiagnosticsNotification
--- @
-type Session = ParserStateReader FromServerMessage SessionState SessionContext IO
-
 type SessionProcessor = ConduitT FromServerMessage FromServerMessage (StateT SessionState (ReaderT SessionContext IO))
 
-runSession' :: Chan FromServerMessage -> SessionProcessor () -> SessionContext -> SessionState -> Session a -> IO (a, SessionState)
-runSession' chan preprocessor context state session = runReaderT (runStateT conduit state) context
-  where conduit = runConduit $ chanSource chan .| preprocessor .| runConduitParser session
+runSession :: Chan FromServerMessage -> SessionProcessor () -> SessionContext -> SessionState -> Session a -> IO (a, SessionState)
+runSession chan preprocessor context state session = runReaderT (runStateT conduit state) context
+  where conduit = runConduit $ chanSource chan .| preprocessor .| runConduitParser (catchError session handler)
+        handler e@(Unexpected "ConduitParser.empty") = do
+          
+          -- Horrible way to get last item in conduit:
+          -- Add a fake message so we can tell when to stop
+          liftIO $ writeChan chan (RspShutdown (ResponseMessage "EMPTY" IdRspNull Nothing Nothing))
+          x <- peek
+          case x of
+            Just x -> do
+              lastMsg <- skipToEnd x
+              name <- getParserName
+              liftIO $ throw (UnexpectedMessageException (T.unpack name) lastMsg)
+            Nothing -> throw e
+
+        handler e = throw e
+
+        skipToEnd x = do
+          y <- peek
+          case y of
+            Just (RspShutdown (ResponseMessage "EMPTY" IdRspNull Nothing Nothing)) -> return x
+            Just _ -> await >>= skipToEnd
+            Nothing -> return x
 
 get :: Monad m => ParserStateReader a s r m s
 get = lift State.get
@@ -89,10 +135,11 @@ ask = lift $ lift Reader.ask
 runSessionWithHandles :: Handle -- ^ Server in
                       -> Handle -- ^ Server out
                       -> (Handle -> Session ()) -- ^ Server listener
+                      -> SessionConfig
                       -> FilePath
                       -> Session a
                       -> IO a
-runSessionWithHandles serverIn serverOut serverHandler rootDir session = do
+runSessionWithHandles serverIn serverOut serverHandler config rootDir session = do
   absRootDir <- canonicalizePath rootDir
 
   hSetBuffering serverIn  NoBuffering
@@ -103,11 +150,11 @@ runSessionWithHandles serverIn serverOut serverHandler rootDir session = do
   meaninglessChan <- newChan
   initRsp <- newEmptyMVar
 
-  let context = SessionContext serverIn absRootDir messageChan reqMap initRsp
+  let context = SessionContext serverIn absRootDir messageChan reqMap initRsp config
       initState = SessionState (IdInt 0) mempty
 
-  threadId <- forkIO $ void $ runSession' meaninglessChan processor context initState (serverHandler serverOut)
-  (result, _) <- runSession' messageChan processor context initState session
+  threadId <- forkIO $ void $ runSession meaninglessChan processor context initState (serverHandler serverOut)
+  (result, _) <- runSession messageChan processor context initState session
 
   killThread threadId
 
@@ -130,6 +177,7 @@ processTextChanges (ReqApplyWorkspaceEdit r) = do
   let groupedParams = groupBy (\a b -> (a ^. textDocument == b ^. textDocument)) changeParams
       mergedParams = map mergeParams groupedParams
 
+  -- TODO: Don't do this when replaying a session
   forM_ mergedParams $ \p -> do
     h <- serverIn <$> lift (lift Reader.ask)
     let msg = NotificationMessage "2.0" TextDocumentDidChange p