{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}

-- | Internal module
module Faker.Internal
  ( Unresolved(..)
  , Regex(..)
  , RegexFakeValue(..)
  , AesonKey(..)
  , rvec
  , insertToCache
  , presentInCache
  , resolver
  , refinedString
  , refinedText
  , cachedRandomVec
  , cachedRandomUnresolvedVec
  , cachedRandomUnresolvedVecWithoutVector
  , cachedRegex
  , resolveUnresolved
  , modifyRandomGen
  , resolveFields
  , genericResolver
  , genericResolver'
  , getLocaleKey
  ) where

import Config
import Control.Monad.Catch
import Control.Monad.IO.Class
import Data.Char (toUpper)
import qualified Data.HashMap.Strict as HM
import Data.Monoid ((<>))
import qualified Data.Text as T
import Data.Text (Text, strip)
import qualified Data.Vector as V
import Data.Vector (Vector, (!))
import Data.Word (Word64)
import Faker
import Faker.Internal.Types (CacheFieldKey(..), AesonKey(..)
                            , aesonKeyFromText
                            , aesonKeyToText)
import System.Random (StdGen, mkStdGen, randomR, split)
import Text.StringRandom (stringRandom)
import Fakedata.Parser
import Data.Attoparsec.Text as P
import Control.Monad (when)
#if MIN_VERSION_aeson(2,0,0)
import qualified Data.Aeson.Key as K
#endif

newtype Unresolved a = Unresolved
  { Unresolved a -> a
unresolvedField :: a
  } deriving (a -> Unresolved b -> Unresolved a
(a -> b) -> Unresolved a -> Unresolved b
(forall a b. (a -> b) -> Unresolved a -> Unresolved b)
-> (forall a b. a -> Unresolved b -> Unresolved a)
-> Functor Unresolved
forall a b. a -> Unresolved b -> Unresolved a
forall a b. (a -> b) -> Unresolved a -> Unresolved b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Unresolved b -> Unresolved a
$c<$ :: forall a b. a -> Unresolved b -> Unresolved a
fmap :: (a -> b) -> Unresolved a -> Unresolved b
$cfmap :: forall a b. (a -> b) -> Unresolved a -> Unresolved b
Functor)

newtype Regex = Regex { Regex -> Text
unRegex :: Text } deriving (Regex -> Regex -> Bool
(Regex -> Regex -> Bool) -> (Regex -> Regex -> Bool) -> Eq Regex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Regex -> Regex -> Bool
$c/= :: Regex -> Regex -> Bool
== :: Regex -> Regex -> Bool
$c== :: Regex -> Regex -> Bool
Eq, Eq Regex
Eq Regex
-> (Regex -> Regex -> Ordering)
-> (Regex -> Regex -> Bool)
-> (Regex -> Regex -> Bool)
-> (Regex -> Regex -> Bool)
-> (Regex -> Regex -> Bool)
-> (Regex -> Regex -> Regex)
-> (Regex -> Regex -> Regex)
-> Ord Regex
Regex -> Regex -> Bool
Regex -> Regex -> Ordering
Regex -> Regex -> Regex
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Regex -> Regex -> Regex
$cmin :: Regex -> Regex -> Regex
max :: Regex -> Regex -> Regex
$cmax :: Regex -> Regex -> Regex
>= :: Regex -> Regex -> Bool
$c>= :: Regex -> Regex -> Bool
> :: Regex -> Regex -> Bool
$c> :: Regex -> Regex -> Bool
<= :: Regex -> Regex -> Bool
$c<= :: Regex -> Regex -> Bool
< :: Regex -> Regex -> Bool
$c< :: Regex -> Regex -> Bool
compare :: Regex -> Regex -> Ordering
$ccompare :: Regex -> Regex -> Ordering
$cp1Ord :: Eq Regex
Ord, Int -> Regex -> ShowS
[Regex] -> ShowS
Regex -> String
(Int -> Regex -> ShowS)
-> (Regex -> String) -> ([Regex] -> ShowS) -> Show Regex
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Regex] -> ShowS
$cshowList :: [Regex] -> ShowS
show :: Regex -> String
$cshow :: Regex -> String
showsPrec :: Int -> Regex -> ShowS
$cshowsPrec :: Int -> Regex -> ShowS
Show)

