{-|
Module      : Toml
Description : TOML parsing, printing, and codecs
Copyright   : (c) Eric Mertens, 2023
License     : ISC
Maintainer  : emertens@gmail.com

This is the high-level interface to the toml-parser library.
It enables parsing, printing, and coversion into and out of
application-specific representations.

This parser implements TOML 1.0.0 <https://toml.io/en/v1.0.0>
as carefully as possible.

-}
module Toml (

    -- * Types
    Table,
    Value(..),

    -- * Parsing
    parse,

    -- * Printing
    prettyToml,
    DocClass(..),

    -- * Serialization
    decode,
    encode,
    Result(..),
    ) where

import Text.Printf (printf)
import Toml.FromValue (FromValue (fromValue), Result(..))
import Toml.FromValue.Matcher (runMatcher)
import Toml.Lexer (scanTokens, Token(TokError))
import Toml.Located (Located(Located))
import Toml.Parser (parseRawToml)
import Toml.Position (Position(posColumn, posLine))
import Toml.Pretty (TomlDoc, DocClass(..), prettyToken, prettyToml)
import Toml.Semantics (semantics)
import Toml.ToValue (ToTable (toTable))
import Toml.Value (Table, Value(..))

-- | Parse a TOML formatted 'String' or report an error message.
parse :: String -> Either String Table
parse :: String -> Either String Table
parse String
str =
    case [Located Token] -> Either (Located Token) [Expr]
parseRawToml (String -> [Located Token]
scanTokens String
str) of
        Left (Located Position
p (TokError String
e)) ->
            forall a b. a -> Either a b
Left (forall r. PrintfType r => String -> r
printf String
"%d:%d: lexical error: %s" (Position -> Int
posLine Position
p) (Position -> Int
posColumn Position
p) String
e)
        Left (Located Position
p Token
t) ->
            forall a b. a -> Either a b
Left (forall r. PrintfType r => String -> r
printf String
"%d:%d: parse error: unexpected %s" (Position -> Int
posLine Position
p) (Position -> Int
posColumn Position
p) (Token -> String
prettyToken Token
t))
        Right [Expr]
exprs -> [Expr] -> Either String Table
semantics [Expr]
exprs

-- | Use the 'FromValue' instance to decode a value from a TOML string.
decode :: FromValue a => String -> Result a
decode :: forall a. FromValue a => String -> Result a
decode = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a. [String] -> Result a
Failure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure) (forall a. Matcher a -> Result a
runMatcher forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. FromValue a => Value -> Matcher a
fromValue forall b c a. (b -> c) -> (a -> b) -> a -> c
. Table -> Value
Table) forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either String Table
parse

-- | Use the 'ToTable' instance to encode a value to a TOML string.
encode :: ToTable a => a -> TomlDoc
encode :: forall a. ToTable a => a -> TomlDoc
encode = Table -> TomlDoc
prettyToml forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ToTable a => a -> Table
toTable