{- |
   Module     : Development.Shake.Plus.Database
   License    : MIT
   Stability  : experimental

Utilities in "Development.Shake.Database" lifted to `MonadIO` and `MonadUnliftIO`.
-}
module Development.Shake.Plus.Database (
  Development.Shake.Database.ShakeDatabase
, shakeOpenDatabase
, shakeWithDatabase
, shakeOneShotDatabase
, shakeRunDatabase
, shakeLiveFilesDatabase
, shakeProfileDatabase
, shakeErrorsDatabase
, shakeRunAfter
) where

import           Development.Shake          (Action, Rules, ShakeOptions)
import           Development.Shake.Database (ShakeDatabase)
import qualified Development.Shake.Database
import           Path
import           RIO

-- | Lifted `Development.Shake.Database.shakeOpenDatabase`
shakeOpenDatabase :: MonadIO m => ShakeOptions -> Rules () -> m (IO ShakeDatabase, IO ())
shakeOpenDatabase :: ShakeOptions -> Rules () -> m (IO ShakeDatabase, IO ())
shakeOpenDatabase ShakeOptions
opts Rules ()
rules = IO (IO ShakeDatabase, IO ()) -> m (IO ShakeDatabase, IO ())
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (IO ShakeDatabase, IO ()) -> m (IO ShakeDatabase, IO ()))
-> IO (IO ShakeDatabase, IO ()) -> m (IO ShakeDatabase, IO ())
forall a b. (a -> b) -> a -> b
$ ShakeOptions -> Rules () -> IO (IO ShakeDatabase, IO ())
Development.Shake.Database.shakeOpenDatabase ShakeOptions
opts Rules ()
rules

-- | Unlifted `Development.Shake.Database.shakeWithDatabase`
shakeWithDatabase :: MonadUnliftIO m => ShakeOptions -> Rules () -> (ShakeDatabase -> m a) -> m a
shakeWithDatabase :: ShakeOptions -> Rules () -> (ShakeDatabase -> m a) -> m a
shakeWithDatabase ShakeOptions
opts Rules ()
rules ShakeDatabase -> m a
inner = ((forall a. m a -> IO a) -> IO a) -> m a
forall (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. m a -> IO a) -> IO b) -> m b
withRunInIO (((forall a. m a -> IO a) -> IO a) -> m a)
-> ((forall a. m a -> IO a) -> IO a) -> m a
forall a b. (a -> b) -> a -> b
$ \forall a. m a -> IO a
run -> ShakeOptions -> Rules () -> (ShakeDatabase -> IO a) -> IO a
forall a.
ShakeOptions -> Rules () -> (ShakeDatabase -> IO a) -> IO a
Development.Shake.Database.shakeWithDatabase ShakeOptions
opts Rules ()
rules ((ShakeDatabase -> IO a) -> IO a)
-> (ShakeDatabase -> IO a) -> IO a
forall a b. (a -> b) -> a -> b
$ m a -> IO a
forall a. m a -> IO a
run (m a -> IO a) -> (ShakeDatabase -> m a) -> ShakeDatabase -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShakeDatabase -> m a
inner

-- | Lifted `Development.Shake.Database.shakeOneShotDatabase`
shakeOneShotDatabase :: MonadIO m => ShakeDatabase -> m ()
shakeOneShotDatabase :: ShakeDatabase -> m ()
shakeOneShotDatabase = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ())
-> (ShakeDatabase -> IO ()) -> ShakeDatabase -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShakeDatabase -> IO ()
Development.Shake.Database.shakeOneShotDatabase

-- | Lifted `Development.Shake.Database.shakeRunDatabase`
shakeRunDatabase :: MonadIO m => ShakeDatabase -> [Action a] -> m ([a], [IO ()])
shakeRunDatabase :: ShakeDatabase -> [Action a] -> m ([a], [IO ()])
shakeRunDatabase ShakeDatabase
db [Action a]
actions = IO ([a], [IO ()]) -> m ([a], [IO ()])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ([a], [IO ()]) -> m ([a], [IO ()]))
-> IO ([a], [IO ()]) -> m ([a], [IO ()])
forall a b. (a -> b) -> a -> b
$ ShakeDatabase -> [Action a] -> IO ([a], [IO ()])
forall (m :: * -> *) a.
MonadIO m =>
ShakeDatabase -> [Action a] -> m ([a], [IO ()])
shakeRunDatabase ShakeDatabase
db [Action a]
actions

-- | Lifted `Development.Shake.Database.shakeLiveFilesDatabase`
shakeLiveFilesDatabase :: MonadIO m => ShakeDatabase -> m [FilePath]
shakeLiveFilesDatabase :: ShakeDatabase -> m [FilePath]
shakeLiveFilesDatabase = IO [FilePath] -> m [FilePath]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [FilePath] -> m [FilePath])
-> (ShakeDatabase -> IO [FilePath])
-> ShakeDatabase
-> m [FilePath]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShakeDatabase -> IO [FilePath]
Development.Shake.Database.shakeLiveFilesDatabase

-- | Lifted `Development.Shake.Database.shakeProfileDatabase` with well-typed path.
shakeProfileDatabase :: MonadIO m => ShakeDatabase -> Path a File -> m ()
shakeProfileDatabase :: ShakeDatabase -> Path a File -> m ()
shakeProfileDatabase ShakeDatabase
db Path a File
file = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ShakeDatabase -> FilePath -> IO ()
Development.Shake.Database.shakeProfileDatabase ShakeDatabase
db (Path a File -> FilePath
forall b t. Path b t -> FilePath
toFilePath Path a File
file)

-- | Lifted `Development.Shake.Database.shakeErrorsDatabase`
shakeErrorsDatabase :: MonadIO m => ShakeDatabase -> m [(String, SomeException)]
shakeErrorsDatabase :: ShakeDatabase -> m [(FilePath, SomeException)]
shakeErrorsDatabase = IO [(FilePath, SomeException)] -> m [(FilePath, SomeException)]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [(FilePath, SomeException)] -> m [(FilePath, SomeException)])
-> (ShakeDatabase -> IO [(FilePath, SomeException)])
-> ShakeDatabase
-> m [(FilePath, SomeException)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShakeDatabase -> IO [(FilePath, SomeException)]
Development.Shake.Database.shakeErrorsDatabase

-- | Unlifted `Development.Shake.Database.shakeRunAfter`
shakeRunAfter :: MonadUnliftIO m => ShakeOptions -> [m ()] -> m ()
shakeRunAfter :: ShakeOptions -> [m ()] -> m ()
shakeRunAfter ShakeOptions
opts [m ()]
inners = ((forall a. m a -> IO a) -> IO ()) -> m ()
forall (m :: * -> *) b.
MonadUnliftIO m =>
((forall a. m a -> IO a) -> IO b) -> m b
withRunInIO (((forall a. m a -> IO a) -> IO ()) -> m ())
-> ((forall a. m a -> IO a) -> IO ()) -> m ()
forall a b. (a -> b) -> a -> b
$ \forall a. m a -> IO a
run -> ShakeOptions -> [IO ()] -> IO ()
Development.Shake.Database.shakeRunAfter ShakeOptions
opts ([IO ()] -> IO ()) -> [IO ()] -> IO ()
forall a b. (a -> b) -> a -> b
$ (m () -> IO ()) -> [m ()] -> [IO ()]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap m () -> IO ()
forall a. m a -> IO a
run [m ()]
inners