Try to use configured formatter instead of brittany

Author: fendor

hie-plugin-api/Haskell/Ide/Engine/PluginsIdeMonads.hs

@@ -75,6 +75,7 @@ module Haskell.Ide.Engine.PluginsIdeMonads
   , PublishDiagnosticsParams(..)
   , List(..)
   , FormattingOptions(..)
+  , FormatCmdParams(..)
   )
 where
 
@@ -208,9 +209,30 @@ type HoverProvider = Uri -> Position -> IdeM (IdeResult [Hover])
 
 type SymbolProvider = Uri -> IdeDeferM (IdeResult [DocumentSymbol])
 
+-- |Format Paramaters for Cmd.
+-- Turns the 'FormattingType' into a record.
+data FormatCmdParams = FormatCmdParams
+  { fmtUri ::  Uri -- ^ Uri to the file to format
+  , fmtType :: FormattingType -- ^ How much and what to format
+  , fmtOptions :: FormattingOptions -- ^ Options for the formatter
+  }
+  deriving (Eq, Show, Generic, FromJSON, ToJSON)
+
+-- | Format the document either as a whole or only a given Range of it.
 data FormattingType = FormatDocument
                     | FormatRange Range
-type FormattingProvider = Uri -> FormattingType -> FormattingOptions -> IdeDeferM (IdeResult [TextEdit])
+                    deriving (Eq, Show, Generic, FromJSON, ToJSON)
+
+-- |Formats the given Uri with the given options.
+-- A formatting type can be given to either format the whole documetn or only a Range.
+-- Fails if the formatter can not parse the source.
+-- Failing menas here that a IdeResultFail is returned.
+-- This can be used to display errors to the user, unless the error is an Internal one.
+-- The record 'IdeError' and 'IdeErrorCode' can be used to determine the type of error.
+type FormattingProvider = Uri -- ^ Uri to the file to format. Can be mapped to a file with `pluginGetFile`
+        -> FormattingType  -- ^ How much to format
+        -> FormattingOptions -- ^ Options for the formatter
+        -> IdeDeferM (IdeResult [TextEdit]) -- ^ Result of the formatting or the unchanged text.
 
 data PluginDescriptor =
   PluginDescriptor { pluginId                 :: PluginId

src/Haskell/Ide/Engine/LSP/Reactor.hs

@@ -37,6 +37,8 @@ data REnv = REnv
   , hoverProviders      :: [HoverProvider]
   , symbolProviders     :: [SymbolProvider]
   , formattingProviders :: Map.Map PluginId FormattingProvider
+  -- | Ide Plugins that are available
+  , idePlugins          :: IdePlugins
   -- TODO: Add code action providers here
   }
 
@@ -58,11 +60,12 @@ runReactor
   -> [HoverProvider]
   -> [SymbolProvider]
   -> Map.Map PluginId FormattingProvider
+  -> IdePlugins
   -> R a
   -> IO a
-runReactor lf sc dps hps sps fps f = do
+runReactor lf sc dps hps sps fps plugins f = do
   pid <- getProcessID
-  runReaderT f (REnv sc lf pid dps hps sps fps)
+  runReaderT f (REnv sc lf pid dps hps sps fps plugins)
 
 -- ---------------------------------------------------------------------
 

src/Haskell/Ide/Engine/Plugin/Brittany.hs

@@ -25,44 +25,75 @@ data FormatParams = FormatParams Int Uri (Maybe Range)
 
 brittanyDescriptor :: PluginId -> PluginDescriptor
 brittanyDescriptor plId = PluginDescriptor
