Don't load renderers until requested

Author: LaurentRDC

executable/Main.hs

@@ -9,7 +9,6 @@ module Main where
 
 import Control.Monad (join, msum, void, when)
 import Data.List (intersperse, (\\))
-import Data.Maybe (fromJust)
 import Data.Text (unpack)
 import qualified Data.Text.IO as TIO
 import Data.Version (parseVersion, showVersion)
@@ -58,15 +57,15 @@ import Text.Pandoc.Filter.Plot
     plotFilter,
   )
 import Text.Pandoc.Filter.Plot.Internal
-  ( Executable (..),
-    cleanOutputDirs,
+  ( cleanOutputDirs,
     cls,
     configurationPathMeta,
     executable,
     readDoc,
     runPlotM,
     supportedSaveFormats,
-    toolkits,
+    toolkits, 
+    pathToExe
   )
 import Text.Pandoc.JSON (toJSONFilter)
 import Text.ParserCombinators.ReadP (readP_to_S)
@@ -286,8 +285,8 @@ showAvailableToolkits mfp = do
     toolkitInfo avail conf tk = do
       putStrLn $ "Toolkit: " <> show tk
       when avail $ do
-        Executable dir exe <- fmap fromJust $ runPlotM Nothing conf $ executable tk
-        putStrLn $ "    Executable: " <> (dir </> unpack exe)
+        exe <- runPlotM Nothing conf $ executable tk
+        putStrLn $ "    Executable: " <> (pathToExe exe)
       putStrLn $ "    Code block trigger: " <> (unpack . cls $ tk)
       putStrLn $ "    Supported save formats: " <> (mconcat . intersperse ", " . fmap show $ supportedSaveFormats tk)
       putStrLn mempty

src/Text/Pandoc/Filter/Plot/Monad.hs

@@ -74,7 +74,6 @@ import Control.Monad.State.Strict
     evalStateT,
   )
 import Data.ByteString.Lazy (toStrict)
-import Data.Functor ((<&>))
 import Data.Hashable (hash)
 import Data.Map.Strict (Map)
 import qualified Data.Map.Strict as M
@@ -84,7 +83,6 @@ import Data.Text.Encoding (decodeUtf8With)
 import Data.Text.Encoding.Error (lenientDecode)
 import System.Directory
   ( doesFileExist,
-    findExecutable,
     getCurrentDirectory,
     getModificationTime,
   )
@@ -269,12 +267,8 @@ fileHash path = do
         else err (mconcat ["Dependency ", pack fp, " does not exist."]) >> return 0
 
 -- | Find an executable.
-executable :: Toolkit -> PlotM (Maybe Executable)
-executable tk =
-  exeSelector tk
-    >>= \name ->
-      liftIO $
-        findExecutable name <&> fmap exeFromPath
+executable :: Toolkit -> PlotM Executable
+executable tk = exeSelector tk >>= return . exeFromPath
   where
     exeSelector Matplotlib = asksConfig matplotlibExe
     exeSelector PlotlyPython = asksConfig plotlyPythonExe

src/Text/Pandoc/Filter/Plot/Monad/Types.hs

@@ -14,6 +14,7 @@
 module Text.Pandoc.Filter.Plot.Monad.Types
   ( Toolkit (..),
     Renderer (..),
+    AvailabilityCheck(..),
     Script,
     CheckResult (..),
     InclusionKey (..),
@@ -38,7 +39,7 @@ import Data.String (IsString (..))
 import Data.Text (Text, pack, unpack)
 import Data.Yaml (FromJSON(..), ToJSON (toJSON), withText)
 import GHC.Generics (Generic)
-import System.FilePath (splitFileName, (</>))
+import System.FilePath (splitFileName, (</>), isAbsolute)
 import System.Info (os)
 import Text.Pandoc.Definition (Attr)
 
@@ -95,16 +96,20 @@ cls Plotsjl = "plotsjl"
 cls PlantUML = "plantuml"
 cls SageMath = "sageplot"
 
--- | Executable program and directory where it can be found.
-data Executable = Executable FilePath Text
+-- | Executable program, and sometimes the directory where it can be found.
+data Executable 
+  = AbsExe FilePath Text
+  | RelExe Text
 
 exeFromPath :: FilePath -> Executable
-exeFromPath fp =
-  let (dir, name) = splitFileName fp
-   in Executable dir (pack name)
+exeFromPath fp
+  | isAbsolute fp = let (dir, name) = splitFileName fp
+                     in AbsExe dir (pack name)
+  | otherwise     = RelExe (pack fp) 
 
 pathToExe :: Executable -> FilePath
-pathToExe (Executable dir name) = dir </> unpack name 
+pathToExe (AbsExe dir name) = dir </> unpack name 
+pathToExe (RelExe name)            = unpack name
 
 -- | Source context for plotting scripts
 type Script = Text
@@ -275,10 +280,15 @@ data OutputSpec = OutputSpec
     oCWD :: FilePath
   }
 
