config-ini-0.1.2.1: A library for simple INI-based configuration files.

Safe HaskellNone
LanguageHaskell2010

Data.Ini.Config

Contents

Synopsis

Documentation

The 'config-ini' library exports some simple monadic functions to make parsing INI-like configuration easier. INI files have a two-level structure: the top-level named chunks of configuration, and the individual key-value pairs contained within those chunks. For example, the following INI file has two sections, NETWORK and LOCAL, and each contains its own key-value pairs. Comments, which begin with # or ;, are ignored:

[NETWORK]
host = example.com
port = 7878

# here is a comment
[LOCAL]
user = terry

The combinators provided here are designed to write quick and idiomatic parsers for files of this form. Sections are parsed by IniParser computations, like section and its variations, while the fields within sections are parsed by SectionParser computations, like field and its variations. If we want to parse an INI file like the one above, treating the entire LOCAL section as optional, we can write it like this:

data Config = Config
  { cfNetwork :: NetworkConfig, cfLocal :: Maybe LocalConfig }
    deriving (Eq, Show)

data NetworkConfig = NetworkConfig
  { netHost :: String, netPort :: Int }
    deriving (Eq, Show)

data LocalConfig = LocalConfig
  { localUser :: Text }
    deriving (Eq, Show)

configParser :: IniParser Config
configParser = do
  netCf <- section "NETWORK" $ do
    host <- fieldOf "host" string
    port <- fieldOf "port" number
    return NetworkConfig { netHost = host, netPort = port }
  locCf <- sectionMb "LOCAL" $
    LocalConfig <$> field "user"
  return Config { cfNetwork = netCf, cfLocal = locCf }

We can run our computation with parseIniFile, which, when run on our example file above, would produce the following:

>>> parseIniFile example configParser
Right (Config {cfNetwork = NetworkConfig {netHost = "example.com", netPort = 7878}, cfLocal = Just (LocalConfig {localUser = "terry"})})

parseIniFile :: Text -> IniParser a -> Either String a Source #

Parse a Text value as an INI file and run an IniParser over it

Parser Types

data IniParser a Source #

An IniParser value represents a computation for parsing entire INI-format files.

Instances

data SectionParser a Source #

A SectionParser value represents a computation for parsing a single section of an INI-format file.

Instances

Section-Level Parsing

section :: Text -> SectionParser a -> IniParser a Source #

Find a named section in the INI file and parse it with the provided section parser, failing if the section does not exist. In order to support classic INI files with capitalized section names, section lookup is case-insensitive.

>>> parseIniFile "[ONE]\nx = hello\n" $ section "ONE" (field "x")
Right "hello"
>>> parseIniFile "[ONE]\nx = hello\n" $ section "TWO" (field "x")
Left "No top-level section named \"TWO\""

sectionMb :: Text -> SectionParser a -> IniParser (Maybe a) Source #

Find a named section in the INI file and parse it with the provided section parser, returning Nothing if the section does not exist. In order to support classic INI files with capitalized section names, section lookup is case-insensitive.

>>> parseIniFile "[ONE]\nx = hello\n" $ sectionMb "ONE" (field "x")
Right (Just "hello")
>>> parseIniFile "[ONE]\nx = hello\n" $ sectionMb "TWO" (field "x")
Right Nothing

sectionDef :: Text -> a -> SectionParser a -> IniParser a Source #

Find a named section in the INI file and parse it with the provided section parser, returning a default value if the section does not exist. In order to support classic INI files with capitalized section names, section lookup is case-insensitive.

>>> parseIniFile "[ONE]\nx = hello\n" $ sectionDef "ONE" "def" (field "x")
Right "hello"
>>> parseIniFile "[ONE]\nx = hello\n" $ sectionDef "TWO" "def" (field "x")
Right "def"

Field-Level Parsing

field :: Text -> SectionParser Text Source #

Retrieve a field, failing if it doesn't exist, and return its raw value.

>>> parseIniFile "[MAIN]\nx = hello\n" $ section "MAIN" (field "x")
Right "hello"
>>> parseIniFile "[MAIN]\nx = hello\n" $ section "MAIN" (field "y")
Left "Missing field \"y\" in section \"MAIN\""

fieldOf :: Text -> (Text -> Either String a) -> SectionParser a Source #

Retrieve a field and use the supplied parser to parse it as a value, failing if the field does not exist, or if the parser fails to produce a value.

>>> parseIniFile "[MAIN]\nx = 72\n" $ section "MAIN" (fieldOf "x" number)
Right 72
>>> parseIniFile "[MAIN]\nx = hello\n" $ section "MAIN" (fieldOf "x" number)
Left "Line 2, in section \"MAIN\": Unable to parse \"hello\" as a value of type Integer"
>>> parseIniFile "[MAIN]\nx = 72\n" $ section "MAIN" (fieldOf "y" number)
Left "Missing field \"y\" in section \"MAIN\""