-  { pluginId       = plId
-  , pluginName     = "Brittany"
-  , pluginDesc     = "Brittany is a tool to format source code."
-  , pluginCommands = []
+  { pluginId = plId
+  , pluginName = "Brittany"
+  , pluginDesc = "Brittany is a tool to format source code."
+  , pluginCommands = [PluginCommand "format" "Format the document" formatCmd]
   , pluginCodeActionProvider = Nothing
   , pluginDiagnosticProvider = Nothing
   , pluginHoverProvider = Nothing
   , pluginSymbolProvider = Nothing
   , pluginFormattingProvider = Just provider
   }
 
+-- |Formatter provider of Brittany.
+-- Results can be deferred, e.g. the file is reformatted when it is loaded and type checked.
+-- If the provider fails an error is returned. 
 provider :: FormattingProvider
-provider uri formatType opts = pluginGetFile "brittanyCmd: " uri $ \file -> do
-  confFile <- liftIO $ getConfFile file
+provider = format
+
+-- |Formatter of Brittany.
+-- Formats the given source in either a given Range or the whole Document.
+-- If the provider fails an error is returned that can be displayed to the user.
+format :: (MonadIO m, MonadIde m)
+       => Uri
+       -> FormattingType
+       -> FormattingOptions
+       -> m (IdeResult [TextEdit])
+format uri formatType opts = pluginGetFile "brittanyCmd: " uri $ \fp -> do
+  confFile <- liftIO $ getConfFile fp
   mtext <- readVFS uri
   case mtext of
-    Nothing -> return $ IdeResultFail (IdeError InternalError "File was not open" Null)
+    Nothing   -> return
+      $ IdeResultFail (IdeError InternalError "File was not open" Null)
     Just text -> case formatType of
-      FormatRange r -> do
+      FormatRange r  -> do
         res <- liftIO $ runBrittany tabSize confFile $ extractRange r text
         case res of
-          Left err -> return $ IdeResultFail (IdeError PluginError
-                      (T.pack $ "brittanyCmd: " ++ unlines (map showErr err)) Null)
+          Left err      -> return
+            $ IdeResultFail
+              (IdeError
+                 PluginError
+                 (T.pack $ "brittanyCmd: " ++ unlines (map showErr err))
+                 Null)
           Right newText -> do
             let textEdit = J.TextEdit (normalize r) newText
             return $ IdeResultOk [textEdit]
       FormatDocument -> do
         res <- liftIO $ runBrittany tabSize confFile text
         case res of
-          Left err -> return $ IdeResultFail (IdeError PluginError
-                      (T.pack $ "brittanyCmd: " ++ unlines (map showErr err)) Null)
-          Right newText ->
-            return $ IdeResultOk [J.TextEdit (fullRange text) newText]
-  where tabSize = opts ^. J.tabSize
+          Left err      -> return
+            $ IdeResultFail
+              (IdeError
+                 PluginError
+                 (T.pack $ "brittanyCmd: " ++ unlines (map showErr err))
+                 Null)
+          Right newText -> return
+            $ IdeResultOk [J.TextEdit (fullRange text) newText]
+  where
+    tabSize = opts ^. J.tabSize
+
+-- | Format a source with the given options.
+-- Synchronized command.
+-- Other plugins can use this Command it to execute formatters.
+-- Command can be run by ``
+formatCmd :: CommandFunc FormatCmdParams [TextEdit]
+formatCmd = CmdSync $ \fmtParam -> 
+  format (fmtUri fmtParam) (fmtType fmtParam) (fmtOptions fmtParam)
 
+-- | Extend to the line below to replace newline character, as above.
 normalize :: Range -> Range
 normalize (Range (Position sl _) (Position el _)) =
-  -- Extend to the line below to replace newline character, as above
   Range (Position sl 0) (Position (el + 1) 0)
 
 getConfFile :: FilePath -> IO (Maybe FilePath)

src/Haskell/Ide/Engine/Plugin/HsImport.hs

@@ -21,6 +21,7 @@ import qualified GhcMod.Utils                  as GM
 import           HsImport
 import           Haskell.Ide.Engine.Config
 import           Haskell.Ide.Engine.MonadTypes
+import qualified Haskell.Ide.Engine.Support.HieExtras as Hie
 import qualified Language.Haskell.LSP.Types      as J
 import qualified Language.Haskell.LSP.Types.Lens as J
 import           Haskell.Ide.Engine.PluginUtils
@@ -83,14 +84,25 @@ importModule uri modName =
 
           if shouldFormat
             then do
-              -- Format the import with Brittany
-              confFile <- liftIO $ Brittany.getConfFile origInput
-              newChanges <- forM mChanges $ mapM $ mapM (formatTextEdit confFile)
-              newDocChanges <- forM mDocChanges $ mapM $ \(J.TextDocumentEdit vDocId tes) -> do
-                ftes <- forM tes (formatTextEdit confFile)
-                return (J.TextDocumentEdit vDocId ftes)
-
-              return $ IdeResultOk (J.WorkspaceEdit newChanges newDocChanges)
+              config <- getConfig
+              plugins <- getPlugins
+              let mprovider = Hie.getFormattingPlugin config plugins
+              case mprovider of 
+                Nothing -> return $ IdeResultOk (J.WorkspaceEdit mChanges mDocChanges)
+                Just (plugin, _) -> do
+                  let fmtCmd = J.Command "unused" 
+                  results <- forM mChanges $ mapM $ mapM $ (runPluginCommand (pluginId plugin) "format" . dynToJSON . toDynJSON)
+
+
+
+                  -- -- Format the import with Brittany
+                  -- confFile <- liftIO $ Brittany.getConfFile origInput
+                  -- newChanges <- forM mChanges $ mapM $ mapM (formatTextEdit confFile)
+                  -- newDocChanges <- forM mDocChanges $ mapM $ \(J.TextDocumentEdit vDocId tes) -> do
+                  --   ftes <- forM tes (formatTextEdit confFile)
+                  --   return (J.TextDocumentEdit vDocId ftes)
+
+                  return $ IdeResultOk  (J.WorkspaceEdit mChanges mDocChanges) -- (J.WorkspaceEdit newChanges newDocChanges)
             else
               return $ IdeResultOk (J.WorkspaceEdit mChanges mDocChanges)
 

src/Haskell/Ide/Engine/Support/HieExtras.hs

@@ -20,6 +20,7 @@ module Haskell.Ide.Engine.Support.HieExtras
   , runGhcModCommand
   , splitCaseCmd'
   , splitCaseCmd
+  , getFormattingPlugin
   ) where
 
 import           ConLike