newtype RegexFakeValue = RegexFakeValue { RegexFakeValue -> Text
unRegexFakeValue :: Text } deriving (RegexFakeValue -> RegexFakeValue -> Bool
(RegexFakeValue -> RegexFakeValue -> Bool)
-> (RegexFakeValue -> RegexFakeValue -> Bool) -> Eq RegexFakeValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegexFakeValue -> RegexFakeValue -> Bool
$c/= :: RegexFakeValue -> RegexFakeValue -> Bool
== :: RegexFakeValue -> RegexFakeValue -> Bool
$c== :: RegexFakeValue -> RegexFakeValue -> Bool
Eq, Eq RegexFakeValue
Eq RegexFakeValue
-> (RegexFakeValue -> RegexFakeValue -> Ordering)
-> (RegexFakeValue -> RegexFakeValue -> Bool)
-> (RegexFakeValue -> RegexFakeValue -> Bool)
-> (RegexFakeValue -> RegexFakeValue -> Bool)
-> (RegexFakeValue -> RegexFakeValue -> Bool)
-> (RegexFakeValue -> RegexFakeValue -> RegexFakeValue)
-> (RegexFakeValue -> RegexFakeValue -> RegexFakeValue)
-> Ord RegexFakeValue
RegexFakeValue -> RegexFakeValue -> Bool
RegexFakeValue -> RegexFakeValue -> Ordering
RegexFakeValue -> RegexFakeValue -> RegexFakeValue
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: RegexFakeValue -> RegexFakeValue -> RegexFakeValue
$cmin :: RegexFakeValue -> RegexFakeValue -> RegexFakeValue
max :: RegexFakeValue -> RegexFakeValue -> RegexFakeValue
$cmax :: RegexFakeValue -> RegexFakeValue -> RegexFakeValue
>= :: RegexFakeValue -> RegexFakeValue -> Bool
$c>= :: RegexFakeValue -> RegexFakeValue -> Bool
> :: RegexFakeValue -> RegexFakeValue -> Bool
$c> :: RegexFakeValue -> RegexFakeValue -> Bool
<= :: RegexFakeValue -> RegexFakeValue -> Bool
$c<= :: RegexFakeValue -> RegexFakeValue -> Bool
< :: RegexFakeValue -> RegexFakeValue -> Bool
$c< :: RegexFakeValue -> RegexFakeValue -> Bool
compare :: RegexFakeValue -> RegexFakeValue -> Ordering
$ccompare :: RegexFakeValue -> RegexFakeValue -> Ordering
$cp1Ord :: Eq RegexFakeValue
Ord, Int -> RegexFakeValue -> ShowS
[RegexFakeValue] -> ShowS
RegexFakeValue -> String
(Int -> RegexFakeValue -> ShowS)
-> (RegexFakeValue -> String)
-> ([RegexFakeValue] -> ShowS)
-> Show RegexFakeValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegexFakeValue] -> ShowS
$cshowList :: [RegexFakeValue] -> ShowS
show :: RegexFakeValue -> String
$cshow :: RegexFakeValue -> String
showsPrec :: Int -> RegexFakeValue -> ShowS
$cshowsPrec :: Int -> RegexFakeValue -> ShowS
Show)

instance Applicative Unresolved where
  pure :: a -> Unresolved a
pure = a -> Unresolved a
forall a. a -> Unresolved a
Unresolved
  Unresolved a -> b
f1 <*> :: Unresolved (a -> b) -> Unresolved a -> Unresolved b
<*> Unresolved a
f2 = b -> Unresolved b
forall (f :: * -> *) a. Applicative f => a -> f a
pure (b -> Unresolved b) -> b -> Unresolved b
forall a b. (a -> b) -> a -> b
$ a -> b
f1 a
f2

instance Monad Unresolved where
  return :: a -> Unresolved a
return = a -> Unresolved a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
  (Unresolved a
f) >>= :: Unresolved a -> (a -> Unresolved b) -> Unresolved b
>>= a -> Unresolved b
f1 = a -> Unresolved b
f1 a
f

-- | Get the Locale settings for your fake data source as a YAML  key.
getLocaleKey :: FakerSettings -> AesonKey
#if MIN_VERSION_aeson(2,0,0)
getLocaleKey :: FakerSettings -> AesonKey
getLocaleKey FakerSettings
settings = Text -> AesonKey
K.fromText (FakerSettings -> Text
getLocale FakerSettings
settings)
#else
getLocaleKey settings = getLocale settings
#endif

-- These are the functions which needs to be remodified
-- rvec, randomVec, randomUnresolvedvec, randomUnresolvedVecwithoutvector, unresolvedResolver, unresolfvedResolverWithoutVector
rvec :: (MonadThrow m, MonadIO m) => FakerSettings -> Vector a -> m a
rvec :: FakerSettings -> Vector a -> m a
rvec FakerSettings
settings Vector a
vec =
  let itemsLen :: Int
itemsLen = Vector a -> Int
forall a. Vector a -> Int
V.length Vector a
vec
      (Int
index, StdGen
_) = (Int, Int) -> StdGen -> (Int, StdGen)
forall a g. (Random a, RandomGen g) => (a, a) -> g -> (a, g)
randomR (Int
0, Int
itemsLen Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (FakerSettings -> StdGen
getRandomGen FakerSettings
settings)
   in if Int
itemsLen Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
        then FakerException -> m a
forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM (FakerException -> m a) -> FakerException -> m a
forall a b. (a -> b) -> a -> b
$ FakerSettings -> FakerException
NoDataFound FakerSettings
settings
        else a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> m a) -> a -> m a
forall a b. (a -> b) -> a -> b
$ Vector a
vec Vector a -> Int -> a
forall a. Vector a -> Int -> a
! Int
index

cachedRandomVec ::
     (MonadThrow m, MonadIO m)
  => Text
  -> AesonKey
  -> (FakerSettings -> m (Vector Text))
  -> FakerSettings
  -> m Text
cachedRandomVec :: Text
-> AesonKey
-> (FakerSettings -> m (Vector Text))
-> FakerSettings
-> m Text
cachedRandomVec Text
sdata AesonKey
field FakerSettings -> m (Vector Text)
provider FakerSettings
settings = do
  Maybe (Vector Text)
val <- IO (Maybe (Vector Text)) -> m (Maybe (Vector Text))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Vector Text)) -> m (Maybe (Vector Text)))
-> IO (Maybe (Vector Text)) -> m (Maybe (Vector Text))
forall a b. (a -> b) -> a -> b
$ Text -> AesonKey -> FakerSettings -> IO (Maybe (Vector Text))
presentInCache Text
sdata AesonKey
field FakerSettings
settings
  case Maybe (Vector Text)
val of
    Maybe (Vector Text)
Nothing -> do
      Vector Text
dat <- FakerSettings -> m (Vector Text)
provider FakerSettings
settings
      IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Text -> AesonKey -> FakerSettings -> Vector Text -> IO ()
insertToCache Text
sdata AesonKey
field FakerSettings
settings Vector Text
dat
      FakerSettings -> (FakerSettings -> m (Vector Text)) -> m Text
