nvim-hs 2.3.2.4 → 2.3.2.6

raw patch · 4 files changed

+44/−18 lines, 4 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• nvim-hs.cabal +1/−1
• src/Neovim/API/Parser.hs +29/−7
• src/Neovim/API/TH.hs +4/−4
• src/Neovim/Plugin.hs +10/−6

@@ -1,6 +1,6 @@ cabal-version:       3.0 name:                nvim-hs-version:             2.3.2.4+version:             2.3.2.6 synopsis:            Haskell plugin backend for neovim description:   This package provides a plugin provider for neovim. It allows you to write

@@ -12,6 +12,7 @@ module Neovim.API.Parser (     NeovimAPI (..),     NeovimFunction (..),+    NeovimFunctionParameters (..),     NeovimType (..),     parseAPI, ) where@@ -26,7 +27,7 @@ import qualified Data.ByteString.Lazy as LB import Data.Map (Map) import qualified Data.Map as Map-import Data.MessagePack (Object)+import Data.MessagePack (Object (..)) import Data.Serialize (decode) import Neovim.Compat.Megaparsec as P (     MonadParsec (eof, try),@@ -60,7 +61,7 @@ data NeovimFunction = NeovimFunction     { name :: String     -- ^ function name-    , parameters :: [(NeovimType, String)]+    , parameters :: [NeovimFunctionParameters]     -- ^ A list of type name and variable name.     , canFail :: Bool     -- ^ Indicator whether the function can fail/throws exceptions.@@ -71,6 +72,13 @@     }     deriving (Show) +data NeovimFunctionParameters = NeovimFunctionParameters+    { parameterType :: NeovimType+    , parameterName :: String+    , parameterIsOptional :: Bool+    }+    deriving (Show)+ {- | This data type represents the top-level structure of the @nvim --api-info@  output. -}@@ -136,16 +144,30 @@ extractFunctions :: Map String Object -> Either (Doc AnsiStyle) [NeovimFunction] extractFunctions objAPI = mapM extractFunction =<< oLookup "functions" objAPI -toParameterlist :: [(String, String)] -> Either (Doc AnsiStyle) [(NeovimType, String)]-toParameterlist ps = forM ps $ \(t, n) -> do-    t' <- parseType t-    return (t', n)+parseFunctionParameters :: Map String Object -> Either (Doc AnsiStyle) [NeovimFunctionParameters]+parseFunctionParameters m = case Map.lookup "parameters" m of+    Just (ObjectArray params) -> mapM parseFunctionParameter params+    Just o -> throwError $ "Unexpected object for function parameters array: " <> pretty (show o)+    Nothing -> throwError $ "No entry for: parameters" +parseFunctionParameter :: Object -> Either (Doc AnsiStyle) NeovimFunctionParameters+parseFunctionParameter o = case o of+    ObjectArray (typeObj : nameObj : rest) -> do+        t <- parseType =<< fromObject typeObj+        n <- fromObject nameObj+        isOptional <- case rest of+            [] -> pure False -- for backwards compatibility+            [ObjectBool b] -> pure b+            [notBool] -> throwError $ "Expected boolean to indicate optionality: " <> pretty (show notBool)+            os -> throwError $ "Unexpected remainder of " <> pretty (show os)+        pure $ NeovimFunctionParameters t n isOptional+    notArray -> throwError $ "Unexpected object for function parameters" <> pretty (show notArray)+ extractFunction :: Map String Object -> Either (Doc AnsiStyle) NeovimFunction extractFunction funDefMap =     NeovimFunction         <$> oLookup "name" funDefMap-        <*> (oLookup "parameters" funDefMap >>= toParameterlist)+        <*> parseFunctionParameters funDefMap         <*> oLookupDefault True "can_fail" funDefMap         <*> oLookupDefault False "async" funDefMap         <*> (oLookup "return_type" funDefMap >>= parseType)

@@ -199,15 +199,15 @@     let prefixWithNumber i n = "arg" ++ show i ++ "_" ++ n         applyPrefixWithNumber =             zipWith-                (\i (t, n) -> (t, prefixWithNumber i n))+                (\i p -> p { parameterName = prefixWithNumber i (parameterName p) })                 [0 :: Int ..]                 . parameters     vars <-         mapM-            ( \(t, n) ->+            ( \NeovimFunctionParameters{parameterType, parameterName} ->                 (,)-                    <$> apiTypeToHaskellType typeMap t-                    <*> newName n+                    <$> apiTypeToHaskellType typeMap parameterType+                    <*> newName parameterName             )             $ applyPrefixWithNumber nf 

@@ -26,7 +26,7 @@ ) where  import Neovim.API.String-    ( nvim_err_writeln, nvim_get_api_info, vim_call_function )+    ( nvim_err_writeln, vim_call_function ) import Neovim.Classes     ( (<+>),       Doc,@@ -70,14 +70,14 @@       getDescription,       getFunction,       wrapPlugin )-import Neovim.RPC.FunctionCall ( respond )+import Neovim.RPC.FunctionCall ( respond, scall' )  import Control.Monad (foldM, void) import Data.Foldable (forM_) import Data.Map (Map) import qualified Data.Map as Map import Data.Either (rights)-import Data.MessagePack ( Object )+import Data.MessagePack ( Object (ObjectArray) ) import Data.Text (Text) import Data.Traversable (forM) import System.Log.Logger ( debugM, errorM )@@ -202,10 +202,12 @@         Just p ->             return p         Nothing -> do-            api <- nvim_get_api_info+            -- The return type of nvim_get_api_info has changed. It is now a 2 element array, which+            -- generates a tuple of 2 elements. To make this code backwards compatible, we use+            -- internals here.+            api <- scall' (F "nvim_get_api_info") []             case api of-                [] -> err "empty nvim_get_api_info"-                (i : _) -> do+                ObjectArray (i : _) -> do                     case fromObject i :: Either (Doc AnsiStyle) Int of                         Left _ ->                             err $@@ -214,6 +216,8 @@                         Right channelId -> do                             liftIO . atomically . putTMVar mp . Right $ fromIntegral channelId                             return . Right $ fromIntegral channelId+                ObjectArray [] -> err "empty nvim_get_api_info"+                _ -> err $ "Unexpected reutnr type of nvim_get_api_info"  registerFunctionality ::     FunctionalityDescription ->