@@ -52,6 +53,7 @@ import qualified GhcMod.Gap                                   as GM
 import qualified GhcMod.LightGhc                              as GM
 import qualified GhcMod.Utils                                 as GM
 import           Haskell.Ide.Engine.ArtifactMap
+import           Haskell.Ide.Engine.Config
 import           Haskell.Ide.Engine.Context
 import           Haskell.Ide.Engine.MonadFunctions
 import           Haskell.Ide.Engine.MonadTypes
@@ -741,3 +743,12 @@ prefixes =
   , "$c"
   , "$m"
   ]
+
+-- ---------------------------------------------------------------------
+
+getFormattingPlugin :: Config -> IdePlugins -> Maybe (PluginDescriptor, FormattingProvider)
+getFormattingPlugin config plugins = do 
+  let providerName = formattingProvider config
+  fmtPlugin <- Map.lookup providerName (ipMap plugins)
+  fmtProvider <- pluginFormattingProvider fmtPlugin
+  return (fmtPlugin, fmtProvider)

src/Haskell/Ide/Engine/Transport/LspStdio.hs

@@ -122,7 +122,7 @@ run scheduler _origDir plugins captureFp = flip E.catches handlers $ do
 
   let dp lf = do
         diagIn      <- atomically newTChan
-        let react = runReactor lf scheduler diagnosticProviders hps sps fps
+        let react = runReactor lf scheduler diagnosticProviders hps sps fps plugins
             reactorFunc = react $ reactor rin diagIn
 
         let errorHandler :: Scheduler.ErrorHandler
@@ -797,21 +797,22 @@ reactor inp diagIn = do
 
 getFormattingProvider :: R FormattingProvider
 getFormattingProvider = do
-  providers <- asks formattingProviders
+  plugins <- asks idePlugins
   lf <- asks lspFuncs
   mc <- liftIO $ Core.config lf
-  -- LL: Is this overengineered? Do we need a pluginFormattingProvider
-  -- or should we just call plugins straight from here based on the providerType?
-  let providerName = formattingProvider (fromMaybe def mc)
-      mProvider = Map.lookup providerName providers
-  case mProvider of
+  let config = fromMaybe def mc
+      -- LL: Is this overengineered? Do we need a pluginFormattingProvider
+      -- or should we just call plugins straight from here based on the providerType?
+      providerName = formattingProvider config
+      mprovider = Hie.getFormattingPlugin config plugins
+  case mprovider of
     Nothing -> do
       unless (providerName == "none") $ do
         let msg = providerName <> " is not a recognised plugin for formatting. Check your config"
         reactorSend $ NotShowMessage $ fmServerShowMessageNotification J.MtWarning msg
         reactorSend $ NotLogMessage $ fmServerLogMessageNotification J.MtWarning msg    
       return (\_ _ _ -> return (IdeResultOk [])) -- nop formatter
-    Just provider -> return provider
+    Just (_, provider) -> return provider
 
 -- ---------------------------------------------------------------------