forall (m :: * -> *) a.
(MonadThrow m, MonadIO m) =>
FakerSettings -> (FakerSettings -> m (Vector a)) -> m a
randomVec FakerSettings
settings (\FakerSettings
_ -> Vector Text -> m (Vector Text)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector Text
dat)
    Just Vector Text
vec -> FakerSettings -> (FakerSettings -> m (Vector Text)) -> m Text
forall (m :: * -> *) a.
(MonadThrow m, MonadIO m) =>
FakerSettings -> (FakerSettings -> m (Vector a)) -> m a
randomVec FakerSettings
settings (\FakerSettings
_ -> Vector Text -> m (Vector Text)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector Text
vec)

randomVec ::
     (MonadThrow m, MonadIO m)
  => FakerSettings
  -> (FakerSettings -> m (Vector a))
  -> m a
randomVec :: FakerSettings -> (FakerSettings -> m (Vector a)) -> m a
randomVec FakerSettings
settings FakerSettings -> m (Vector a)
provider = do
  Vector a
items <- FakerSettings -> m (Vector a)
provider FakerSettings
settings
  let itemsLen :: Int
itemsLen = Vector a -> Int
forall a. Vector a -> Int
V.length Vector a
items
      stdGen :: StdGen
stdGen = FakerSettings -> StdGen
getRandomGen FakerSettings
settings
      (Int
index, StdGen
_) = (Int, Int) -> StdGen -> (Int, StdGen)
forall a g. (Random a, RandomGen g) => (a, a) -> g -> (a, g)
randomR (Int
0, Int
itemsLen Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) StdGen
stdGen
  if Int
itemsLen Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
    then FakerException -> m a
forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM (FakerException -> m a) -> FakerException -> m a
forall a b. (a -> b) -> a -> b
$ FakerSettings -> FakerException
NoDataFound FakerSettings
settings
    else a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> m a) -> a -> m a
forall a b. (a -> b) -> a -> b
$ Vector a
items Vector a -> Int -> a
forall a. Vector a -> Int -> a
! Int
index

cachedRandomUnresolvedVec ::
     (MonadThrow m, MonadIO m)
  => Text
  -> AesonKey
  -> (FakerSettings -> m (Unresolved (Vector Text)))
  -> (FakerSettings -> AesonKey -> m Text)
  -> FakerSettings
  -> m Text
cachedRandomUnresolvedVec :: Text
-> AesonKey
-> (FakerSettings -> m (Unresolved (Vector Text)))
-> (FakerSettings -> AesonKey -> m Text)
-> FakerSettings
-> m Text
cachedRandomUnresolvedVec Text
sdata AesonKey
field FakerSettings -> m (Unresolved (Vector Text))
provider FakerSettings -> AesonKey -> m Text
resolverFn FakerSettings
settings = do
  Maybe (Vector Text)
val <- IO (Maybe (Vector Text)) -> m (Maybe (Vector Text))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Vector Text)) -> m (Maybe (Vector Text)))
-> IO (Maybe (Vector Text)) -> m (Maybe (Vector Text))
forall a b. (a -> b) -> a -> b
$ Text -> AesonKey -> FakerSettings -> IO (Maybe (Vector Text))
presentInCache Text
sdata AesonKey
field FakerSettings
settings
  case Maybe (Vector Text)
val of
    Maybe (Vector Text)
Nothing -> do
      Unresolved (Vector Text)
dat <- FakerSettings -> m (Unresolved (Vector Text))
provider FakerSettings
settings
      IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Text -> AesonKey -> FakerSettings -> Vector Text -> IO ()
insertToCache Text
sdata AesonKey
field FakerSettings
settings (Unresolved (Vector Text) -> Vector Text
forall a. Unresolved a -> a
unresolvedField Unresolved (Vector Text)
dat)
      FakerSettings
-> Unresolved (Vector Text)
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
forall (m :: * -> *).
(MonadThrow m, MonadIO m) =>
FakerSettings
-> Unresolved (Vector Text)
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
resolveUnresolved FakerSettings
settings Unresolved (Vector Text)
dat FakerSettings -> AesonKey -> m Text
resolverFn
    Just Vector Text
vec -> do
      let unres :: Unresolved (Vector Text)
unres = Unresolved :: forall a. a -> Unresolved a
Unresolved {unresolvedField :: Vector Text
unresolvedField = Vector Text
vec}
      FakerSettings
-> (FakerSettings -> m (Unresolved (Vector Text)))
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
forall (m :: * -> *).
(MonadThrow m, MonadIO m) =>
FakerSettings
-> (FakerSettings -> m (Unresolved (Vector Text)))
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
randomUnresolvedVec FakerSettings
settings (\FakerSettings
_ -> Unresolved (Vector Text) -> m (Unresolved (Vector Text))
forall (f :: * -> *) a. Applicative f => a -> f a
pure Unresolved (Vector Text)
unres) FakerSettings -> AesonKey -> m Text
resolverFn

randomUnresolvedVec ::
     (MonadThrow m, MonadIO m)
  => FakerSettings
  -> (FakerSettings -> m (Unresolved (Vector Text)))
  -> (FakerSettings -> AesonKey -> m Text)
  -> m Text
randomUnresolvedVec :: FakerSettings
-> (FakerSettings -> m (Unresolved (Vector Text)))
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
randomUnresolvedVec FakerSettings
settings FakerSettings -> m (Unresolved (Vector Text))
provider FakerSettings -> AesonKey -> m Text
resolverFn = do
  Unresolved (Vector Text)
items <- FakerSettings -> m (Unresolved (Vector Text))
provider FakerSettings
settings
  FakerSettings
