module Argo.Encode where

import qualified Argo.Class.ToValue as ToValue
import qualified Argo.Encoder as Encoder
import qualified Argo.Json.Value as Value
import qualified Argo.Literal as Literal
import qualified Argo.Pointer.Pointer as Pointer
import qualified Argo.Vendor.Builder as Builder
import qualified Argo.Vendor.Transformers as Trans
import qualified Control.Monad as Monad

encode :: ToValue.ToValue a => a -> Builder.Builder
encode :: a -> Builder
encode = Indent -> a -> Builder
forall a. ToValue a => Indent -> a -> Builder
encodeWith (Indent -> a -> Builder) -> Indent -> a -> Builder
forall a b. (a -> b) -> a -> b
$ Int -> Indent
Encoder.Spaces Int
0

encodeWith :: ToValue.ToValue a => Encoder.Indent -> a -> Builder.Builder
encodeWith :: Indent -> a -> Builder
encodeWith Indent
i a
x =
    let c :: Config
c = Config
Encoder.defaultConfig { indent :: Indent
Encoder.indent = Indent
i }
    in ((), Builder) -> Builder
forall a b. (a, b) -> b
snd (((), Builder) -> Builder)
-> (Encoder () -> ((), Builder)) -> Encoder () -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Config -> Encoder () -> ((), Builder)
forall a. Config -> Encoder a -> (a, Builder)
Encoder.run Config
c (Encoder () -> Builder) -> Encoder () -> Builder
forall a b. (a -> b) -> a -> b
$ do
        Value -> Encoder ()
Value.encode (Value -> Encoder ()) -> Value -> Encoder ()
forall a b. (a -> b) -> a -> b
$ a -> Value
forall a. ToValue a => a -> Value
ToValue.toValue a
x
        Bool -> Encoder () -> Encoder ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
Monad.when (Config -> Bool
Encoder.hasIndent Config
c)
            (Encoder () -> Encoder ())
-> (Builder -> Encoder ()) -> Builder -> Encoder ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WriterT Builder Identity () -> Encoder ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
Trans.lift
            (WriterT Builder Identity () -> Encoder ())
-> (Builder -> WriterT Builder Identity ())
-> Builder
-> Encoder ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> WriterT Builder Identity ()
forall (m :: * -> *) w. Monad m => w -> WriterT w m ()
Trans.tell
            (Builder -> Encoder ()) -> Builder -> Encoder ()
forall a b. (a -> b) -> a -> b
$ Word8 -> Builder
Builder.word8 Word8
Literal.newLine

encodePointer :: Pointer.Pointer -> Builder.Builder
encodePointer :: Pointer -> Builder
encodePointer =
    let c :: Config
c = Config
Encoder.defaultConfig
    in ((), Builder) -> Builder
forall a b. (a, b) -> b
snd (((), Builder) -> Builder)
-> (Pointer -> ((), Builder)) -> Pointer -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Config -> Encoder () -> ((), Builder)
forall a. Config -> Encoder a -> (a, Builder)
Encoder.run Config
c (Encoder () -> ((), Builder))
-> (Pointer -> Encoder ()) -> Pointer -> ((), Builder)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pointer -> Encoder ()
Pointer.encode