------------------------------------------------------------------------------
-- |
-- Module: Xmobar.App.Main
-- Copyright: (c) 2018, 2019, 2020, 2022 Jose Antonio Ortega Ruiz
-- License: BSD3-style (see LICENSE)
--
-- Maintainer: jao@gnu.org
-- Stability: unstable
-- Portability: portable
-- Created: Sun Nov 25, 2018 21:53
--
--
-- Support for creating executable main functions
--
------------------------------------------------------------------------------


module Xmobar.App.Main (xmobar, xmobarMain, configFromArgs) where


import Data.List (intercalate)
import System.Posix.Process (executeFile)
import System.Environment (getArgs)
import System.FilePath ((</>), takeBaseName, takeDirectory, takeExtension)
import Text.Parsec.Error (ParseError)

import Control.Monad (unless)

import Xmobar.App.Config
import Xmobar.Config.Types
import Xmobar.Config.Parse
import Xmobar.X11.Loop (x11Loop)
import Xmobar.Text.Loop (textLoop)
import Xmobar.App.Opts (recompileFlag, verboseFlag, getOpts, doOpts)
import Xmobar.App.Compile (recompile, trace)

xmobar :: Config -> IO ()
xmobar :: Config -> IO ()
xmobar Config
cfg = if Config -> Bool
textOutput Config
cfg then Config -> IO ()
textLoop Config
cfg else Config -> IO ()
x11Loop Config
cfg

configFromArgs :: Config -> IO Config
configFromArgs :: Config -> IO Config
configFromArgs Config
cfg = IO [[Char]]
getArgs IO [[Char]]
-> ([[Char]] -> IO ([Opts], [[Char]])) -> IO ([Opts], [[Char]])
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [[Char]] -> IO ([Opts], [[Char]])
getOpts IO ([Opts], [[Char]])
-> (([Opts], [[Char]]) -> IO Config) -> IO Config
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Config -> [Opts] -> IO Config
doOpts Config
cfg ([Opts] -> IO Config)
-> (([Opts], [[Char]]) -> [Opts])
-> ([Opts], [[Char]])
-> IO Config
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Opts], [[Char]]) -> [Opts]
forall a b. (a, b) -> a
fst

buildLaunch :: [String] -> Bool -> Bool -> String -> ParseError -> IO ()
buildLaunch :: [[Char]] -> Bool -> Bool -> [Char] -> ParseError -> IO ()
buildLaunch [[Char]]
args Bool
verb Bool
force [Char]
p ParseError
e = do
  let exec :: [Char]
exec = [Char] -> [Char]
takeBaseName [Char]
p
      confDir :: [Char]
confDir = [Char] -> [Char]
takeDirectory [Char]
p
      ext :: [Char]
ext = [Char] -> [Char]
takeExtension [Char]
p
  if [Char]
ext [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]
".hs", [Char]
".hsc", [Char]
".lhs"]
    then IO [Char]
xmobarDataDir IO [Char] -> ([Char] -> IO ()) -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Char]
dd -> [Char] -> [Char] -> [Char] -> Bool -> Bool -> IO Bool
forall (m :: * -> *).
MonadIO m =>
[Char] -> [Char] -> [Char] -> Bool -> Bool -> m Bool
recompile [Char]
confDir [Char]
dd [Char]
exec Bool
force Bool
verb IO Bool -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
         [Char] -> Bool -> [[Char]] -> Maybe [([Char], [Char])] -> IO ()
forall a.
[Char] -> Bool -> [[Char]] -> Maybe [([Char], [Char])] -> IO a
executeFile ([Char]
confDir [Char] -> [Char] -> [Char]
</> [Char]
exec) Bool
False [[Char]]
args Maybe [([Char], [Char])]
forall a. Maybe a
Nothing
    else Bool -> [Char] -> IO ()
forall (m :: * -> *). MonadIO m => Bool -> [Char] -> m ()
trace Bool
True ([Char]
"Invalid configuration file: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ParseError -> [Char]
forall a. Show a => a -> [Char]
show ParseError
e) IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
         Bool -> [Char] -> IO ()
forall (m :: * -> *). MonadIO m => Bool -> [Char] -> m ()
trace Bool
True [Char]
"\n(No compilation attempted: \
                    \only .hs, .hsc or .lhs files are compiled)"

xmobar' :: [String] -> Config -> IO ()
xmobar' :: [[Char]] -> Config -> IO ()
xmobar' [[Char]]
defs Config
cfg = do
  Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ([[Char]] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [[Char]]
defs Bool -> Bool -> Bool
|| Bool -> Bool
not (Config -> Bool
verbose Config
cfg)) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> IO ()
putStrLn ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$
    [Char]
"Fields missing from config defaulted: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
"," [[Char]]
defs
  Config -> IO ()
xmobar Config
cfg

xmobarMain :: IO ()
xmobarMain :: IO ()
xmobarMain = do
  args <- IO [[Char]]
getArgs
  (flags, rest) <- getOpts args
  cf <- case rest of
          [[Char]
c] -> Maybe [Char] -> IO (Maybe [Char])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
c)
          [] -> IO (Maybe [Char])
xmobarConfigFile
          [[Char]]
_ -> [Char] -> IO (Maybe [Char])
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO (Maybe [Char])) -> [Char] -> IO (Maybe [Char])
forall a b. (a -> b) -> a -> b
$ [Char]
"Too many arguments: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [[Char]] -> [Char]
forall a. Show a => a -> [Char]
show [[Char]]
rest
  case cf of
    Maybe [Char]
Nothing -> case [[Char]]
rest of
                ([Char]
c:[[Char]]
_) -> [Char] -> IO ()
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char]
c [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
": file not found"
                [[Char]]
_ -> Config -> [Opts] -> IO Config
doOpts Config
defaultConfig [Opts]
flags IO Config -> (Config -> IO ()) -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Config -> IO ()
xmobar
    Just [Char]
p -> do r <- Config -> [Char] -> IO (Either ParseError (Config, [[Char]]))
readConfig Config
defaultConfig [Char]
p
                 case r of
                   Left ParseError
e ->
                     [[Char]] -> Bool -> Bool -> [Char] -> ParseError -> IO ()
buildLaunch (([Char] -> Bool) -> [[Char]] -> [[Char]]
forall a. (a -> Bool) -> [a] -> [a]
filter ([Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
/= [Char]
p) [[Char]]
args) ([Opts] -> Bool
verboseFlag [Opts]
flags)
                                 ([Opts] -> Bool
recompileFlag [Opts]
flags) [Char]
p ParseError
e
                   Right (Config
c, [[Char]]
defs) -> Config -> [Opts] -> IO Config
doOpts Config
c [Opts]
flags IO Config -> (Config -> IO ()) -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [[Char]] -> Config -> IO ()
xmobar' [[Char]]
defs