-> Unresolved (Vector Text)
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
forall (m :: * -> *).
(MonadThrow m, MonadIO m) =>
FakerSettings
-> Unresolved (Vector Text)
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
resolveUnresolved FakerSettings
settings Unresolved (Vector Text)
items FakerSettings -> AesonKey -> m Text
resolverFn

cachedRandomUnresolvedVecWithoutVector ::
     (MonadThrow m, MonadIO m)
  => Text
  -> AesonKey
  -> (FakerSettings -> m (Unresolved Text))
  -> (FakerSettings -> AesonKey -> m Text)
  -> FakerSettings
  -> m Text
cachedRandomUnresolvedVecWithoutVector :: Text
-> AesonKey
-> (FakerSettings -> m (Unresolved Text))
-> (FakerSettings -> AesonKey -> m Text)
-> FakerSettings
-> m Text
cachedRandomUnresolvedVecWithoutVector Text
sdata AesonKey
field FakerSettings -> m (Unresolved Text)
provider FakerSettings -> AesonKey -> m Text
resolverFn FakerSettings
settings = do
  Maybe (Vector Text)
val <- IO (Maybe (Vector Text)) -> m (Maybe (Vector Text))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Vector Text)) -> m (Maybe (Vector Text)))
-> IO (Maybe (Vector Text)) -> m (Maybe (Vector Text))
forall a b. (a -> b) -> a -> b
$ Text -> AesonKey -> FakerSettings -> IO (Maybe (Vector Text))
presentInCache Text
sdata AesonKey
field FakerSettings
settings
  case Maybe (Vector Text)
val of
    Maybe (Vector Text)
Nothing -> do
      Unresolved Text
dat <- FakerSettings -> m (Unresolved Text)
provider FakerSettings
settings
      IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Text -> AesonKey -> FakerSettings -> Vector Text -> IO ()
insertToCache Text
sdata AesonKey
field FakerSettings
settings (Text -> Vector Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> Vector Text) -> Text -> Vector Text
forall a b. (a -> b) -> a -> b
$ Unresolved Text -> Text
forall a. Unresolved a -> a
unresolvedField Unresolved Text
dat)
      FakerSettings
-> Unresolved (Vector Text)
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
forall (m :: * -> *).
(MonadThrow m, MonadIO m) =>
FakerSettings
-> Unresolved (Vector Text)
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
resolveUnresolved FakerSettings
settings (Vector (Unresolved Text) -> Unresolved (Vector Text)
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
sequenceA (Vector (Unresolved Text) -> Unresolved (Vector Text))
-> Vector (Unresolved Text) -> Unresolved (Vector Text)
forall a b. (a -> b) -> a -> b
$ Unresolved Text -> Vector (Unresolved Text)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Unresolved Text
dat) FakerSettings -> AesonKey -> m Text
resolverFn
    Just Vector Text
vec -> do
      let unres :: Unresolved (Vector Text)
unres = Unresolved :: forall a. a -> Unresolved a
Unresolved {unresolvedField :: Vector Text
unresolvedField = Vector Text
vec}
      FakerSettings
-> (FakerSettings -> m (Unresolved (Vector Text)))
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
forall (m :: * -> *).
(MonadThrow m, MonadIO m) =>
FakerSettings
-> (FakerSettings -> m (Unresolved (Vector Text)))
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
randomUnresolvedVec FakerSettings
settings (\FakerSettings
_ -> Unresolved (Vector Text) -> m (Unresolved (Vector Text))
forall (f :: * -> *) a. Applicative f => a -> f a
pure Unresolved (Vector Text)
unres) FakerSettings -> AesonKey -> m Text
resolverFn

randomUnresolvedVecWithoutVector ::
     (MonadThrow m, MonadIO m)
  => FakerSettings
  -> (FakerSettings -> m (Unresolved Text))
  -> (FakerSettings -> AesonKey -> m Text)
  -> m Text
randomUnresolvedVecWithoutVector :: FakerSettings
-> (FakerSettings -> m (Unresolved Text))
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
randomUnresolvedVecWithoutVector FakerSettings
settings FakerSettings -> m (Unresolved Text)
provider FakerSettings -> AesonKey -> m Text
resolverFn = do
  Unresolved Text
items <- FakerSettings -> m (Unresolved Text)
provider FakerSettings
settings
  FakerSettings
-> Unresolved (Vector Text)
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
forall (m :: * -> *).
(MonadThrow m, MonadIO m) =>
FakerSettings
-> Unresolved (Vector Text)
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
resolveUnresolved FakerSettings
settings (Vector (Unresolved Text) -> Unresolved (Vector Text)
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
sequenceA (Vector (Unresolved Text) -> Unresolved (Vector Text))
-> Vector (Unresolved Text) -> Unresolved (Vector Text)
forall a b. (a -> b) -> a -> b
$ Unresolved Text -> Vector (Unresolved Text)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Unresolved Text
items) FakerSettings -> AesonKey -> m Text
resolverFn

resolveUnresolved ::
     (MonadThrow m, MonadIO m)
  => FakerSettings
  -> Unresolved (Vector Text)
  -> (FakerSettings -> AesonKey -> m Text)
  -> m Text
resolveUnresolved :: FakerSettings
-> Unresolved (Vector Text)
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
resolveUnresolved FakerSettings
settings (Unresolved Vector Text
unres) FakerSettings -> AesonKey -> m Text
resolverFn = do
  let unresLen :: Int
unresLen = Vector Text -> Int
forall a. Vector a -> Int
V.length Vector Text
unres
      stdGen :: StdGen
