{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings #-}
module Data.Ini
(
readIniFile
,parseIni
,lookupValue
,lookupArray
,readValue
,readArray
,parseValue
,sections
,keys
,printIni
,writeIniFile
,KeySeparator(..)
,WriteIniSettings(..)
,defaultWriteIniSettings
,printIniWith
,writeIniFileWith
,Ini(..)
,unIni
,iniParser
,sectionParser
,keyValueParser
)
where
import Control.Applicative
import Control.Monad
import Data.Attoparsec.Combinator
import Data.Attoparsec.Text
import Data.Char
import Data.HashMap.Strict (HashMap)
import qualified Data.HashMap.Strict as M
import Data.Maybe
import Data.Monoid (Monoid)
import Data.Semigroup
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.IO as T
import Prelude hiding (takeWhile)
data Ini =
Ini
{ iniSections :: HashMap Text [(Text, Text)]
, iniGlobals :: [(Text, Text)]
}
deriving (Show, Eq)
instance Semigroup Ini where
(<>) = mappend
instance Monoid Ini where
mempty = Ini {iniGlobals = mempty, iniSections = mempty}
mappend x y =
Ini {iniGlobals = mempty, iniSections = iniSections x <> iniSections y}
{-# DEPRECATED #-}
unIni :: Ini -> HashMap Text (HashMap Text Text)
unIni = fmap M.fromList . iniSections
readIniFile :: FilePath -> IO (Either String Ini)
readIniFile = fmap parseIni . T.readFile
parseIni :: Text -> Either String Ini
parseIni = parseOnly iniParser
lookupValue :: Text
-> Text
-> Ini -> Either String Text
lookupValue name key (Ini {iniSections=secs}) =
case M.lookup name secs of
Nothing -> Left ("Couldn't find section: " ++ T.unpack name)
Just section ->
case lookup key section of
Nothing -> Left ("Couldn't find key: " ++ T.unpack key)
Just value -> return value
lookupArray :: Text
-> Text
-> Ini -> Either String [Text]
lookupArray name key (Ini {iniSections = secs}) =
case M.lookup name secs of
Nothing -> Left ("Couldn't find section: " ++ T.unpack name)
Just section ->
case mapMaybe
(\(k, v) ->
if k == key
then Just v
else Nothing)
section of
[] -> Left ("Couldn't find key: " ++ T.unpack key)
values -> return values
sections :: Ini -> [Text]
sections = M.keys . iniSections
keys :: Text
-> Ini -> Either String [Text]
keys name i =
case M.lookup name (iniSections i) of
Nothing -> Left ("Couldn't find section: " ++ T.unpack name)
Just section -> Right (map fst section)
readValue :: Text
-> Text
-> (Text -> Either String (a, Text))
-> Ini
-> Either String a
readValue section key f ini =
lookupValue section key ini >>= f >>= return . fst
readArray :: Text
-> Text
-> (Text -> Either String (a, Text))
-> Ini
-> Either String [a]
readArray section key f ini =
fmap (map fst) (lookupArray section key ini >>= mapM f)
parseValue :: Text
-> Text
-> Parser a
-> Ini
-> Either String a
parseValue section key f ini =
lookupValue section key ini >>= parseOnly (f <* (skipSpace >> endOfInput))
writeIniFile :: FilePath -> Ini -> IO ()
writeIniFile = writeIniFileWith defaultWriteIniSettings
printIni :: Ini -> Text
printIni = printIniWith defaultWriteIniSettings
data KeySeparator
= ColonKeySeparator
| EqualsKeySeparator
deriving (Eq, Show)
data WriteIniSettings = WriteIniSettings
{ writeIniKeySeparator :: KeySeparator
} deriving (Show)
defaultWriteIniSettings :: WriteIniSettings
defaultWriteIniSettings = WriteIniSettings
{ writeIniKeySeparator = ColonKeySeparator
}
writeIniFileWith :: WriteIniSettings -> FilePath -> Ini -> IO ()
writeIniFileWith wis fp = T.writeFile fp . printIniWith wis
printIniWith :: WriteIniSettings -> Ini -> Text
printIniWith wis i =
T.concat (map buildSection (M.toList (iniSections i)))
where buildSection (name,pairs) =
"[" <> name <> "]\n" <>
T.concat (map buildPair pairs)
buildPair (name,value) =
name <> separator <> value <> "\n"
separator = case writeIniKeySeparator wis of
ColonKeySeparator -> ": "
EqualsKeySeparator -> "="
iniParser :: Parser Ini
iniParser =
(\kv secs -> Ini {iniSections = M.fromList secs, iniGlobals = kv}) <$>
many keyValueParser <*>
many sectionParser
sectionParser :: Parser (Text,[(Text, Text)])
sectionParser =
do skipEndOfLine
skipComments
skipEndOfLine
_ <- char '['
name <- takeWhile (\c -> c /=']' && c /= '[')
_ <- char ']'
skipEndOfLine
values <- many keyValueParser
return (T.strip name, values)
keyValueParser :: Parser (Text,Text)
keyValueParser =
do skipEndOfLine
skipComments
skipEndOfLine
key <- takeWhile1 (\c -> not (isDelim c || c == '[' || c == ']'))
delim <- satisfy isDelim
value <- fmap (clean delim) (takeWhile (not . isEndOfLine))
skipEndOfLine
return (T.strip key, T.strip value)
where clean ':' = T.drop 1
clean _ = id
isDelim :: Char -> Bool
isDelim x = x == '=' || x == ':'
skipEndOfLine :: Parser ()
skipEndOfLine = skipWhile isSpace
skipComments :: Parser ()
skipComments =
skipMany (do _ <- satisfy (\c -> c == ';' || c == '#')
skipWhile (not . isEndOfLine)
skipEndOfLine)