module Bloodhound.Import
( module X
, LByteString
, Method
, omitNulls
, parseNEJSON
, parseReadText
, readMay
, showText
, deleteSeveral
, oPath
, tshow
) where
import Control.Applicative as X (Alternative (..), optional)
import Control.Exception as X (Exception)
import Control.Monad as X (MonadPlus (..), forM, (<=<))
import Control.Monad.Catch as X (MonadCatch, MonadMask,
MonadThrow)
import Control.Monad.Except as X (MonadError)
import Control.Monad.Fix as X (MonadFix)
import Control.Monad.IO.Class as X (MonadIO (..))
import Control.Monad.Reader as X (MonadReader (..),
MonadTrans (..), ReaderT (..))
import Control.Monad.State as X (MonadState)
import Control.Monad.Writer as X (MonadWriter)
import Data.Aeson as X
import Data.Aeson.Key as X
import qualified Data.Aeson.KeyMap as X
import Data.Aeson.Types as X (Pair, Parser, emptyObject,
parseEither, parseMaybe,
typeMismatch)
import Data.Bifunctor as X (first)
import Data.Char as X (isNumber)
import Data.Hashable as X (Hashable)
import Data.List as X (foldl', intercalate, nub)
import Data.List.NonEmpty as X (NonEmpty (..), toList)
import Data.Maybe as X (catMaybes, fromMaybe,
isNothing, maybeToList)
import Data.Scientific as X (Scientific)
import Data.Semigroup as X (Semigroup (..))
import Data.Text as X (Text)
import Data.Time.Calendar as X (Day (..), showGregorian)
import Data.Time.Clock as X (NominalDiffTime, UTCTime)
import Data.Time.Clock.POSIX as X
import qualified Data.ByteString.Lazy as BL
import qualified Data.Text as T
import qualified Data.Traversable as DT
import qualified Data.Vector as V
import qualified Network.HTTP.Types.Method as NHTM
type LByteString = BL.ByteString
type Method = NHTM.Method
readMay :: Read a => String -> Maybe a
readMay s = case reads s of
(a, ""):_ -> Just a
_ -> Nothing
parseReadText :: Read a => Text -> Parser a
parseReadText = maybe mzero return . readMay . T.unpack
showText :: Show a => a -> Text
showText = T.pack . show
omitNulls :: [(Key, Value)] -> Value
omitNulls = object . filter notNull where
notNull (_, Null) = False
notNull (_, Array a) = (not . V.null) a
notNull _ = True
parseNEJSON :: (FromJSON a) => [Value] -> Parser (NonEmpty a)
parseNEJSON [] = fail "Expected non-empty list"
parseNEJSON (x:xs) = DT.mapM parseJSON (x :| xs)
deleteSeveral :: [Key] -> X.KeyMap v -> X.KeyMap v
deleteSeveral ks km = foldr X.delete km ks
oPath :: ToJSON a => NonEmpty Key -> a -> Value
oPath (k :| []) v = object [k .= v]
oPath (k:| (h:t)) v = object [k .= oPath (h :| t) v]
tshow :: Show a => a -> Text
tshow = T.pack . show