stdGen = FakerSettings -> StdGen
getRandomGen FakerSettings
settings
      (Int
index, StdGen
_) = (Int, Int) -> StdGen -> (Int, StdGen)
forall a g. (Random a, RandomGen g) => (a, a) -> g -> (a, g)
randomR (Int
0, Int
unresLen Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) StdGen
stdGen
      randomItem :: Text
randomItem = Vector Text
unres Vector Text -> Int -> Text
forall a. Vector a -> Int -> a
! Int
index
  Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
unresLen Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ FakerException -> m ()
forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM (FakerException -> m ()) -> FakerException -> m ()
forall a b. (a -> b) -> a -> b
$ FakerSettings -> FakerException
NoDataFound FakerSettings
settings
  case Parser [FakeIRValue] -> Text -> Either String [FakeIRValue]
forall a. Parser a -> Text -> Either String a
P.parseOnly Parser [FakeIRValue]
parseFakedata Text
randomItem of
       Left String
err -> FakerException -> m Text
forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM (FakerException -> m Text) -> FakerException -> m Text
forall a b. (a -> b) -> a -> b
$ String -> FakerException
ParseError String
err
       Right [FakeIRValue]
vals -> FakerSettings
-> (FakerSettings -> AesonKey -> m Text) -> [FakeIRValue] -> m Text
forall (m :: * -> *).
MonadIO m =>
FakerSettings
-> (FakerSettings -> AesonKey -> m Text) -> [FakeIRValue] -> m Text
combineFakeIRValue FakerSettings
settings FakerSettings -> AesonKey -> m Text
resolverFn [FakeIRValue]
vals

resolveFakeIRValue :: (MonadIO m) => FakerSettings -> (FakerSettings -> AesonKey -> m Text) -> (FakeIRValue,StdGen) -> m Text
resolveFakeIRValue :: FakerSettings
-> (FakerSettings -> AesonKey -> m Text)
-> (FakeIRValue, StdGen)
-> m Text
resolveFakeIRValue FakerSettings
_ FakerSettings -> AesonKey -> m Text
_ (Literal Text
txt,StdGen
_) = Text -> m Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
txt
resolveFakeIRValue FakerSettings
settings FakerSettings -> AesonKey -> m Text
_ (Hash Int
num,StdGen
_) = Text -> m Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> m Text) -> Text -> m Text
forall a b. (a -> b) -> a -> b
$ FakerSettings -> Int -> Text
resolveHash FakerSettings
settings Int
num
resolveFakeIRValue FakerSettings
settings FakerSettings -> AesonKey -> m Text
_ (Ques Int
num,StdGen
_) = Text -> m Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> m Text) -> Text -> m Text
forall a b. (a -> b) -> a -> b
$ FakerSettings -> Int -> Text
resolveQues FakerSettings
settings Int
num
resolveFakeIRValue FakerSettings
settings FakerSettings -> AesonKey -> m Text
resolverFn (Resolve Text
text,StdGen
gen) = FakerSettings -> AesonKey -> m Text
resolverFn (StdGen -> FakerSettings -> FakerSettings
setRandomGen StdGen
gen FakerSettings
settings) (Text -> AesonKey
aesonKeyFromText Text
text)

combineFakeIRValue :: (MonadIO m) => FakerSettings -> (FakerSettings -> AesonKey -> m Text) -> [FakeIRValue] -> m Text
combineFakeIRValue :: FakerSettings
-> (FakerSettings -> AesonKey -> m Text) -> [FakeIRValue] -> m Text
combineFakeIRValue FakerSettings
settings FakerSettings -> AesonKey -> m Text
resolverFn [FakeIRValue]
xs = do
  [Text]
vals <- ((FakeIRValue, StdGen) -> m Text)
-> [(FakeIRValue, StdGen)] -> m [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (FakerSettings
-> (FakerSettings -> AesonKey -> m Text)
-> (FakeIRValue, StdGen)
-> m Text
forall (m :: * -> *).
MonadIO m =>
FakerSettings
-> (FakerSettings -> AesonKey -> m Text)
-> (FakeIRValue, StdGen)
-> m Text
resolveFakeIRValue FakerSettings
settings FakerSettings -> AesonKey -> m Text
resolverFn) ([FakeIRValue] -> [StdGen] -> [(FakeIRValue, StdGen)]
forall a b. [a] -> [b] -> [(a, b)]
zip [FakeIRValue]
xs (StdGen -> [StdGen]
stdgens (FakerSettings -> StdGen
getRandomGen FakerSettings
settings)))
  Text -> m Text
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> m Text) -> Text -> m Text
forall a b. (a -> b) -> a -> b
$ [Text] -> Text
T.concat [Text]
vals

resolveFields :: (MonadIO m, MonadThrow m) => Text -> m [FakeIRValue]
resolveFields :: Text -> m [FakeIRValue]
resolveFields Text
text = case Parser [FakeIRValue] -> Text -> Either String [FakeIRValue]
forall a. Parser a -> Text -> Either String a
P.parseOnly Parser [FakeIRValue]
parseFakedata Text
text of
                       Left String
err -> FakerException -> m [FakeIRValue]
forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM (FakerException -> m [FakeIRValue])
-> FakerException -> m [FakeIRValue]
forall a b. (a -> b) -> a -> b
$ String -> FakerException
ParseError String
err
                       Right [FakeIRValue]
vals -> [FakeIRValue] -> m [FakeIRValue]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [FakeIRValue]
vals