fieldMb :: Text -> SectionParser (Maybe Text) Source #

Retrieve a field, returning a Nothing value if it does not exist.

>>> parseIniFile "[MAIN]\nx = hello\n" $ section "MAIN" (fieldMb "x")
Right (Just "hello")
>>> parseIniFile "[MAIN]\nx = hello\n" $ section "MAIN" (fieldMb "y")
Right Nothing

fieldMbOf :: Text -> (Text -> Either String a) -> SectionParser (Maybe a) Source #

Retrieve a field and parse it according to the given parser, returning Nothing if it does not exist. If the parser fails, then this will fail.

>>> parseIniFile "[MAIN]\nx = 72\n" $ section "MAIN" (fieldMbOf "x" number)
Right (Just 72)
>>> parseIniFile "[MAIN]\nx = hello\n" $ section "MAIN" (fieldMbOf "x" number)
Left "Line 2, in section \"MAIN\": Unable to parse \"hello\" as a value of type Integer"
>>> parseIniFile "[MAIN]\nx = 72\n" $ section "MAIN" (fieldMbOf "y" number)
Right Nothing

fieldDef :: Text -> Text -> SectionParser Text Source #

Retrieve a field and supply a default value for if it doesn't exist.

>>> parseIniFile "[MAIN]\nx = hello\n" $ section "MAIN" (fieldDef "x" "def")
Right "hello"
>>> parseIniFile "[MAIN]\nx = hello\n" $ section "MAIN" (fieldDef "y" "def")
Right "def"

fieldDefOf :: Text -> (Text -> Either String a) -> a -> SectionParser a Source #

Retrieve a field, parsing it according to the given parser, and returning a default value if it does not exist. If the parser fails, then this will fail.

>>> parseIniFile "[MAIN]\nx = 72\n" $ section "MAIN" (fieldDefOf "x" number 99)
Right 72
>>> parseIniFile "[MAIN]\nx = hello\n" $ section "MAIN" (fieldDefOf "x" number 99)
Left "Line 2, in section \"MAIN\": Unable to parse \"hello\" as a value of type Integer"
>>> parseIniFile "[MAIN]\nx = 72\n" $ section "MAIN" (fieldDefOf "y" number 99)
Right 99

fieldFlag :: Text -> SectionParser Bool Source #

Retrieve a field and treat it as a boolean, failing if it does not exist.

>>> parseIniFile "[MAIN]\nx = yes\n" $ section "MAIN" (fieldFlag "x")
Right True
>>> parseIniFile "[MAIN]\nx = yes\n" $ section "MAIN" (fieldFlag "y")
Left "Missing field \"y\" in section \"MAIN\""

fieldFlagDef :: Text -> Bool -> SectionParser Bool Source #

Retrieve a field and treat it as a boolean, subsituting a default value if it doesn't exist.

>>> parseIniFile "[MAIN]\nx = yes\n" $ section "MAIN" (fieldFlagDef "x" False)
Right True
>>> parseIniFile "[MAIN]\nx = hello\n" $ section "MAIN" (fieldFlagDef "x" False)
Left "Line 2, in section \"MAIN\": Unable to parse \"hello\" as a boolean"
>>> parseIniFile "[MAIN]\nx = yes\n" $ section "MAIN" (fieldFlagDef "y" False)
Right False

Reader Functions

readable :: forall a. (Read a, Typeable a) => Text -> Either String a Source #

Try to use the Read instance for a type to parse a value, failing with a human-readable error message if reading fails.

>>> readable "(5, 7)" :: Either String (Int, Int)
Right (5,7)
>>> readable "hello" :: Either String (Int, Int)
Left "Unable to parse \"hello\" as a value of type (Int,Int)"

number :: (Num a, Read a, Typeable a) => Text -> Either String a Source #

Try to use the Read instance for a numeric type to parse a value, failing with a human-readable error message if reading fails.

>>> number "5" :: Either String Int
Right 5
>>> number "hello" :: Either String Int
Left "Unable to parse \"hello\" as a value of type Int"

string :: IsString a => Text -> Either String a Source #

Convert a textua value to the appropriate string type. This will never fail.

>>> string "foo" :: Either String String
Right "foo"

flag :: Text -> Either String Bool Source #

Convert a string that represents a boolean to a proper boolean. This is case-insensitive, and matches the words true, false, yes, no, as well as single-letter abbreviations for all of the above. If the input does not match, then this will fail with a human-readable error message.

>>> flag "TRUE"
Right True
>>> flag "y"
Right True
>>> flag "no"
Right False
>>> flag "F"
Right False
>>> flag "That's a secret!"
Left "Unable to parse \"That's a secret!\" as a boolean"