+data AvailabilityCheck
+  = CommandSuccess (Executable -> Text)
+  | ExecutableExists
+
 data Renderer = Renderer
   { rendererToolkit :: Toolkit,
     rendererCapture :: FigureSpec -> FilePath -> Script,
     rendererCommand :: OutputSpec -> Text,
+    rendererAvailability :: AvailabilityCheck,
     rendererSupportedSaveFormats :: [SaveFormat],
     rendererChecks :: [Script -> CheckResult],
     rendererLanguage :: Text,

src/Text/Pandoc/Filter/Plot/Parse.hs

@@ -70,11 +70,7 @@ parseFigureSpec block@(CodeBlock (id', classes, attrs) _) = do
     Nothing -> return NotAFigure
     Just tk -> do
       r <- renderer tk
-      case r of
-        Nothing -> do
-          err $ mconcat ["Renderer for ", tshow tk, " needed but is not installed"]
-          return $ MissingToolkit tk
-        Just r' -> figureSpec r'
+      figureSpec r
   where
     attrs' = Map.fromList attrs
     preamblePath = unpack <$> Map.lookup (tshow PreambleK) attrs'
@@ -109,7 +105,7 @@ parseFigureSpec block@(CodeBlock (id', classes, attrs) _) = do
           -- Decide between reading from file or using document content
           content <- parseContent block
 
-          defaultExe <- fromJust <$> (executable rendererToolkit)
+          defaultExe <- executable rendererToolkit
 
           let caption = Map.findWithDefault mempty (tshow CaptionK) attrs'
               fsExecutable = maybe defaultExe (exeFromPath . unpack) $ Map.lookup (tshow ExecutableK) attrs'

src/Text/Pandoc/Filter/Plot/Renderers.hs

@@ -27,16 +27,14 @@ module Text.Pandoc.Filter.Plot.Renderers
 where
 
 import Control.Concurrent.Async.Lifted (forConcurrently)
-import Control.Concurrent.MVar (putMVar, takeMVar)
 import Control.Monad.Reader (local)
-import Control.Monad.State.Strict
-  ( MonadState (get, put),
-  )
+import Data.Functor ((<&>))
 import Data.List ((\\))
 import Data.Map.Strict (Map)
 import qualified Data.Map.Strict as M
 import Data.Maybe (catMaybes, isJust)
 import Data.Text (Text, pack)
+import System.Exit (ExitCode (..))
 import Text.Pandoc.Filter.Plot.Monad
 import Text.Pandoc.Filter.Plot.Monad.Logging
   ( Logger (lVerbosity),
@@ -67,41 +65,25 @@ import Text.Pandoc.Filter.Plot.Renderers.Plotsjl
     ( plotsjl, plotsjlSupportedSaveFormats )
 import Text.Pandoc.Filter.Plot.Renderers.SageMath
     ( sagemath, sagemathSupportedSaveFormats )
+import System.Directory (findExecutable)
 
 -- | Get the renderer associated with a toolkit.
 -- If the renderer has not been used before,
 -- initialize it and store where it is. It will be re-used.
-renderer :: Toolkit -> PlotM (Maybe Renderer)
-renderer tk = do
-  PlotState varHashes varRenderers <- get
-  renderers <- liftIO $ takeMVar varRenderers
-  (r', rs') <- case M.lookup tk renderers of
-    Nothing -> do
-      debug $ mconcat ["Looking for renderer for ", pack $ show tk]
-      r' <- sel tk
-      let rs' = M.insert tk r' renderers
-      return (r', rs')
-    Just e -> do
-      debug $ mconcat ["Renderer for \"", pack $ show tk, "\" already initialized."]
-      return (e, renderers)
-  liftIO $ putMVar varRenderers rs'
-  put $ PlotState varHashes varRenderers
-  return r'
-  where
-    sel :: Toolkit -> PlotM (Maybe Renderer)
-    sel Matplotlib = matplotlib
-    sel PlotlyPython = plotlyPython
-    sel PlotlyR = plotlyR
-    sel Matlab = matlab
-    sel Mathematica = mathematica
-    sel Octave = octave
-    sel GGPlot2 = ggplot2
-    sel GNUPlot = gnuplot
-    sel Graphviz = graphviz
-    sel Bokeh = bokeh
-    sel Plotsjl = plotsjl
-    sel PlantUML = plantuml
-    sel SageMath = sagemath
+renderer :: Toolkit -> PlotM Renderer
+renderer Matplotlib = matplotlib
+renderer PlotlyPython = plotlyPython
+renderer PlotlyR = plotlyR
+renderer Matlab = matlab
+renderer Mathematica = mathematica
+renderer Octave = octave
+renderer GGPlot2 = ggplot2
+renderer GNUPlot = gnuplot
+renderer Graphviz = graphviz
+renderer Bokeh = bokeh
+renderer Plotsjl = plotsjl
+renderer PlantUML = plantuml
+renderer SageMath = sagemath
 
 -- | Save formats supported by this renderer.
 supportedSaveFormats :: Toolkit -> [SaveFormat]
@@ -157,14 +139,29 @@ unavailableToolkits conf = runPlotM Nothing conf unavailableToolkitsM
 availableToolkitsM :: PlotM [Toolkit]
 availableToolkitsM = asNonStrictAndSilent $ do
     mtks <- forConcurrently toolkits $ \tk -> do
-      available <- isJust <$> renderer tk
-      if available
+      r <- renderer tk
+      exe <- executable tk
+      a <- isAvailable exe (rendererAvailability r)
+      if a
         then return $ Just tk
         else return Nothing
     return $ catMaybes mtks
   where
     asNonStrictAndSilent = local (\(RuntimeEnv f c l d) -> RuntimeEnv f (c{strictMode = False}) (l{lVerbosity = Silent}) d)
 
+    -- | Check that the supplied command results in
+    -- an exit code of 0 (i.e. no errors)
+    commandSuccess :: Text -> PlotM Bool
+    commandSuccess s = do
+      cwd <- asks envCWD 
+      (ec, _) <- runCommand cwd s
+      debug $ mconcat ["Command ", s, " resulted in ", pack $ show ec]
+      return $ ec == ExitSuccess
+
+    isAvailable :: Executable -> AvailabilityCheck -> PlotM Bool
+    isAvailable exe (CommandSuccess f) = commandSuccess (f exe)
+    isAvailable exe (ExecutableExists) = liftIO $ findExecutable (pathToExe exe) <&> isJust
+
 -- | Monadic version of @unavailableToolkits@
 unavailableToolkitsM :: PlotM [Toolkit]
 unavailableToolkitsM = (\\) toolkits <$> availableToolkitsM

src/Text/Pandoc/Filter/Plot/Renderers/Bokeh.hs

@@ -22,39 +22,28 @@ import Data.Monoid (Any (..))
 import qualified Data.Text as T
 import Text.Pandoc.Filter.Plot.Renderers.Prelude
 
-bokeh :: PlotM (Maybe Renderer)
+bokeh :: PlotM Renderer
 bokeh = do
-  avail <- bokehAvailable
-  if not avail
-    then return Nothing
-    else do
       cmdargs <- asksConfig bokehCmdArgs
       return $
-          return
-            Renderer
-              { rendererToolkit = Bokeh,
-                rendererCapture = appendCapture bokehCaptureFragment,
-                rendererCommand = bokehCommand cmdargs,
-                rendererSupportedSaveFormats = bokehSupportedSaveFormats,
-                rendererChecks = [bokehCheckIfShow],
-                rendererLanguage = "python",
-                rendererComment = mappend "# ",
-                rendererScriptExtension = ".py"
-              }
+        Renderer
+          { rendererToolkit = Bokeh,
+            rendererCapture = appendCapture bokehCaptureFragment,
+            rendererCommand = bokehCommand cmdargs,
+            rendererAvailability = CommandSuccess $ \exe -> [st|#{pathToExe exe} -c "import bokeh; import selenium"|],
+            rendererSupportedSaveFormats = bokehSupportedSaveFormats,
+            rendererChecks = [bokehCheckIfShow],
+            rendererLanguage = "python",
+            rendererComment = mappend "# ",
+            rendererScriptExtension = ".py"
+          }
 
 bokehSupportedSaveFormats :: [SaveFormat]
 bokehSupportedSaveFormats = [PNG, SVG, HTML]
 
 bokehCommand :: Text -> OutputSpec -> Text
 bokehCommand cmdargs OutputSpec {..} = [st|#{pathToExe oExecutable} #{cmdargs} "#{oScriptPath}"|]
 
-bokehAvailable :: PlotM Bool
-bokehAvailable = do
-  mexe <- executable Bokeh
-  case mexe of
-    Nothing -> return False
-    Just (Executable dir exe) -> withPrependedPath dir $ asks envCWD >>= flip commandSuccess [st|#{exe} -c "import bokeh; import selenium"|]
-
 -- | Check if `bokeh.io.show()` calls are present in the script,
 -- which would halt pandoc-plot
 bokehCheckIfShow :: Script -> CheckResult

src/Text/Pandoc/Filter/Plot/Renderers/GGPlot2.hs

@@ -21,40 +21,28 @@ where
 import qualified Data.Text as T
 import Text.Pandoc.Filter.Plot.Renderers.Prelude
 
-ggplot2 :: PlotM (Maybe Renderer)
+ggplot2 :: PlotM Renderer
 ggplot2 = do
-  avail <- ggplot2Available
-  if not avail
-    then return Nothing
-    else do
       cmdargs <- asksConfig ggplot2CmdArgs
       return $
-          return
-            Renderer
-              { rendererToolkit = GGPlot2,
-                rendererCapture = ggplot2Capture,
-                rendererCommand = ggplot2Command cmdargs,
-                rendererSupportedSaveFormats = ggplot2SupportedSaveFormats,
-                rendererChecks = mempty,
-                rendererLanguage = "r",
-                rendererComment = mappend "# ",
-                rendererScriptExtension = ".r"
-              }
+        Renderer
+          { rendererToolkit = GGPlot2,
+            rendererCapture = ggplot2Capture,
+            rendererCommand = ggplot2Command cmdargs,
+            rendererAvailability = CommandSuccess $ \exe -> [st|#{pathToExe exe} -e "if(!require('ggplot2')) {quit(status=1)}"|],
+            rendererSupportedSaveFormats = ggplot2SupportedSaveFormats,
+            rendererChecks = mempty,
+            rendererLanguage = "r",
+            rendererComment = mappend "# ",
+            rendererScriptExtension = ".r"
+          }
 
 ggplot2SupportedSaveFormats :: [SaveFormat]
 ggplot2SupportedSaveFormats = [PNG, PDF, SVG, JPG, EPS, TIF]
 
 ggplot2Command :: Text -> OutputSpec -> Text
 ggplot2Command cmdargs OutputSpec {..} = [st|#{pathToExe oExecutable} #{cmdargs} "#{oScriptPath}"|]
 
-ggplot2Available :: PlotM Bool
-ggplot2Available = do
-  mexe <- executable GGPlot2
-  case mexe of
-    Nothing -> return False
-    Just (Executable dir exe) ->
-      withPrependedPath dir $ asks envCWD >>= flip commandSuccess [st|#{exe} -e "if(!require('ggplot2')) {quit(status=1)}"|]
-
 ggplot2Capture :: FigureSpec -> FilePath -> Script
 ggplot2Capture fs fp =
   T.unlines