genericResolver :: (MonadIO m, MonadThrow m) => FakerSettings -> AesonKey -> (FakerSettings -> AesonKey -> m Text) -> m Text
genericResolver :: FakerSettings
-> AesonKey -> (FakerSettings -> AesonKey -> m Text) -> m Text
genericResolver FakerSettings
settings AesonKey
txt FakerSettings -> AesonKey -> m Text
resolverFn = FakerSettings
-> (FakerSettings -> AesonKey -> m Text) -> [FakeIRValue] -> m Text
forall (m :: * -> *).
MonadIO m =>
FakerSettings
-> (FakerSettings -> AesonKey -> m Text) -> [FakeIRValue] -> m Text
combineFakeIRValue FakerSettings
settings FakerSettings -> AesonKey -> m Text
resolverFn [Text -> FakeIRValue
Resolve (AesonKey -> Text
aesonKeyToText AesonKey
txt)]

genericResolver' :: (MonadIO m, MonadThrow m) => (FakerSettings -> AesonKey -> m Text) -> FakerSettings -> AesonKey -> m Text
genericResolver' :: (FakerSettings -> AesonKey -> m Text)
-> FakerSettings -> AesonKey -> m Text
genericResolver' FakerSettings -> AesonKey -> m Text
resolverFn FakerSettings
settings AesonKey
txt = FakerSettings
-> AesonKey -> (FakerSettings -> AesonKey -> m Text) -> m Text
forall (m :: * -> *).
(MonadIO m, MonadThrow m) =>
FakerSettings
-> AesonKey -> (FakerSettings -> AesonKey -> m Text) -> m Text
genericResolver FakerSettings
settings AesonKey
txt FakerSettings -> AesonKey -> m Text
resolverFn

-- resolveHash settings 3
-- "234"
resolveHash :: FakerSettings -> Int -> Text
resolveHash :: FakerSettings -> Int -> Text
resolveHash FakerSettings
settings Int
num = String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ FakerSettings -> Int -> ShowS
forall t. (Eq t, Num t) => FakerSettings -> t -> ShowS
helper FakerSettings
settings Int
num String
forall a. Monoid a => a
mempty
    where
      helper :: FakerSettings -> t -> ShowS
helper FakerSettings
_ t
0 String
acc = String
acc
      helper FakerSettings
settings !t
n String
acc = do
        let (Int
num, StdGen
newGen) = (Int, Int) -> StdGen -> (Int, StdGen)
forall a g. (Random a, RandomGen g) => (a, a) -> g -> (a, g)
randomR (Int
0, Int
9) (FakerSettings -> StdGen
getRandomGen FakerSettings
settings)
        FakerSettings -> t -> ShowS
helper (StdGen -> FakerSettings -> FakerSettings
setRandomGen StdGen
newGen FakerSettings
settings) (t
n t -> t -> t
forall a. Num a => a -> a -> a
- t
1) ((Int -> Char
digitToChar Int
num)Char -> ShowS
forall a. a -> [a] -> [a]
:String
acc)

resolveQues :: FakerSettings -> Int -> Text
resolveQues :: FakerSettings -> Int -> Text
resolveQues FakerSettings
settings Int
num = String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ FakerSettings -> Int -> ShowS
forall t. (Eq t, Num t) => FakerSettings -> t -> ShowS
helper FakerSettings
settings Int
num String
forall a. Monoid a => a
mempty
    where
      helper :: FakerSettings -> t -> ShowS
helper FakerSettings
_ t
0 String
acc = String
acc
      helper FakerSettings
settings !t
n String
acc = do
        let (Char
char, StdGen
newGen) = (Char, Char) -> StdGen -> (Char, StdGen)
forall a g. (Random a, RandomGen g) => (a, a) -> g -> (a, g)
randomR (Char
'A', Char
'Z') (FakerSettings -> StdGen
getRandomGen FakerSettings
settings)
        FakerSettings -> t -> ShowS
helper (StdGen -> FakerSettings -> FakerSettings
setRandomGen StdGen
newGen FakerSettings
settings) (t
n t -> t -> t
forall a. Num a => a -> a -> a
- t
1) (Char
charChar -> ShowS
forall a. a -> [a] -> [a]
:String
acc)

digitToChar :: Int -> Char
digitToChar :: Int -> Char
digitToChar Int
0 = Char
'0'
digitToChar Int
1 = Char
'1'
digitToChar Int
2 = Char
'2'
digitToChar Int
3 = Char
'3'
digitToChar Int
4 = Char
'4'
digitToChar Int
5 = Char
'5'
digitToChar Int
6 = Char
'6'
digitToChar Int
7 = Char
'7'
digitToChar Int
8 = Char
'8'
digitToChar Int
9 = Char
'9'
digitToChar Int
x = String -> Char
forall a. HasCallStack => String -> a
error (String -> Char) -> String -> Char
forall a b. (a -> b) -> a -> b
$ String
"Expected single digit number, but received " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Int -> String
forall a. Show a => a -> String
show Int
x

resolver ::
     (MonadThrow m, MonadIO m)
  => (FakerSettings -> m (Vector a))
  -> FakerSettings
  -> m a
resolver :: (FakerSettings -> m (Vector a)) -> FakerSettings -> m a
resolver FakerSettings -> m (Vector a)
provider = \FakerSettings
settings -> FakerSettings -> (FakerSettings -> m (Vector a)) -> m a
forall (m :: * -> *) a.
(MonadThrow m, MonadIO m) =>
FakerSettings -> (FakerSettings -> m (Vector a)) -> m a
randomVec FakerSettings
settings FakerSettings -> m (Vector a)
provider

unresolvedResolver ::
     (MonadThrow m, MonadIO m)
  => (FakerSettings -> m (Unresolved (Vector Text)))
  -> (FakerSettings -> AesonKey -> m Text)
  -> (FakerSettings -> m Text)
unresolvedResolver :: (FakerSettings -> m (Unresolved (Vector Text)))
-> (FakerSettings -> AesonKey -> m Text) -> FakerSettings -> m Text
unresolvedResolver FakerSettings -> m (Unresolved (Vector Text))
provider FakerSettings -> AesonKey -> m Text
resolverFn =
  \FakerSettings
