{-|
Module      : Slick.Shake
Description : DEPRECATED -- Advanced caching tools for using slick with shake
Copyright   : (c) Chris Penner, 2019
License     : BSD3
-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE ScopedTypeVariables        #-}
{-# LANGUAGE TypeFamilies               #-}

module Slick.Caching {-# DEPRECATED "No longer necessary with slick >= 0.3.0.0" #-}
  ( simpleJsonCache
  , simpleJsonCache'
  , jsonCache
  , jsonCache'
  )
where

import Data.Aeson                 as A
import Data.ByteString.Lazy
import Development.Shake          hiding (Resource)
import Development.Shake.Classes
import GHC.Generics               (Generic)

--------------------------------------------------------------------------------

newtype CacheQuery q =
  CacheQuery q
  deriving (Int -> CacheQuery q -> ShowS
[CacheQuery q] -> ShowS
CacheQuery q -> String
(Int -> CacheQuery q -> ShowS)
-> (CacheQuery q -> String)
-> ([CacheQuery q] -> ShowS)
-> Show (CacheQuery q)
forall q. Show q => Int -> CacheQuery q -> ShowS
forall q. Show q => [CacheQuery q] -> ShowS
forall q. Show q => CacheQuery q -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall q. Show q => Int -> CacheQuery q -> ShowS
showsPrec :: Int -> CacheQuery q -> ShowS
$cshow :: forall q. Show q => CacheQuery q -> String
show :: CacheQuery q -> String
$cshowList :: forall q. Show q => [CacheQuery q] -> ShowS
showList :: [CacheQuery q] -> ShowS
Show, CacheQuery q -> CacheQuery q -> Bool
(CacheQuery q -> CacheQuery q -> Bool)
-> (CacheQuery q -> CacheQuery q -> Bool) -> Eq (CacheQuery q)
forall q. Eq q => CacheQuery q -> CacheQuery q -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall q. Eq q => CacheQuery q -> CacheQuery q -> Bool
== :: CacheQuery q -> CacheQuery q -> Bool
$c/= :: forall q. Eq q => CacheQuery q -> CacheQuery q -> Bool
/= :: CacheQuery q -> CacheQuery q -> Bool
Eq, (forall x. CacheQuery q -> Rep (CacheQuery q) x)
-> (forall x. Rep (CacheQuery q) x -> CacheQuery q)
-> Generic (CacheQuery q)
forall x. Rep (CacheQuery q) x -> CacheQuery q
forall x. CacheQuery q -> Rep (CacheQuery q) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall q x. Rep (CacheQuery q) x -> CacheQuery q
forall q x. CacheQuery q -> Rep (CacheQuery q) x
$cfrom :: forall q x. CacheQuery q -> Rep (CacheQuery q) x
from :: forall x. CacheQuery q -> Rep (CacheQuery q) x
$cto :: forall q x. Rep (CacheQuery q) x -> CacheQuery q
to :: forall x. Rep (CacheQuery q) x -> CacheQuery q
Generic, Get (CacheQuery q)
[CacheQuery q] -> Put
CacheQuery q -> Put
(CacheQuery q -> Put)
-> Get (CacheQuery q)
-> ([CacheQuery q] -> Put)
-> Binary (CacheQuery q)
forall q. Binary q => Get (CacheQuery q)
forall q. Binary q => [CacheQuery q] -> Put
forall q. Binary q => CacheQuery q -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
$cput :: forall q. Binary q => CacheQuery q -> Put
put :: CacheQuery q -> Put
$cget :: forall q. Binary q => Get (CacheQuery q)
get :: Get (CacheQuery q)
$cputList :: forall q. Binary q => [CacheQuery q] -> Put
putList :: [CacheQuery q] -> Put
Binary, CacheQuery q -> ()
(CacheQuery q -> ()) -> NFData (CacheQuery q)
forall q. NFData q => CacheQuery q -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall q. NFData q => CacheQuery q -> ()
rnf :: CacheQuery q -> ()
NFData, Eq (CacheQuery q)
Eq (CacheQuery q) =>
(Int -> CacheQuery q -> Int)
-> (CacheQuery q -> Int) -> Hashable (CacheQuery q)
Int -> CacheQuery q -> Int
CacheQuery q -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall q. Hashable q => Eq (CacheQuery q)
forall q. Hashable q => Int -> CacheQuery q -> Int
forall q. Hashable q => CacheQuery q -> Int
$chashWithSalt :: forall q. Hashable q => Int -> CacheQuery q -> Int
hashWithSalt :: Int -> CacheQuery q -> Int
$chash :: forall q. Hashable q => CacheQuery q -> Int
hash :: CacheQuery q -> Int
Hashable)

type instance RuleResult (CacheQuery q) = ByteString

-- | Note that you probably don't need this if you're using the recommended @Development.Shake.Forward@ module. It can do a lot of caching for you, otherwise look at 'Development.Shake.Forward.cacheAction'.
--
-- A wrapper around 'addOracleCache' which given a @q@ which is a 'ShakeValue'
-- allows caching and retrieving 'Value's within Shake. See documentation on
-- 'addOracleCache' or see Slick examples for more info.
--
-- > -- We need to define a unique datatype as our cache key
-- > newtype PostFilePath =
-- >   PostFilePath String
-- > -- We can derive the classes we need (using GeneralizedNewtypeDeriving)
-- > -- so long as the underlying type implements them
-- >   deriving (Show, Eq, Hashable, Binary, NFData)
-- > -- now in our shake rules we can create a cache by providing a loader action
-- >
-- > do
-- > postCache <- jsonCache $ \(PostFilePath path) ->
-- >   readFile' path >>= markdownToHTML . Text.pack
-- > -- Now use postCache inside an Action to load your post with caching!
jsonCache :: ShakeValue q => (q -> Action Value) -> Rules (q -> Action Value)
jsonCache :: forall q.
ShakeValue q =>
(q -> Action Value) -> Rules (q -> Action Value)
jsonCache = (q -> Action Value) -> Rules (q -> Action Value)
forall a q.
(ToJSON a, FromJSON a, ShakeValue q) =>
(q -> Action a) -> Rules (q -> Action a)
jsonCache'

-- | Like 'jsonCache' but allows caching/retrieving any JSON serializable
-- objects.
jsonCache'
  :: forall a q
   . (ToJSON a, FromJSON a, ShakeValue q)
  => (q -> Action a)
  -> Rules (q -> Action a)
jsonCache' :: forall a q.
(ToJSON a, FromJSON a, ShakeValue q) =>
(q -> Action a) -> Rules (q -> Action a)
jsonCache' q -> Action a
loader = FromJSON a => (CacheQuery q -> Action ByteString) -> q -> Action a
(CacheQuery q -> Action ByteString) -> q -> Action a
unpackJSON
  ((CacheQuery q -> Action ByteString) -> q -> Action a)
-> Rules (CacheQuery q -> Action ByteString)
-> Rules (q -> Action a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CacheQuery q -> Action ByteString)
-> Rules (CacheQuery q -> Action ByteString)
forall q a.
(RuleResult q ~ a, ShakeValue q, ShakeValue a, Partial) =>
(q -> Action a) -> Rules (q -> Action a)
addOracleCache (\(CacheQuery q
q) -> a -> ByteString
forall a. ToJSON a => a -> ByteString
A.encode (a -> ByteString) -> Action a -> Action ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> q -> Action a
loader q
q)
 where
  unpackJSON
    :: FromJSON a => (CacheQuery q -> Action ByteString) -> q -> Action a
  unpackJSON :: FromJSON a => (CacheQuery q -> Action ByteString) -> q -> Action a
unpackJSON CacheQuery q -> Action ByteString
runCacheQuery = \q
q -> do
    ByteString
bytes <- CacheQuery q -> Action ByteString
runCacheQuery (CacheQuery q -> Action ByteString)
-> CacheQuery q -> Action ByteString
forall a b. (a -> b) -> a -> b
$ q -> CacheQuery q
forall q. q -> CacheQuery q
CacheQuery q
q
    case ByteString -> Either String a
forall a. FromJSON a => ByteString -> Either String a
A.eitherDecode ByteString
bytes of
      Left  String
err -> String -> Action a
forall a. String -> Action a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
err
      Right a
res -> a -> Action a
forall a. a -> Action a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
res

-- | Note that you probably don't need this if you're using the recommended @Development.Shake.Forward@ module. It can do a lot of caching for you, otherwise look at 'Development.Shake.Forward.cacheAction'.
--
-- A wrapper around 'jsonCache' which simplifies caching of values which do NOT
-- depend on an input parameter. Unfortunately Shake still requires that the
-- key type implement several typeclasses, however this is easily accomplished
-- using @GeneralizedNewtypeDeriving@ and a wrapper around @()@.
-- example usage:
--
-- > {-# LANGUAGE GeneralizedNewtypeDeriving #-}
-- > module Main where
-- > newtype ProjectList = ProjectList ()
-- >   deriving (Show, Eq, Hashable, Binary, NFData)
--  Within your shake Rules:
--
-- > projectCache = simpleJsonCache (ProjectList ()) $ do
-- >   -- load your project list here; returning it as a Value
simpleJsonCache :: ShakeValue q => q -> Action Value -> Rules (Action Value)
simpleJsonCache :: forall q. ShakeValue q => q -> Action Value -> Rules (Action Value)
simpleJsonCache = q -> Action Value -> Rules (Action Value)
forall q a.
(ToJSON a, FromJSON a, ShakeValue q) =>
q -> Action a -> Rules (Action a)
simpleJsonCache'

-- | Like 'simpleJsonCache' but allows caching any JSON serializable object.
simpleJsonCache'
  :: forall q a
   . (ToJSON a, FromJSON a, ShakeValue q)
  => q
  -> Action a
  -> Rules (Action a)
simpleJsonCache' :: forall q a.
(ToJSON a, FromJSON a, ShakeValue q) =>
q -> Action a -> Rules (Action a)
simpleJsonCache' q
q Action a
loader = do
  q -> Action a
cacheGetter <- (q -> Action a) -> Rules (q -> Action a)
forall a q.
(ToJSON a, FromJSON a, ShakeValue q) =>
(q -> Action a) -> Rules (q -> Action a)
jsonCache' (Action a -> q -> Action a
forall a b. a -> b -> a
const Action a
loader)
  Action a -> Rules (Action a)
forall a. a -> Rules a
forall (m :: * -> *) a. Monad m => a -> m a
return (Action a -> Rules (Action a)) -> Action a -> Rules (Action a)
forall a b. (a -> b) -> a -> b
$ q -> Action a
cacheGetter q
q