settings -> FakerSettings
-> (FakerSettings -> m (Unresolved (Vector Text)))
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
forall (m :: * -> *).
(MonadThrow m, MonadIO m) =>
FakerSettings
-> (FakerSettings -> m (Unresolved (Vector Text)))
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
randomUnresolvedVec FakerSettings
settings FakerSettings -> m (Unresolved (Vector Text))
provider FakerSettings -> AesonKey -> m Text
resolverFn

unresolvedResolverWithoutVector ::
     (MonadThrow m, MonadIO m)
  => (FakerSettings -> m (Unresolved Text))
  -> (FakerSettings -> AesonKey -> m Text)
  -> (FakerSettings -> m Text)
unresolvedResolverWithoutVector :: (FakerSettings -> m (Unresolved Text))
-> (FakerSettings -> AesonKey -> m Text) -> FakerSettings -> m Text
unresolvedResolverWithoutVector FakerSettings -> m (Unresolved Text)
provider FakerSettings -> AesonKey -> m Text
resolverFn =
  \FakerSettings
settings -> FakerSettings
-> (FakerSettings -> m (Unresolved Text))
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
forall (m :: * -> *).
(MonadThrow m, MonadIO m) =>
FakerSettings
-> (FakerSettings -> m (Unresolved Text))
-> (FakerSettings -> AesonKey -> m Text)
-> m Text
randomUnresolvedVecWithoutVector FakerSettings
settings FakerSettings -> m (Unresolved Text)
provider FakerSettings -> AesonKey -> m Text
resolverFn

uprStr :: String -> String
uprStr :: ShowS
uprStr [] = []
uprStr (Char
x:String
xs) = Char -> Char
toUpper Char
x Char -> ShowS
forall a. a -> [a] -> [a]
: String
xs

refinedString :: String -> String
refinedString :: ShowS
refinedString String
xs = String -> ShowS
aux String
xs []
  where
    String
whiteListChars :: [Char] = [Char
'-', Char
'_', Char
' ']
    aux :: String -> String -> String
    aux :: String -> ShowS
aux [] String
acc = String
acc
    aux (Char
x:String
remTxt) String
acc =
      if Char
x Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
whiteListChars
        then if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
remTxt
               then String -> ShowS
aux String
remTxt String
acc
               else String -> ShowS
aux (ShowS
uprStr String
remTxt) String
acc
        else String -> ShowS
aux String
remTxt (String
acc String -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char
x])

refinedText :: Text -> Text
refinedText :: Text -> Text
refinedText = String -> Text
T.pack (String -> Text) -> (Text -> String) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
refinedString ShowS -> (Text -> String) -> Text -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack

presentInCache :: Text -> AesonKey -> FakerSettings -> IO (Maybe (Vector Text))
presentInCache :: Text -> AesonKey -> FakerSettings -> IO (Maybe (Vector Text))
presentInCache Text
sdata AesonKey
field FakerSettings
settings = do
  let key :: CacheFieldKey
key =
        CacheFieldKey :: Text -> AesonKey -> Text -> CacheFieldKey
CacheFieldKey
          {ckSource :: Text
ckSource = Text
sdata, ckLocale :: Text
ckLocale = FakerSettings -> Text
getLocale FakerSettings
settings, ckField :: AesonKey
ckField = AesonKey
field}
  HashMap CacheFieldKey (Vector Text)
hmap <- FakerSettings -> IO (HashMap CacheFieldKey (Vector Text))
getCacheField FakerSettings
settings
  Maybe (Vector Text) -> IO (Maybe (Vector Text))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (Vector Text) -> IO (Maybe (Vector Text)))
-> Maybe (Vector Text) -> IO (Maybe (Vector Text))
forall a b. (a -> b) -> a -> b
$ CacheFieldKey
-> HashMap CacheFieldKey (Vector Text) -> Maybe (Vector Text)
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup CacheFieldKey
key HashMap CacheFieldKey (Vector Text)
hmap

insertToCache :: Text -> AesonKey -> FakerSettings -> (Vector Text) -> IO ()
insertToCache :: Text -> AesonKey -> FakerSettings -> Vector Text -> IO ()
insertToCache Text
sdata AesonKey
field FakerSettings
settings Vector Text
vec = do
  let key :: CacheFieldKey
key =
        CacheFieldKey :: Text -> AesonKey -> Text -> CacheFieldKey
CacheFieldKey
          {ckSource :: Text
ckSource = Text
sdata, ckLocale :: Text
ckLocale = FakerSettings -> Text
getLocale FakerSettings
settings, ckField :: AesonKey
ckField = AesonKey
field}
  HashMap CacheFieldKey (Vector Text)
hmap <- FakerSettings -> IO (HashMap CacheFieldKey (Vector Text))
getCacheField FakerSettings
settings
  let hmap2 :: HashMap CacheFieldKey (Vector Text)
hmap2 = CacheFieldKey
-> Vector Text
-> HashMap CacheFieldKey (Vector Text)
-> HashMap CacheFieldKey (Vector Text)
forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
HM.insert CacheFieldKey
key Vector Text
vec HashMap CacheFieldKey (Vector Text)
hmap
  HashMap CacheFieldKey (Vector Text) -> FakerSettings -> IO ()
setCacheField HashMap CacheFieldKey (Vector Text)
hmap2 FakerSettings
settings

stdgens :: StdGen -> [StdGen]
stdgens :: StdGen -> [StdGen]
stdgens StdGen
gen = let (StdGen
g1, StdGen
g2) = StdGen -> (StdGen, StdGen)
forall g. RandomGen g => g -> (g, g)
split StdGen
gen
              in [StdGen
gen, StdGen
g1, StdGen
g2] [StdGen] -> [StdGen] -> [StdGen]
forall a. Semigroup a => a -> a -> a
<> (StdGen -> [StdGen]
stdgens StdGen
g2)

-- TODO: Not efficient. Better to switch to splitmax once this gets
-- resolved: https://github.com/phadej/splitmix/issues/23
incrementStdGen :: Word64 -> StdGen -> StdGen
incrementStdGen :: Word64 -> StdGen -> StdGen
incrementStdGen Word64
0 StdGen
gen = StdGen
gen
incrementStdGen Word64
n StdGen
gen =
  let (StdGen
_, StdGen
newGen) = StdGen -> (StdGen, StdGen)
forall g. RandomGen g => g -> (g, g)
split StdGen
gen
   in Word64 -> StdGen -> StdGen
incrementStdGen (Word64
n Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
1) StdGen
newGen

modifyRandomGen :: FakerSettings -> Word64 -> FakerSettings
modifyRandomGen :: FakerSettings -> Word64 -> FakerSettings
modifyRandomGen FakerSettings
settings Word64
seed =
  let gen :: StdGen
gen = FakerSettings -> StdGen
getRandomGen FakerSettings
settings
      newGen :: StdGen
newGen = Word64 -> StdGen -> StdGen
incrementStdGen Word64
seed StdGen
gen
   in StdGen -> FakerSettings -> FakerSettings
setRandomGen StdGen
newGen FakerSettings
settings

cachedRegex ::
     (MonadThrow m, MonadIO m)
  => Text
  -> AesonKey
  -> (FakerSettings -> m Regex)
  -> FakerSettings
  -> m RegexFakeValue
cachedRegex :: Text
-> AesonKey
-> (FakerSettings -> m Regex)
-> FakerSettings
-> m RegexFakeValue
cachedRegex Text
sdata AesonKey
field FakerSettings -> m Regex
provider FakerSettings
settings = do
  Maybe (Vector Text)
val <- IO (Maybe (Vector Text)) -> m (Maybe (Vector Text))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Vector Text)) -> m (Maybe (Vector Text)))
-> IO (Maybe (Vector Text)) -> m (Maybe (Vector Text))
forall a b. (a -> b) -> a -> b
$ Text -> AesonKey -> FakerSettings -> IO (Maybe (Vector Text))
presentInCache Text
sdata AesonKey
field FakerSettings
settings
  case Maybe (Vector Text)
val of
    Maybe (Vector Text)
Nothing -> do
      Regex
dat <- FakerSettings -> m Regex
provider FakerSettings
settings
      IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Text -> AesonKey -> FakerSettings -> Vector Text -> IO ()
insertToCache Text
sdata AesonKey
field FakerSettings
settings (Text -> Vector Text
forall a. a -> Vector a
V.singleton (Text -> Vector Text) -> Text -> Vector Text
forall a b. (a -> b) -> a -> b
$ Regex -> Text
unRegex Regex
dat)
      FakerSettings -> (FakerSettings -> m Regex) -> m RegexFakeValue
forall (m :: * -> *).
(MonadThrow m, MonadIO m) =>
FakerSettings -> (FakerSettings -> m Regex) -> m RegexFakeValue
generateRegexData FakerSettings
settings FakerSettings -> m Regex
provider
    Just Vector Text
vec -> RegexFakeValue -> m RegexFakeValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RegexFakeValue -> m RegexFakeValue)
-> RegexFakeValue -> m RegexFakeValue
forall a b. (a -> b) -> a -> b
$ FakerSettings -> Regex -> RegexFakeValue
generateRegex FakerSettings
settings (Text -> Regex
Regex (Text -> Regex) -> Text -> Regex
forall a b. (a -> b) -> a -> b
$ Vector Text -> Text
forall a. Vector a -> a
V.head Vector Text
vec)

cleanFakerRegex :: Text -> Text
cleanFakerRegex :: Text -> Text
cleanFakerRegex Text
xs = Int -> Text -> Text
T.dropEnd Int
1 (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ Int -> Text -> Text
T.drop Int
1 Text
xs

generateRegex :: FakerSettings -> Regex -> RegexFakeValue
generateRegex :: FakerSettings -> Regex -> RegexFakeValue
generateRegex FakerSettings
settings Regex
regex =
  let stdGen :: StdGen
stdGen = FakerSettings -> StdGen
getRandomGen FakerSettings
settings
  in Text -> RegexFakeValue
RegexFakeValue (Text -> RegexFakeValue) -> Text -> RegexFakeValue
forall a b. (a -> b) -> a -> b
$ StdGen -> Text -> Text
forall g. RandomGen g => g -> Text -> Text
stringRandom StdGen
stdGen (Text -> Text
cleanFakerRegex (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ Regex -> Text
unRegex Regex
regex)

generateRegexData ::
     (MonadThrow m, MonadIO m)
  => FakerSettings
  -> (FakerSettings -> m Regex)
  -> m RegexFakeValue
generateRegexData :: FakerSettings -> (FakerSettings -> m Regex) -> m RegexFakeValue
generateRegexData FakerSettings
settings FakerSettings -> m Regex
provider = do
  Regex
items <- FakerSettings -> m Regex
provider FakerSettings
settings
  RegexFakeValue -> m RegexFakeValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RegexFakeValue -> m RegexFakeValue)
-> RegexFakeValue -> m RegexFakeValue
forall a b. (a -> b) -> a -> b
$ FakerSettings -> Regex -> RegexFakeValue
generateRegex FakerSettings
settings Regex
items