config-ini-0.2.7.0/0000755000000000000000000000000007346545000012071 5ustar0000000000000000config-ini-0.2.7.0/CHANGELOG.md0000644000000000000000000000225507346545000013706 0ustar00000000000000000.2.4.0 ======= - Fixed a bug that prevented `config-ini` from building with GHC 7.10 - Bumped version bounds for `containers` to enable GHC 8.6 compat 0.2.3.0 ======= - Add the `iniValueL` lens for access to the underlying INI value in a value of type `Ini s` - Bumped compatible version of `megaparsec` 0.2.2.0 ======= - Added `sections`, `sectionOf`, and `sectionsOf` helpers to the vanilla API for more flexibility in working with section names - Put `test-doctest` behind a flag, which is disabled by default 0.2.1.1 ======= - Fix doctest pointing at deprecated API 0.2.1.0 ======= - Fix regression in standard API where values would be reported with extraneous whitespace 0.2.0.1 ======= - Include prewritten test cases in distributed package 0.2.0.0 ======= - Introduced `Data.Config.Ini.Bidir`, which introduces a new alternate API for working with Ini files. - Reworked the internal representation to accomodate `Data.Config.Ini.Bidir`; as such, the structure of `Data.Config.Ini.Raw` is radically changed - Dropped GHC 7.8 backwards-compatibility. 0.1.2.1 ======= - GHC 8.2 compatibility 0.1.2.0 ======= - GHC 7.8 backwards-compatibility - Started changelog config-ini-0.2.7.0/LICENSE0000644000000000000000000000271307346545000013101 0ustar0000000000000000Copyright (c) 2016, Getty Ritter All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. config-ini-0.2.7.0/README.md0000644000000000000000000002127107346545000013353 0ustar0000000000000000# `config-ini` [![Hackage](https://img.shields.io/hackage/v/config-ini.svg)](https://hackage.haskell.org/package/config-ini) ![stability: stable](https://img.shields.io/badge/stability-stable-green.svg) The `config-ini` library is a Haskell library for doing elementary INI file parsing in a quick and painless way. ## Basic Usage 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 section contains its own key-value pairs separated by either `=` or `:`. Comments, which begin with `#` or `;`, are ignored: ~~~.ini [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 basic INI files. 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: ~~~haskell 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: ~~~haskell >>> parseIniFile example configParser Right (Config {cfNetwork = NetworkConfig {netHost = "example.com", netPort = 7878}, cfLocal = Just (LocalConfig {localUser = "terry"})}) ~~~ ## Bidirectional Usage The above example had an INI file split into two sections (`NETWORK` and `LOCAL`) and a data type with a corresponding structure (containing a `NetworkConfig` and `Maybe LocalConfig` field), which allowed each `section`-level parser to construct a chunk of the configuration and then combine them. This works well if our configuration file has the same structure as our data type, but that might not be what we want. Let's imagine we want to construct our `Config` type as a flat record like this: ~~~haskell data Config = Config { _cfHost :: String , _cfPort :: Int , _cfUser :: Maybe Text } deriving (Eq, Show) ~~~ In this case, we can't construct a `Config` value until we've parsed all three fields in two distinct subsections. One way of doing this is to return the intermediate values from our `section` parsers and construct the `Config` value at the end, once we have all three of its fields: ~~~haskell configParser :: IniParser Config configParser = do (host, port) <- section "NETWORK" $ do h <- fieldOf "host" string p <- fieldOf "port" number return (h, p) user <- section "LOCAL" $ fieldMb "user" return (Config host port user) ~~~ This is unfortunately awkward and repetitive. An alternative is to flatten it out by repeating invocations of `section` like below, but this has its own problems, such as unnecessary repetition of the `"NETWORK"` string literal, unnecessarily repetitive lookups, and general verbosity: ~~~haskell configParser :: IniParser Config configParser = do host <- section "NETWORK" $ fieldOf "host" string port <- section "NETWORK" $ fieldOf "port" number user <- section "LOCAL" $ fieldMb "user" return (Config host port user) ~~~ In situations like these, you can instead use the `Data.Ini.Config.Bidir` module, which provides a slightly different abstraction: the functions exported by this module assume that you start with a default configuration value, and parsing a field allows you to _update_ that configuration with the value of a field. The monads exported by this module have an extra type parameter that represents the type of the value being updated. The easiest way to use this module is by combining lenses with the `.=` and `.=?` operators, which take a lens and a description of a field, and produce a `SectionSpec` value that uses the provided lens to update the underlying type when parsing: ~~~haskell makeLenses ''Config configParser :: IniSpec Config () configParser = do section "NETWORK" $ do cfHost .= field "host" string cfPort .= field "port" number section "LOCAL" $ do cfUser .=? field "user" ~~~ In order to use this as a parser, we will need to provide an existing value of `Config` so we can apply our updates to it. We combine the `IniSpec` defined above with a default config ~~~haskell configIni :: Ini Config configIni = let defConfig = Config "localhost" 8080 Nothing in ini defConfig configParser myParseIni :: Text -> Either String Config myParseIni t = fmap getIniValue (parseIni t configIni) ~~~ This approach gives us other advantages, too. Each of the defined fields can be associated with some various pieces of metadata, marking them as optional for the purpose of parsing or associating a comment with them. ~~~haskell configParser' :: IniSpec Config () configParser' = do section "NETWORK" $ do cfHost .= field "host" string & comment ["The desired hostname"] & optional cfPort .= field "port" number & comment ["The port for the server"] section "LOCAL" $ do cfUser .=? field "user" & comment ["The username"] ~~~ When we create an ini from this `IniSpec`, we can serialize it directly to get a "default" INI file, one which contains the supplied comments on each field. This is useful if our application wants to produce a default configuration from the same declarative specification as before. This approach also enables another, much more powerful feature: this enables us to perform a _diff-minimal update_. You'll notice that our `parseIni` function here doesn't give us back the value directly, but rather yet another `Ini` value from which we had to extract the value. This is because the `Ini` value also records incidental formatting choices of the input file: whitespace, comments, specifics of capitalization, and so forth. When we serialize an INI file that was returned by `parseIni`, we will get out _literally the same file_ that we put in, complete with incidental formatting choices retained. But we can also use that file and update it using the `updateIni` function: this takes a configuration value and a previous `Ini` value and builds a new `Ini` value such that as much structure as possible is retained from the original `Ini`. This means that if we parse a file, update a single field, and reserialize, that file should differ only in the field we changed _and that's it_: fields will stay in the same order (with new fields being added to the end of sections), comments will be retained, incidental whitespace will stay as it is. This is a useful tool if you're building an application that has both a human-readable configuration as well the ability to set configuration values from within the application itself. This will allow you to rewrite the configuration file while minimizing lossy changes to a possibly-hand-edited possibly-checked-into-git configuration file. ## Combinators and Conventions There are several variations on the same basic functionality that appear in `config-ini`. All functions that start with `section` are for parsing section-level chunks of an INI file, while all functions that start with `field` are for parsing key-value pairs within a section. Because it's reasonably common, there are also special `fieldFlag` functions which return `Bool` values, parsed in a relatively loose way. All functions which end in `Mb` return a `Maybe` value, returning `Nothing` if the section or key was not found. All functions which end in `Def` take an additional default value, returning it if the section or key was not found. All functions which contain `Of` take a function of the type `Text -> Either String a`, which is used to attempt to decode or parse the extracted value. In total, there are three section-level parsers (`section`, `sectionMb`, and `sectionDef`) and eight field-level parsers (`field`, `fieldOf`, `fieldMb`, `fieldMbOf`, `fieldDef`, `fieldDefOf`, `fieldFlag`, `fieldFlagDef`). For the `_Of` functions, `config-ini` also provides several built-in parser functions which provide nice error messages on failure. config-ini-0.2.7.0/config-ini.cabal0000644000000000000000000000645107346545000015105 0ustar0000000000000000name: config-ini version: 0.2.7.0 synopsis: A library for simple INI-based configuration files. homepage: https://github.com/aisamanra/config-ini bug-reports: https://github.com/aisamanra/config-ini/issues description: The @config-ini@ library is a set of small monadic languages for writing simple configuration languages with convenient, human-readable error messages. . > parseConfig :: IniParser (Text, Int, Bool) > parseConfig = section "NETWORK" $ do > user <- field "user" > port <- fieldOf "port" number > enc <- fieldFlagDef "encryption" True > return (user, port, enc) license: BSD3 license-file: LICENSE author: Getty Ritter maintainer: Getty Ritter copyright: ©2018 Getty Ritter category: Configuration build-type: Simple cabal-version: 1.18 tested-with: GHC == 8.8.4, GHC == 8.10.7, GHC == 9.0.2, GHC == 9.2.4, GHC == 9.4.2, GHC == 9.6.2, GHC == 9.8.1 extra-doc-files: README.md, CHANGELOG.md extra-source-files: test/prewritten/cases/*.hs, test/prewritten/cases/*.ini source-repository head type: git location: git://github.com/aisamanra/config-ini.git flag enable-doctests description: Build doctest modules as well (can be finicky) default: False library hs-source-dirs: src exposed-modules: Data.Ini.Config , Data.Ini.Config.Bidir , Data.Ini.Config.Raw ghc-options: -Wall if impl(ghc > 8.0) ghc-options: -fno-warn-redundant-constraints build-depends: base >=4.8 && <5 , containers >=0.5 && <0.7 , text >=1.2.2 && <3 , unordered-containers >=0.2.7 && <0.5 , transformers >=0.4.1 && <0.7 , megaparsec >=7 && <10 default-language: Haskell2010 test-suite test-ini-compat type: exitcode-stdio-1.0 ghc-options: -Wall -threaded default-language: Haskell2010 hs-source-dirs: test/ini-compat main-is: Main.hs build-depends: base , ini >=0.4 , config-ini , hedgehog , containers , unordered-containers , text test-suite test-prewritten type: exitcode-stdio-1.0 ghc-options: -Wall default-language: Haskell2010 hs-source-dirs: test/prewritten main-is: Main.hs build-depends: base , config-ini , containers , unordered-containers , text , directory test-suite test-doctest if impl(ghc < 7.10) || !flag(enable-doctests) buildable: False type: exitcode-stdio-1.0 ghc-options: -Wall default-language: Haskell2010 hs-source-dirs: test/doctest main-is: Main.hs build-depends: base , doctest , microlens , text config-ini-0.2.7.0/src/Data/Ini/0000755000000000000000000000000007346545000014250 5ustar0000000000000000config-ini-0.2.7.0/src/Data/Ini/Config.hs0000644000000000000000000004525107346545000016020 0ustar0000000000000000{-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} -- | -- Module : Data.Ini.Config -- Copyright : (c) Getty Ritter, 2017 -- License : BSD -- Maintainer : Getty Ritter -- Stability : experimental -- -- 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"})}) module Data.Ini.Config ( -- * Parsing Files parseIniFile, -- * Parser Types IniParser, SectionParser, -- * Section-Level Parsing section, sections, sectionOf, sectionsOf, sectionMb, sectionDef, -- * Field-Level Parsing field, fieldOf, fieldMb, fieldMbOf, fieldDef, fieldDefOf, fieldFlag, fieldFlagDef, -- * Reader Functions readable, number, string, flag, listWithSeparator, ) where import Control.Applicative (Alternative (..)) import Control.Monad.Trans.Except import Data.Ini.Config.Raw import Data.Sequence (Seq) import qualified Data.Sequence as Seq import Data.String (IsString (..)) import Data.Text (Text) import qualified Data.Text as T import Data.Typeable (Proxy (..), Typeable, typeRep) import GHC.Exts (IsList (..)) import Text.Read (readMaybe) lkp :: NormalizedText -> Seq (NormalizedText, a) -> Maybe a lkp t = go . Seq.viewl where go ((t', x) Seq.:< rs) | t == t' = Just x | otherwise = go (Seq.viewl rs) go Seq.EmptyL = Nothing addLineInformation :: Int -> Text -> StParser s a -> StParser s a addLineInformation lineNo sec = withExceptT go where go e = "Line " ++ show lineNo ++ ", in section " ++ show sec ++ ": " ++ e type StParser s a = ExceptT String ((->) s) a -- | An 'IniParser' value represents a computation for parsing entire -- INI-format files. newtype IniParser a = IniParser (StParser RawIni a) deriving (Functor, Applicative, Alternative, Monad) -- | A 'SectionParser' value represents a computation for parsing a single -- section of an INI-format file. newtype SectionParser a = SectionParser (StParser IniSection a) deriving (Functor, Applicative, Alternative, Monad) -- | Parse a 'Text' value as an INI file and run an 'IniParser' over it parseIniFile :: Text -> IniParser a -> Either String a parseIniFile text (IniParser mote) = do ini <- parseRawIni text runExceptT mote ini -- | 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\"" section :: Text -> SectionParser a -> IniParser a section name (SectionParser thunk) = IniParser $ ExceptT $ \(RawIni ini) -> case lkp (normalize name) ini of Nothing -> Left ("No top-level section named " ++ show name) Just sec -> runExceptT thunk sec -- | Find multiple named sections in the INI file and parse them all -- with the provided section parser. In order to support classic INI -- files with capitalized section names, section lookup is -- __case-insensitive__. -- -- >>> parseIniFile "[ONE]\nx = hello\n[ONE]\nx = goodbye\n" $ sections "ONE" (field "x") -- Right (fromList ["hello","goodbye"]) -- >>> parseIniFile "[ONE]\nx = hello\n" $ sections "TWO" (field "x") -- Right (fromList []) sections :: Text -> SectionParser a -> IniParser (Seq a) sections name (SectionParser thunk) = IniParser $ ExceptT $ \(RawIni ini) -> let name' = normalize name in mapM (runExceptT thunk . snd) (Seq.filter (\(t, _) -> t == name') ini) -- | A call to @sectionOf f@ will apply @f@ to each section name and, -- if @f@ produces a "Just" value, pass the extracted value in order -- to get the "SectionParser" to use for that section. This will -- find at most one section, and will produce an error if no section -- exists. -- -- >>> parseIniFile "[FOO]\nx = hello\n" $ sectionOf (T.stripSuffix "OO") (\ l -> fmap ((,) l) (field "x")) -- Right ("F","hello") -- >>> parseIniFile "[BAR]\nx = hello\n" $ sectionOf (T.stripSuffix "OO") (\ l -> fmap ((,) l) (field "x")) -- Left "No matching top-level section" sectionOf :: (Text -> Maybe b) -> (b -> SectionParser a) -> IniParser a sectionOf fn sectionParser = IniParser $ ExceptT $ \(RawIni ini) -> let go Seq.EmptyL = Left "No matching top-level section" go ((t, sec) Seq.:< rs) | Just v <- fn (actualText t) = let SectionParser thunk = sectionParser v in runExceptT thunk sec | otherwise = go (Seq.viewl rs) in go (Seq.viewl ini) -- | A call to @sectionsOf f@ will apply @f@ to each section name and, -- if @f@ produces a @Just@ value, pass the extracted value in order -- to get the "SectionParser" to use for that section. This will -- return every section for which the call to @f@ produces a "Just" -- value. -- -- >>> parseIniFile "[FOO]\nx = hello\n[BOO]\nx = goodbye\n" $ sectionsOf (T.stripSuffix "OO") (\ l -> fmap ((,) l) (field "x")) -- Right (fromList [("F","hello"),("B","goodbye")]) -- >>> parseIniFile "[BAR]\nx = hello\n" $ sectionsOf (T.stripSuffix "OO") (\ l -> fmap ((,) l) (field "x")) -- Right (fromList []) sectionsOf :: (Text -> Maybe b) -> (b -> SectionParser a) -> IniParser (Seq a) sectionsOf fn sectionParser = IniParser $ ExceptT $ \(RawIni ini) -> let go Seq.EmptyL = return Seq.empty go ((t, sec) Seq.:< rs) | Just v <- fn (actualText t) = let SectionParser thunk = sectionParser v in do x <- runExceptT thunk sec xs <- go (Seq.viewl rs) return (x Seq.<| xs) | otherwise = go (Seq.viewl rs) in go (Seq.viewl ini) -- | 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 sectionMb :: Text -> SectionParser a -> IniParser (Maybe a) sectionMb name (SectionParser thunk) = IniParser $ ExceptT $ \(RawIni ini) -> case lkp (normalize name) ini of Nothing -> return Nothing Just sec -> Just `fmap` runExceptT thunk sec -- | 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" sectionDef :: Text -> a -> SectionParser a -> IniParser a sectionDef name def (SectionParser thunk) = IniParser $ ExceptT $ \(RawIni ini) -> case lkp (normalize name) ini of Nothing -> return def Just sec -> runExceptT thunk sec --- throw :: String -> StParser s a throw msg = ExceptT (\_ -> Left msg) getSectionName :: StParser IniSection Text getSectionName = ExceptT (return . isName) rawFieldMb :: Text -> StParser IniSection (Maybe IniValue) rawFieldMb name = ExceptT $ \m -> return (lkp (normalize name) (isVals m)) rawField :: Text -> StParser IniSection IniValue rawField name = do sec <- getSectionName valMb <- rawFieldMb name case valMb of Nothing -> throw ( "Missing field " ++ show name ++ " in section " ++ show sec ) Just x -> return x getVal :: IniValue -> Text getVal = T.strip . vValue -- | 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\"" field :: Text -> SectionParser Text field name = SectionParser $ getVal `fmap` rawField name -- | 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\"" fieldOf :: Text -> (Text -> Either String a) -> SectionParser a fieldOf name parse = SectionParser $ do sec <- getSectionName val <- rawField name case parse (getVal val) of Left err -> addLineInformation (vLineNo val) sec (throw err) Right x -> return x -- | 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 fieldMb :: Text -> SectionParser (Maybe Text) fieldMb name = SectionParser $ fmap getVal `fmap` rawFieldMb name -- | 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 fieldMbOf :: Text -> (Text -> Either String a) -> SectionParser (Maybe a) fieldMbOf name parse = SectionParser $ do sec <- getSectionName mb <- rawFieldMb name case mb of Nothing -> return Nothing Just v -> case parse (getVal v) of Left err -> addLineInformation (vLineNo v) sec (throw err) Right x -> return (Just x) -- | 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" fieldDef :: Text -> Text -> SectionParser Text fieldDef name def = SectionParser $ ExceptT $ \m -> case lkp (normalize name) (isVals m) of Nothing -> return def Just x -> return (getVal x) -- | 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 fieldDefOf :: Text -> (Text -> Either String a) -> a -> SectionParser a fieldDefOf name parse def = SectionParser $ do sec <- getSectionName mb <- rawFieldMb name case mb of Nothing -> return def Just v -> case parse (getVal v) of Left err -> addLineInformation (vLineNo v) sec (throw err) Right x -> return x -- | 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\"" fieldFlag :: Text -> SectionParser Bool fieldFlag name = fieldOf name flag -- | 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 fieldFlagDef :: Text -> Bool -> SectionParser Bool fieldFlagDef name = fieldDefOf name flag --- -- | 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)" readable :: forall a. (Read a, Typeable a) => Text -> Either String a readable t = case readMaybe str of Just v -> Right v Nothing -> Left ( "Unable to parse " ++ show str ++ " as a value of type " ++ show typ ) where str = T.unpack t typ = typeRep prx prx :: Proxy a prx = Proxy -- | 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" number :: (Num a, Read a, Typeable a) => Text -> Either String a number = readable -- | Convert a textual value to the appropriate string type. This will -- never fail. -- -- >>> string "foo" :: Either String String -- Right "foo" string :: (IsString a) => Text -> Either String a string = return . fromString . T.unpack -- | 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" flag :: Text -> Either String Bool flag s = case T.toLower s of "true" -> Right True "yes" -> Right True "t" -> Right True "y" -> Right True "false" -> Right False "no" -> Right False "f" -> Right False "n" -> Right False _ -> Left ("Unable to parse " ++ show s ++ " as a boolean") -- | Convert a reader for a value into a reader for a list of those -- values, separated by a chosen separator. This will split apart -- the string on that separator, get rid of leading and trailing -- whitespace on the individual chunks, and then attempt to parse -- each of them according to the function provided, turning the -- result into a list. -- -- This is overloaded with the "IsList" typeclass, so it can be -- used transparently to parse other list-like types. -- -- >>> listWithSeparator "," number "2, 3, 4" :: Either String [Int] -- Right [2,3,4] -- >>> listWithSeparator " " number "7 8 9" :: Either String [Int] -- Right [7,8,9] -- >>> listWithSeparator ":" string "/bin:/usr/bin" :: Either String [FilePath] -- Right ["/bin","/usr/bin"] -- >>> listWithSeparator "," number "7 8 9" :: Either String [Int] -- Left "Unable to parse \"7 8 9\" as a value of type Int" listWithSeparator :: (IsList l) => Text -> (Text -> Either String (Item l)) -> Text -> Either String l listWithSeparator sep rd = fmap fromList . mapM (rd . T.strip) . T.splitOn sep -- $setup -- -- >>> :{ -- data NetworkConfig = NetworkConfig -- { netHost :: String, netPort :: Int } -- deriving (Eq, Show) -- >>> :} -- -- >>> :{ -- data LocalConfig = LocalConfig -- { localUser :: Text } -- deriving (Eq, Show) -- >>> :} -- -- >>> :{ -- data Config = Config -- { cfNetwork :: NetworkConfig, cfLocal :: Maybe LocalConfig } -- deriving (Eq, Show) -- >>> :} -- -- >>> :{ -- let 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 } -- >>> :} -- -- >>> :{ -- let example = "[NETWORK]\nhost = example.com\nport = 7878\n\n# here is a comment\n[LOCAL]\nuser = terry\n" -- >>> :} config-ini-0.2.7.0/src/Data/Ini/Config/0000755000000000000000000000000007346545000015455 5ustar0000000000000000config-ini-0.2.7.0/src/Data/Ini/Config/Bidir.hs0000644000000000000000000010702107346545000017043 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE ExistentialQuantification #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} -- | -- Module : Data.Ini.Config.Bidir -- Copyright : (c) Getty Ritter, 2017 -- License : BSD -- Maintainer : Getty Ritter -- Stability : experimental -- -- This module presents an alternate API for parsing INI files. Unlike -- the standard API, it is bidirectional: the same declarative structure -- can be used to parse an INI file to a value, serialize an INI file -- from a value, or even /update/ an INI file by comparing it against a -- value and serializing in a way that minimizes the differences between -- revisions of the file. -- -- This API does make some extra assumptions about your configuration -- type and the way you interact with it: in particular, it assumes that -- you have lenses for all the fields you're parsing and that you have -- some kind of sensible default value of that configuration -- type. Instead of providing combinators which can extract and parse a -- field of an INI file into a value, the bidirectional API allows you to -- declaratively associate a lens into your structure with a field of the -- INI file. -- -- Consider the following example INI file: -- -- > [NETWORK] -- > host = example.com -- > port = 7878 -- > -- > [LOCAL] -- > user = terry -- -- We'd like to parse this INI file into a @Config@ type which we've -- defined like this, using -- or a similar library -- to provide lenses: -- -- > data Config = Config -- > { _cfHost :: String -- > , _cfPort :: Int -- > , _cfUser :: Maybe Text -- > } deriving (Eq, Show) -- > -- > ''makeLenses Config -- -- We can now define a basic specification of the type @'IniSpec' Config -- ()@ by using the provided operations to declare our top-level -- sections, and then within those sections we can associate fields with -- @Config@ lenses. -- -- @ -- 'configSpec' :: 'IniSpec' Config () -- 'configSpec' = do -- 'section' \"NETWORK\" $ do -- cfHost '.=' 'field' \"host\" 'string' -- cfPost '.=' 'field' \"port\" 'number' -- 'sectionOpt' \"LOCAL\" $ do -- cfUser '.=?' 'field' \"user\" 'text' -- @ -- -- There are two operators used to associate lenses with fields: -- -- ['.='] Associates a lens of type @Lens' s a@ with a field description -- of type @FieldDescription a@. By default, this will raise an -- error when parsing if the field described is missing, but we -- can mark it as optional, as we'll see. -- -- ['.=?'] Associates a lens of type @Lens' s (Maybe a)@ with a field -- description of type @FieldDescription a@. During parsing, if -- the value does not appear in an INI file, then the lens will -- be set to 'Nothing'; similarly, during serializing, if the -- value is 'Nothing', then the field will not be serialized in -- the file. -- -- Each field must include the field's name as well as a 'FieldValue', -- which describes how to both parse and serialize a value of a given -- type. Several built-in 'FieldValue' descriptions are provided, but you -- can always build your own by providing parsing and serialization -- functions for individual fields. -- -- We can also provide extra metadata about a field, allowing it to be -- skipped durin parsing, or to provide an explicit default value, or to -- include an explanatory comment for that value to be used when we -- serialize an INI file. These are conventionally applied to the field -- using the '&' operator: -- -- @ -- configSpec :: 'IniSpec' Config () -- configSpec = do -- 'section' \"NETWORK\" $ do -- cfHost '.=' 'field' \"host\" 'string' -- & 'comment' [\"The desired hostname (optional)\"] -- & 'optional' -- cfPost '.=' 'field' \"port\" 'number' -- & 'comment' [\"The port number\"] -- 'sectionOpt' \"LOCAL\" $ do -- cfUser '.=?' 'field' \"user\" 'text' -- @ -- -- When we want to use this specification, we need to create a value of -- type 'Ini', which is an abstract representation of an INI -- specification. To create an 'Ini' value, we need to use the 'ini' -- function, which combines the spec with the default version of our -- configuration value. -- -- Once we have a value of type 'Ini', we can use it for three basic -- operations: -- -- * We can parse a textual INI file with 'parseIni', which will -- systematically walk the spec and use the provided lens/field -- associations to create a parsed configuration file. This will give -- us a new value of type 'Ini' that represents the parsed -- configuration, and we can extract the actual configuration value -- with 'getIniValue'. -- -- * We can update the value contained in an 'Ini' value. If the 'Ini' -- value is the result of a previous call to 'parseIni', then this -- update will attempt to retain as much of the incidental structure of -- the parsed file as it can: for example, it will attempt to retain -- comments, whitespace, and ordering. The general strategy is to make -- the resulting INI file "diff-minimal": the diff between the older -- INI file and the updated INI file should contain as little noise as -- possible. Small cosmetic choices such as how to treat generated -- comments are controlled by a configurable 'UpdatePolicy' value. -- -- * We can serialize an 'Ini' value to a textual INI file. This will -- produce the specified INI file (either a default fresh INI, or a -- modified existing INI) as a textual value. module Data.Ini.Config.Bidir ( -- * Parsing, Serializing, and Updating Files -- $using Ini, ini, getIniValue, iniValueL, getRawIni, -- ** Parsing INI files parseIni, -- ** Serializing INI files serializeIni, -- ** Updating INI Files updateIni, setIniUpdatePolicy, UpdatePolicy (..), UpdateCommentPolicy (..), defaultUpdatePolicy, -- * Bidirectional Parser Types -- $types IniSpec, SectionSpec, -- * Section-Level Parsing -- $sections section, allOptional, -- * Field-Level Parsing -- $fields FieldDescription, (.=), (.=?), field, flag, comment, placeholderValue, optional, -- * FieldValues -- $fieldvalues FieldValue (..), text, string, number, bool, readable, listWithSeparator, pairWithSeparator, -- * Miscellaneous Helpers -- $misc (&), Lens, ) where import Control.Monad.Trans.State.Strict (State, modify, runState) import qualified Control.Monad.Trans.State.Strict as State import qualified Data.Foldable as F #if __GLASGOW_HASKELL__ >= 710 import Data.Function ((&)) #endif import Data.Ini.Config.Raw import Data.Monoid ((<>)) import Data.Sequence (Seq, ViewL (..), ViewR (..), (<|)) import qualified Data.Sequence as Seq import Data.Text (Text) import qualified Data.Text as T import qualified Data.Traversable as F import Data.Typeable (Proxy (..), Typeable, typeRep) import GHC.Exts (IsList (..)) import Text.Read (readMaybe) -- * Utility functions + lens stuffs -- | This is a -- -compatible -- type alias type Lens s t a b = forall f. Functor f => (a -> f b) -> s -> f t -- These are some inline reimplementations of "lens" operators. We -- need the identity functor to implement 'set': newtype I a = I {fromI :: a} instance Functor I where fmap f (I x) = I (f x) set :: Lens s t a b -> b -> s -> t set lns x a = fromI (lns (const (I x)) a) -- ... and we need the const functor to implement 'get': newtype C a b = C {fromC :: a} instance Functor (C a) where fmap _ (C x) = C x get :: Lens s t a b -> s -> a get lns a = fromC (lns C a) lkp :: NormalizedText -> Seq (NormalizedText, a) -> Maybe a lkp t = fmap snd . F.find (\(t', _) -> t' == t) rmv :: NormalizedText -> Seq (Field s) -> Seq (Field s) rmv n = Seq.filter (\f -> fieldName f /= n) -- The & operator is really useful here, but it didn't show up in -- earlier versions, so it gets redefined here. #if __GLASGOW_HASKELL__ < 710 {- | '&' is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator '$', which allows '&' to be nested in '$'. -} (&) :: a -> (a -> b) -> b a & f = f a infixl 1 & #endif -- * The 'Ini' type -- | An 'Ini' is an abstract representation of an INI file, including -- both its textual representation and the Haskell value it -- represents. data Ini s = Ini { iniSpec :: Spec s, iniCurr :: s, iniDef :: s, iniLast :: Maybe RawIni, iniPol :: UpdatePolicy } -- | Create a basic 'Ini' value from a default value and a spec. ini :: s -> IniSpec s () -> Ini s ini def (IniSpec spec) = Ini { iniSpec = runBidirM spec, iniCurr = def, iniDef = def, iniLast = Nothing, iniPol = defaultUpdatePolicy } -- | Get the underlying Haskell value associated with the 'Ini'. getIniValue :: Ini s -> s getIniValue = iniCurr mkLens :: (a -> b) -> (b -> a -> a) -> Lens a a b b mkLens get' set' f a = (`set'` a) `fmap` f (get' a) -- | The lens equivalent of 'getIniValue' iniValueL :: Lens (Ini s) (Ini s) s s iniValueL = mkLens iniCurr (\i v -> v {iniCurr = i}) -- | Get the textual representation of an 'Ini' value. If this 'Ini' -- value is the result of 'parseIni', then it will attempt to retain -- the textual characteristics of the parsed version as much as -- possible (e.g. by retaining comments, ordering, and whitespace in a -- way that will minimize the overall diff footprint.) If the 'Ini' -- value was created directly from a value and a specification, then -- it will pretty-print an initial version of the file with the -- comments and placeholder text specified in the spec. serializeIni :: Ini s -> Text serializeIni = printRawIni . getRawIni -- | Get the underlying 'RawIni' value for the file. getRawIni :: Ini s -> RawIni getRawIni Ini {iniLast = Just raw} = raw getRawIni Ini { iniCurr = s, iniSpec = spec } = emitIniFile s spec -- | Parse a textual representation of an 'Ini' file. If the file is -- malformed or if an obligatory field is not found, this will produce -- a human-readable error message. If an optional field is not found, -- then it will fall back on the existing value contained in the -- provided 'Ini' structure. parseIni :: Text -> Ini s -> Either String (Ini s) parseIni t i@Ini { iniSpec = spec, iniCurr = def } = do RawIni raw <- parseRawIni t s <- parseSections def (Seq.viewl spec) raw return $ i { iniCurr = s, iniLast = Just (RawIni raw) } -- | Update the internal value of an 'Ini' file. If this 'Ini' value -- is the result of 'parseIni', then the resulting 'Ini' value will -- attempt to retain the textual characteristics of the parsed version -- as much as possible (e.g. by retaining comments, ordering, and -- whitespace in a way that will minimize the overall diff footprint.) updateIni :: s -> Ini s -> Ini s updateIni new i = case doUpdateIni new i of Left err -> error err Right i' -> i' -- | Use the provided 'UpdatePolicy' as a guide when creating future -- updated versions of the given 'Ini' value. setIniUpdatePolicy :: UpdatePolicy -> Ini s -> Ini s setIniUpdatePolicy pol i = i {iniPol = pol} -- * Type definitions -- | A value of type 'FieldValue' packages up a parser and emitter -- function into a single value. These are used for bidirectional -- parsing and emitting of the value of a field. data FieldValue a = FieldValue { -- | The function to use when parsing the value of a field; if -- the parser fails, then the string will be shown as an error -- message to the user. fvParse :: Text -> Either String a, -- | The function to use when serializing a value into an INI -- file. fvEmit :: a -> Text } -- This is actually being used as a writer monad, but using a state -- monad lets us avoid the space leaks. Not that those are likely to -- be a problem in this application, but it's not like it cost us -- none. type BidirM s a = State (Seq s) a runBidirM :: BidirM s a -> Seq s runBidirM = snd . flip runState Seq.empty type Spec s = Seq (Section s) -- | An 'IniSpec' value represents the structure of an entire -- INI-format file in a declarative way. The @s@ parameter represents -- the type of a Haskell structure which is being serialized to or -- from. newtype IniSpec s a = IniSpec (BidirM (Section s) a) deriving (Functor, Applicative, Monad) -- | A 'SectionSpec' value represents the structure of a single -- section of an INI-format file in a declarative way. The @s@ -- parameter represents the type of a Haskell structure which is being -- serialized to or from. newtype SectionSpec s a = SectionSpec (BidirM (Field s) a) deriving (Functor, Applicative, Monad) -- * Sections -- | Define the specification of a top-level INI section. section :: Text -> SectionSpec s () -> IniSpec s () section name (SectionSpec mote) = IniSpec $ do let fields = runBidirM mote modify (Seq.|> Section (normalize name) fields (allFieldsOptional fields)) allFieldsOptional :: Seq (Field s) -> Bool allFieldsOptional = all isOptional where isOptional (Field _ fd) = fdSkipIfMissing fd isOptional (FieldMb _ _) = True -- | Treat an entire section as containing entirely optional fields. allOptional :: (SectionSpec s () -> IniSpec s ()) -> (SectionSpec s () -> IniSpec s ()) allOptional k spec = IniSpec $ do let IniSpec comp = k spec comp modify ( \s -> case Seq.viewr s of EmptyR -> s rs :> Section name fields _ -> rs Seq.|> Section name (fmap makeOptional fields) True ) makeOptional :: Field s -> Field s makeOptional (Field l d) = Field l d {fdSkipIfMissing = True} makeOptional (FieldMb l d) = FieldMb l d {fdSkipIfMissing = True} data Section s = Section NormalizedText (Seq (Field s)) Bool -- * Fields -- | A "Field" is a description of data Field s = forall a. Eq a => Field (Lens s s a a) (FieldDescription a) | forall a. Eq a => FieldMb (Lens s s (Maybe a) (Maybe a)) (FieldDescription a) -- convenience accessors for things in a Field fieldName :: Field s -> NormalizedText fieldName (Field _ FieldDescription {fdName = n}) = n fieldName (FieldMb _ FieldDescription {fdName = n}) = n fieldComment :: Field s -> Seq Text fieldComment (Field _ FieldDescription {fdComment = n}) = n fieldComment (FieldMb _ FieldDescription {fdComment = n}) = n -- | A 'FieldDescription' is a declarative representation of the -- structure of a field. This includes the name of the field and the -- 'FieldValue' used to parse and serialize values of that field, as -- well as other metadata that might be needed in the course of -- parsing or serializing a structure. data FieldDescription t = FieldDescription { fdName :: NormalizedText, fdValue :: FieldValue t, fdComment :: Seq Text, fdDummy :: Maybe Text, fdSkipIfMissing :: Bool } -- ** Field operators -- | -- Associate a field description with a field. If this field -- is not present when parsing, it will attempt to fall back -- on a default, and if no default value is present, it will -- fail to parse. -- -- When serializing an INI file, this will produce all the -- comments associated with the field description followed -- by the value of the field in the. (.=) :: Eq t => Lens s s t t -> FieldDescription t -> SectionSpec s () l .= f = SectionSpec $ modify (Seq.|> fd) where fd = Field l f -- | -- Associate a field description with a field of type "Maybe a". -- When parsing, this field will be initialized to "Nothing" if -- it is not found, and to a "Just" value if it is. When -- serializing an INI file, this will try to serialize a value (.=?) :: Eq t => Lens s s (Maybe t) (Maybe t) -> FieldDescription t -> SectionSpec s () l .=? f = SectionSpec $ modify (Seq.|> fd) where fd = FieldMb l f -- ** Field metadata -- | -- Associate a multiline comment with a "FieldDescription". When -- serializing a field that has a comment associated, the comment will -- appear before the field. comment :: [Text] -> FieldDescription t -> FieldDescription t comment cmt fd = fd {fdComment = Seq.fromList cmt} -- | Choose a placeholder value to be displayed for optional fields. -- This is used when serializing an optional Ini field: the -- field will appear commented out in the output using the -- placeholder text as a value, so a spec that includes -- -- @ -- myLens .=? field "x" & placeholderValue "\" -- @ -- -- will serialize into an INI file that contains the line -- -- @ -- # x = \ -- @ -- -- A placeholder value will only appear in the serialized output if -- the field is optional, but will be preferred over serializing the -- default value for an optional field. This will not affect INI -- file updates. placeholderValue :: Text -> FieldDescription t -> FieldDescription t placeholderValue t fd = fd {fdDummy = Just t} -- | If the field is not found in parsing, simply skip instead of -- raising an error or setting anything. optional :: FieldDescription t -> FieldDescription t optional fd = fd {fdSkipIfMissing = True} infixr 0 .= infixr 0 .=? -- ** Creating fields -- | Create a description of a field by a combination of the name of -- the field and a "FieldValue" describing how to parse and emit -- values associated with that field. field :: Text -> FieldValue a -> FieldDescription a field name value = FieldDescription { fdName = normalize (name <> " "), fdValue = value, fdComment = Seq.empty, fdDummy = Nothing, fdSkipIfMissing = False } -- | Create a description of a 'Bool'-valued field. flag :: Text -> FieldDescription Bool flag name = field name bool -- ** FieldValues -- | A "FieldValue" for parsing and serializing values according to -- the logic of the "Read" and "Show" instances for that type, -- providing a convenient human-readable error message if the -- parsing step fails. readable :: forall a. (Show a, Read a, Typeable a) => FieldValue a readable = FieldValue {fvParse = parse, fvEmit = emit} where emit = T.pack . show parse t = case readMaybe (T.unpack t) of Just v -> Right v Nothing -> Left ( "Unable to parse " ++ show t ++ " as a value of type " ++ show typ ) typ = typeRep prx prx :: Proxy a prx = Proxy -- | Represents a numeric field whose value is parsed according to the -- 'Read' implementation for that type, and is serialized according to -- the 'Show' implementation for that type. number :: (Show a, Read a, Num a, Typeable a) => FieldValue a number = readable -- | Represents a field whose value is a 'Text' value text :: FieldValue Text text = FieldValue {fvParse = Right, fvEmit = id} -- | Represents a field whose value is a 'String' value string :: FieldValue String string = FieldValue {fvParse = Right . T.unpack, fvEmit = T.pack} -- | Represents a field whose value is a 'Bool' value. This parser is -- case-insensitive, and matches the words @true@, @false@, @yes@, and -- @no@, as well as single-letter abbreviations for all of the -- above. This will serialize as @true@ for 'True' and @false@ for -- 'False'. bool :: FieldValue Bool bool = FieldValue {fvParse = parse, fvEmit = emit} where parse s = case T.toLower s of "true" -> Right True "yes" -> Right True "t" -> Right True "y" -> Right True "false" -> Right False "no" -> Right False "f" -> Right False "n" -> Right False _ -> Left ("Unable to parse " ++ show s ++ " as a boolean") emit True = "true" emit False = "false" -- | Represents a field whose value is a sequence of other values -- which are delimited by a given string, and whose individual values -- are described by another 'FieldValue' value. This uses GHC's -- `IsList` typeclass to convert back and forth between sequence -- types. listWithSeparator :: IsList l => Text -> FieldValue (Item l) -> FieldValue l listWithSeparator sep fv = FieldValue { fvParse = fmap fromList . mapM (fvParse fv . T.strip) . T.splitOn sep, fvEmit = T.intercalate sep . map (fvEmit fv) . toList } -- | Represents a field whose value is a pair of two other values -- separated by a given string, whose individual values are described -- by two different 'FieldValue' values. pairWithSeparator :: FieldValue l -> Text -> FieldValue r -> FieldValue (l, r) pairWithSeparator left sep right = FieldValue { fvParse = \t -> let (leftChunk, rightChunk) = T.breakOn sep t in do x <- fvParse left leftChunk y <- fvParse right rightChunk return (x, y), fvEmit = \(x, y) -> fvEmit left x <> sep <> fvEmit right y } -- * Parsing INI files -- Are you reading this source code? It's not even that gross -- yet. Just you wait. This is just the regular part. 'runSpec' is -- easy: we walk the spec, and for each section, find the -- corresponding section in the INI file and call runFields. parseSections :: s -> Seq.ViewL (Section s) -> Seq (NormalizedText, IniSection) -> Either String s parseSections s Seq.EmptyL _ = Right s parseSections s (Section name fs opt Seq.:< rest) i | Just v <- lkp name i = do s' <- parseFields s (Seq.viewl fs) v parseSections s' (Seq.viewl rest) i | opt = parseSections s (Seq.viewl rest) i | otherwise = Left ( "Unable to find section " ++ show (normalizedText name) ) -- Now that we've got 'set', we can walk the field descriptions and -- find them. There's some fiddly logic, but the high-level idea is -- that we try to look up a field, and if it exists, parse it using -- the provided parser and use the provided lens to add it to the -- value. We have to decide what to do if it's not there, which -- depends on lens metadata and whether it's an optional field or not. parseFields :: s -> Seq.ViewL (Field s) -> IniSection -> Either String s parseFields s Seq.EmptyL _ = Right s parseFields s (Field l descr Seq.:< fs) sect | Just v <- lkp (fdName descr) (isVals sect) = do value <- fvParse (fdValue descr) (T.strip (vValue v)) parseFields (set l value s) (Seq.viewl fs) sect | fdSkipIfMissing descr = parseFields s (Seq.viewl fs) sect | otherwise = Left ( "Unable to find field " ++ show (normalizedText (fdName descr)) ) parseFields s (FieldMb l descr Seq.:< fs) sect | Just v <- lkp (fdName descr) (isVals sect) = do value <- fvParse (fdValue descr) (T.strip (vValue v)) parseFields (set l (Just value) s) (Seq.viewl fs) sect | otherwise = parseFields (set l Nothing s) (Seq.viewl fs) sect -- | Serialize a value as an INI file according to a provided -- 'IniSpec'. emitIniFile :: s -> Spec s -> RawIni emitIniFile s spec = RawIni $ fmap ( \(Section name fs _) -> (name, toSection s (actualText name) fs) ) spec mkComments :: Seq Text -> Seq BlankLine mkComments = fmap (\ln -> CommentLine '#' (" " <> ln)) toSection :: s -> Text -> Seq (Field s) -> IniSection toSection s name fs = IniSection { isName = name, isVals = fmap toVal fs, isStartLine = 0, isEndLine = 0, isComments = Seq.empty } where mkIniValue val descr opt = ( fdName descr, IniValue { vLineNo = 0, vName = actualText (fdName descr), vValue = " " <> val, vComments = mkComments (fdComment descr), vCommentedOut = opt, vDelimiter = '=' } ) toVal (Field l descr) | Just dummy <- fdDummy descr = mkIniValue dummy descr False | otherwise = mkIniValue (fvEmit (fdValue descr) (get l s)) descr False toVal (FieldMb l descr) | Just dummy <- fdDummy descr = mkIniValue dummy descr True | Just v <- get l s = mkIniValue (fvEmit (fdValue descr) v) descr True | otherwise = mkIniValue "" descr True -- | An 'UpdatePolicy' guides certain choices made when an 'Ini' file -- is updated: for example, how to add comments to the generated -- fields, or how to treat fields which are optional. data UpdatePolicy = UpdatePolicy { -- | If 'True', then optional fields not included in the INI file -- will be included in the updated INI file. Defaults to 'False'. updateAddOptionalFields :: Bool, -- | If 'True', then fields in the INI file that have no -- corresponding description in the 'IniSpec' will be ignored; if -- 'False', then those fields will return an error value. Defaults -- to 'True'. updateIgnoreExtraneousFields :: Bool, -- | The policy for what to do to comments associated with -- modified fields during an update. Defaults to -- 'CommentPolicyNone'. updateGeneratedCommentPolicy :: UpdateCommentPolicy } deriving (Eq, Show) -- | A set of sensible 'UpdatePolicy' defaults which keep the diffs -- between file versions minimal. defaultUpdatePolicy :: UpdatePolicy defaultUpdatePolicy = UpdatePolicy { updateAddOptionalFields = False, updateIgnoreExtraneousFields = True, updateGeneratedCommentPolicy = CommentPolicyNone } -- | An 'UpdateCommentPolicy' describes what comments should accompany -- a field added to or modified in an existing INI file when using -- 'updateIni'. data UpdateCommentPolicy = -- | Do not add comments to new fields CommentPolicyNone | -- | Add the same comment which appears in the 'IniSpec' value for -- the field we're adding or modifying. CommentPolicyAddFieldComment | -- | Add a common comment to all new fields added or modified -- by an 'updateIni' call. CommentPolicyAddDefaultComment (Seq Text) deriving (Eq, Show) getComments :: FieldDescription s -> UpdateCommentPolicy -> Seq BlankLine getComments _ CommentPolicyNone = Seq.empty getComments f CommentPolicyAddFieldComment = mkComments (fdComment f) getComments _ (CommentPolicyAddDefaultComment cs) = mkComments cs -- | Given a value, an 'IniSpec', and a 'Text' form of an INI file, -- parse 'Text' as INI and then selectively modify the file whenever -- the provided value differs from the file. This is designed to help -- applications update a user's configuration automatically while -- retaining the structure and comments of a user's application, -- ideally in a way which produces as few changes as possible to the -- resulting file (so that, for example, the diff between the two -- should be as small as possible.) -- -- A field is considered to have "changed" if the parsed -- representation of the field as extracted from the textual INI file -- is not equal to the corresponding value in the provided -- structure. Changed fields will retain their place in the overall -- file, while newly added fields (for example, fields which have -- been changed from a default value) will be added to the end of the -- section in which they appear. -- doUpdateIni :: s -> s -> Spec s -> RawIni -> UpdatePolicy -> Either String (Ini s) doUpdateIni :: s -> Ini s -> Either String (Ini s) doUpdateIni s i@Ini { iniSpec = spec, iniDef = def, iniPol = pol } = do -- spec (RawIni ini) pol = do let RawIni ini' = getRawIni i res <- updateSections s def ini' spec pol return $ i { iniCurr = s, iniLast = Just (RawIni res) } updateSections :: s -> s -> Seq (NormalizedText, IniSection) -> Seq (Section s) -> UpdatePolicy -> Either String (Seq (NormalizedText, IniSection)) updateSections s def sections fields pol = do -- First, we process all the sections that actually appear in the -- INI file in order existingSections <- F.for sections $ \(name, sec) -> do let err = Left ("Unexpected top-level section: " ++ show name) Section _ spec _ <- maybe err Right (F.find (\(Section n _ _) -> n == name) fields) newVals <- updateFields s (isVals sec) spec pol return (name, sec {isVals = newVals}) -- And then let existingSectionNames = fmap fst existingSections newSections <- F.for fields $ \(Section nm spec _) -> if nm `elem` existingSectionNames then return mempty else let rs = emitNewFields s def spec pol in if Seq.null rs then return mempty else return $ Seq.singleton ( nm, IniSection (actualText nm) rs 0 0 mempty ) return (existingSections <> F.asum newSections) -- We won't emit a section if everything in the section is also -- missing emitNewFields :: s -> s -> Seq (Field s) -> UpdatePolicy -> Seq (NormalizedText, IniValue) emitNewFields s def fields pol = go (Seq.viewl fields) where go EmptyL = Seq.empty go (Field l d :< fs) -- If a field is not present but is also the same as the default, -- then we can safely omit it | get l s == get l def && not (updateAddOptionalFields pol) = go (Seq.viewl fs) -- otherwise, we should add it to the result | otherwise = let cs = getComments d (updateGeneratedCommentPolicy pol) new = ( fdName d, IniValue { vLineNo = 0, vName = actualText (fdName d), vValue = " " <> fvEmit (fdValue d) (get l s), vComments = cs, vCommentedOut = False, vDelimiter = '=' } ) in new <| go (Seq.viewl fs) go (FieldMb l d :< fs) = case get l s of Nothing -> go (Seq.viewl fs) Just v -> let cs = getComments d (updateGeneratedCommentPolicy pol) new = ( fdName d, IniValue { vLineNo = 0, vName = actualText (fdName d), vValue = fvEmit (fdValue d) v, vComments = cs, vCommentedOut = False, vDelimiter = '=' } ) in new <| go (Seq.viewl fs) updateFields :: s -> Seq (NormalizedText, IniValue) -> Seq (Field s) -> UpdatePolicy -> Either String (Seq (NormalizedText, IniValue)) updateFields s values fields pol = go (Seq.viewl values) fields where go ((t, val) :< vs) fs = -- For each field, we need to fetch the description of the -- field in the spec case F.find (\f -> fieldName f == t) fs of Just f@(Field l descr) -> -- if it does exist, then we need to find out whether -- the field has changed at all. We can do this with the -- provided lens, and check it against the INI file -- we've got. There's a minor complication: there's -- nothing that forces the user to provide the same INI -- file we originally parsed! One side-effect means that -- the parsed INI file might not actually have a valid -- field according to the field parser the user -- provides. In that case, we'll assume the field is -- outdated, and update it with the value in the -- provided structure. if Right (get l s) == fvParse (fdValue descr) (T.strip (vValue val)) then -- if the value in the INI file parses the same as -- the one in the structure we were passed, then it -- doesn't need any updating, and we keep going, -- removing the field from our list ((t, val) <|) `fmap` go (Seq.viewl vs) (rmv t fs) else -- otherwise, we've got a new updated value! Let's -- synthesize a new element, using our comment policy -- to comment it accordingly. (This pattern is -- partial, but we should never have a situation -- where it returns Nothing, because we already know -- that we've matched a Field!) let Just nv = mkValue t f (vDelimiter val) in ((t, nv) <|) `fmap` go (Seq.viewl vs) (rmv t fs) -- And we have to replicate the logic for the FieldMb -- case, because (as an existential) it doesn't really -- permit us usable abstractions here. See the previous -- comments for descriptions of the cases. Just f@(FieldMb l descr) -> let parsed = fvParse (fdValue descr) (T.strip (vValue val)) in if Right (get l s) == fmap Just parsed then ((t, val) <|) `fmap` go (Seq.viewl vs) (rmv t fs) else -- this is in the only case where the FieldMb case -- differs: we might NOT have a value in the -- structure. In that case, we remove the value -- from the file, as well! case mkValue t f (vDelimiter val) of Just nv -> ((t, nv) <|) `fmap` go (Seq.viewl vs) (rmv t fs) Nothing -> go (Seq.viewl vs) (rmv t fs) -- Finally, if we can't find any description of the field, -- then we might skip it or throw an error, depending on -- the policy the user wants. Nothing | updateIgnoreExtraneousFields pol -> ((t, val) <|) `fmap` go (Seq.viewl vs) fs | otherwise -> Left ("Unexpected field: " ++ show t) -- Once we've gone through all the fields in the file, we need -- to see if there's anything left over that should be in the -- file. We might want to include dummy values for things that -- were left out, but if we have any non-optional fields left -- over, then we definitely need to include them. go EmptyL fs = return (finish (Seq.viewl fs)) finish (f@Field {} :< fs) | updateAddOptionalFields pol, Just val <- mkValue (fieldName f) f '=' = (fieldName f, val) <| finish (Seq.viewl fs) | otherwise = finish (Seq.viewl fs) finish (f@(FieldMb _ descr) :< fs) | not (fdSkipIfMissing descr), Just val <- mkValue (fieldName f) f '=' = (fieldName f, val) <| finish (Seq.viewl fs) | updateAddOptionalFields pol, Just val <- mkValue (fieldName f) f '=' = (fieldName f, val) <| finish (Seq.viewl fs) | otherwise = finish (Seq.viewl fs) -- If there's nothing left, then we can return a final value! finish EmptyL = Seq.empty mkValue t fld delim = let comments = case updateGeneratedCommentPolicy pol of CommentPolicyNone -> Seq.empty CommentPolicyAddFieldComment -> mkComments (fieldComment fld) CommentPolicyAddDefaultComment cs -> mkComments cs val = IniValue { vLineNo = 0, vName = actualText t, vValue = "", vComments = comments, vCommentedOut = False, vDelimiter = delim } in case fld of Field l descr -> Just (val {vValue = " " <> fvEmit (fdValue descr) (get l s)}) FieldMb l descr -> case get l s of Just v -> Just (val {vValue = " " <> fvEmit (fdValue descr) v}) Nothing -> Nothing -- $using -- Functions for parsing, serializing, and updating INI files. -- $types -- Types which represent declarative specifications for INI -- file structure. -- $sections -- Declaring sections of an INI file specification -- $fields -- Declaring individual fields of an INI file specification. -- $fieldvalues -- Values of type 'FieldValue' represent both a parser and a -- serializer for a value of a given type. It's possible to manually -- create 'FieldValue' descriptions, but for simple configurations, -- but for the sake of convenience, several commonly-needed -- varieties of 'FieldValue' are defined here. -- $misc -- These values and types are exported for compatibility. config-ini-0.2.7.0/src/Data/Ini/Config/Raw.hs0000644000000000000000000002262707346545000016553 0ustar0000000000000000-- | -- Module : Data.Ini.Config.Raw -- Copyright : (c) Getty Ritter, 2017 -- License : BSD -- Maintainer : Getty Ritter -- Stability : experimental -- -- __Warning!__ This module is subject to change in the future, and therefore should -- not be relied upon to have a consistent API. module Data.Ini.Config.Raw ( -- * INI types RawIni (..), IniSection (..), IniValue (..), BlankLine (..), NormalizedText (..), normalize, -- * serializing and deserializing parseRawIni, printRawIni, -- * inspection lookupInSection, lookupSection, lookupValue, ) where import Control.Monad (void) import qualified Data.Foldable as F import Data.Monoid ((<>)) import Data.Sequence (Seq) import qualified Data.Sequence as Seq import Data.Text (Text) import qualified Data.Text as T import qualified Data.Text.Lazy as LazyText import qualified Data.Text.Lazy.Builder as Builder import Data.Void (Void) import Text.Megaparsec import Text.Megaparsec.Char type Parser = Parsec Void Text -- | The 'NormalizedText' type is an abstract representation of text -- which has had leading and trailing whitespace removed and been -- normalized to lower-case, but from which we can still extract the -- original, non-normalized version. This acts like the normalized -- text for the purposes of 'Eq' and 'Ord' operations, so -- -- @ -- 'normalize' " x " == 'normalize' \"X\" -- @ -- -- This type is used to store section and key names in the data NormalizedText = NormalizedText { actualText :: Text, normalizedText :: Text } deriving (Show) -- | The constructor function to build a 'NormalizedText' value. You -- probably shouldn't be using this module directly, but if for some -- reason you are using it, then you should be using this function to -- create 'NormalizedText' values. normalize :: Text -> NormalizedText normalize t = NormalizedText t (T.toLower (T.strip t)) instance Eq NormalizedText where NormalizedText _ x == NormalizedText _ y = x == y instance Ord NormalizedText where NormalizedText _ x `compare` NormalizedText _ y = x `compare` y -- | An 'Ini' value is a mapping from section names to -- 'IniSection' values. The section names in this mapping are -- normalized to lower-case and stripped of whitespace. This -- sequence retains the ordering of the original source file. newtype RawIni = RawIni { fromRawIni :: Seq (NormalizedText, IniSection) } deriving (Eq, Show) -- | An 'IniSection' consists of a name, a mapping of key-value pairs, -- and metadata about where the section starts and ends in the -- file. The section names found in 'isName' are __not__ normalized -- to lower-case or stripped of whitespace, and thus should appear -- exactly as they appear in the original source file. data IniSection = IniSection { -- | The name of the section, as it appears in the -- original INI source isName :: Text, -- | The key-value mapping within that section. Key -- names here are normalized to lower-case and -- stripped of whitespace. This sequence retains -- the ordering of the original source file. isVals :: Seq (NormalizedText, IniValue), -- | The line on which the section begins. This -- field is ignored when serializing, and is only -- used for error messages produced when parsing -- and deserializing an INI structure. isStartLine :: Int, -- | The line on which the section ends. This field -- is ignored when serializing, and is only used -- for error messages produced when parsing and -- deserializing an INI structure. isEndLine :: Int, -- | The blank lines and comments that appear prior -- to the section head declaration, retained for -- pretty-printing identical INI files. isComments :: Seq BlankLine } deriving (Eq, Show) -- | An 'IniValue' represents a key-value mapping, and also stores the -- line number where it appears. The key names and values found in -- 'vName' and 'vValue' respectively are _not_ normalized to -- lower-case or stripped of whitespace, and thus should appear -- exactly as they appear in the original source file. data IniValue = IniValue { -- | The line on which the key/value mapping -- appears. This field is ignored when -- serializing, and is only used for error -- messages produced when parsing and -- deserializing an INI structure. vLineNo :: Int, -- | The name of the key, as it appears in the INI source. vName :: Text, -- | The value of the key vValue :: Text, vComments :: Seq BlankLine, -- | Right now, this will never show up in a parsed INI file, but -- it's used when emitting a default INI file: it causes the -- key-value line to include a leading comment as well. vCommentedOut :: Bool, vDelimiter :: Char } deriving (Eq, Show) -- | We want to keep track of the whitespace/comments in between KV -- lines, so this allows us to track those lines in a reproducible -- way. data BlankLine = CommentLine Char Text | BlankLine deriving (Eq, Show) -- | Parse a 'Text' value into an 'Ini' value, retaining a maximal -- amount of structure as needed to reconstruct the original INI file. parseRawIni :: Text -> Either String RawIni parseRawIni t = case runParser pIni "ini file" t of Left err -> Left (errorBundlePretty err) Right v -> Right v pIni :: Parser RawIni pIni = do leading <- sBlanks pSections leading Seq.empty sBlanks :: Parser (Seq BlankLine) sBlanks = Seq.fromList <$> many ((BlankLine <$ void eol) <|> sComment) sComment :: Parser BlankLine sComment = do c <- oneOf [';', '#'] txt <- T.pack `fmap` manyTill anySingle eol return (CommentLine c txt) pSections :: Seq BlankLine -> Seq (NormalizedText, IniSection) -> Parser RawIni pSections leading prevs = pSection leading prevs <|> (RawIni prevs <$ void eof) pSection :: Seq BlankLine -> Seq (NormalizedText, IniSection) -> Parser RawIni pSection leading prevs = do start <- getCurrentLine void (char '[') name <- T.pack `fmap` some (noneOf ['[', ']']) void (char ']') void eol comments <- sBlanks pPairs (T.strip name) start leading prevs comments Seq.empty pPairs :: Text -> Int -> Seq BlankLine -> Seq (NormalizedText, IniSection) -> Seq BlankLine -> Seq (NormalizedText, IniValue) -> Parser RawIni pPairs name start leading prevs comments pairs = newPair <|> finishedSection where newPair = do (n, pair) <- pPair comments rs <- sBlanks pPairs name start leading prevs rs (pairs Seq.|> (n, pair)) finishedSection = do end <- getCurrentLine let newSection = IniSection { isName = name, isVals = pairs, isStartLine = start, isEndLine = end, isComments = leading } pSections comments (prevs Seq.|> (normalize name, newSection)) pPair :: Seq BlankLine -> Parser (NormalizedText, IniValue) pPair leading = do pos <- getCurrentLine key <- T.pack `fmap` some (noneOf ['[', ']', '=', ':']) delim <- oneOf [':', '='] val <- T.pack `fmap` manyTill anySingle eol return ( normalize key, IniValue { vLineNo = pos, vName = key, vValue = val, vComments = leading, vCommentedOut = False, vDelimiter = delim } ) getCurrentLine :: Parser Int getCurrentLine = (fromIntegral . unPos . sourceLine) `fmap` getSourcePos -- | Serialize an INI file to text, complete with any comments which -- appear in the INI structure, and retaining the aesthetic details -- which are present in the INI file. printRawIni :: RawIni -> Text printRawIni = LazyText.toStrict . Builder.toLazyText . F.foldMap build . fromRawIni where build (_, ini) = F.foldMap buildComment (isComments ini) <> Builder.singleton '[' <> Builder.fromText (isName ini) <> Builder.fromString "]\n" <> F.foldMap buildKV (isVals ini) buildComment BlankLine = Builder.singleton '\n' buildComment (CommentLine c txt) = Builder.singleton c <> Builder.fromText txt <> Builder.singleton '\n' buildKV (_, val) = F.foldMap buildComment (vComments val) <> (if vCommentedOut val then Builder.fromString "# " else mempty) <> Builder.fromText (vName val) <> Builder.singleton (vDelimiter val) <> Builder.fromText (vValue val) <> Builder.singleton '\n' -- | Look up an Ini value by section name and key. Returns the sequence -- of matches. lookupInSection :: -- | The section name. Will be normalized prior to -- comparison. Text -> -- | The key. Will be normalized prior to comparison. Text -> -- | The Ini to search. RawIni -> Seq.Seq Text lookupInSection sec opt ini = vValue <$> F.asum (lookupValue opt <$> lookupSection sec ini) -- | Look up an Ini section by name. Returns a sequence of all matching -- section records. lookupSection :: -- | The section name. Will be normalized prior to -- comparison. Text -> -- | The Ini to search. RawIni -> Seq.Seq IniSection lookupSection name ini = snd <$> Seq.filter ((== normalize name) . fst) (fromRawIni ini) -- | Look up an Ini key's value in a given section by the key. Returns -- the sequence of matches. lookupValue :: -- | The key. Will be normalized prior to comparison. Text -> -- | The section to search. IniSection -> Seq.Seq IniValue lookupValue name section = snd <$> Seq.filter ((== normalize name) . fst) (isVals section) config-ini-0.2.7.0/test/doctest/0000755000000000000000000000000007346545000014515 5ustar0000000000000000config-ini-0.2.7.0/test/doctest/Main.hs0000644000000000000000000000021707346545000015735 0ustar0000000000000000module Main where import Test.DocTest (doctest) main :: IO () main = do doctest ["src/Data/Ini/Config.hs", "-XOverloadedStrings", "-isrc"] config-ini-0.2.7.0/test/ini-compat/0000755000000000000000000000000007346545000015110 5ustar0000000000000000config-ini-0.2.7.0/test/ini-compat/Main.hs0000644000000000000000000000634007346545000016333 0ustar0000000000000000{-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TypeSynonymInstances #-} {-# OPTIONS_GHC -fno-warn-orphans #-} module Main where import qualified Data.Foldable as Fold import Data.Function (on) import Data.HashMap.Strict (HashMap) import qualified Data.HashMap.Strict as HM import qualified Data.Ini as I1 import qualified Data.Ini.Config.Raw as I2 import Data.List (nubBy) import qualified Data.Sequence as Seq import Data.Text (Text) import qualified Data.Text as T import Hedgehog import qualified Hedgehog.Gen as Gen import qualified Hedgehog.Range as Range propIniEquiv :: Property propIniEquiv = property $ do raw <- forAll mkIni let printed = I1.printIniWith I1.defaultWriteIniSettings raw i1 = I1.parseIni printed i2 = I2.parseRawIni printed case (i1, i2) of (Right i1', Right i2') -> let i1'' = lower i1' i2'' = toMaps i2' in i1'' === i2'' _ -> failure propRevIniEquiv :: Property propRevIniEquiv = property $ do raw <- forAll mkRichIni let printed = I2.printRawIni raw i1 = I1.parseIni printed i2 = I2.parseRawIni printed case (i1, i2) of (Right i1', Right i2') -> lower i1' === toMaps i2' _ -> failure propIniSelfEquiv :: Property propIniSelfEquiv = property $ do raw <- forAll mkRichIni Right (toMaps raw) === fmap toMaps (I2.parseRawIni (I2.printRawIni raw)) lower :: I1.Ini -> HashMap Text (HashMap Text Text) lower (I1.Ini sections _) = HM.fromList [ (T.toLower sectionName, HM.fromList [(T.toLower k, v) | (k, v) <- section]) | (sectionName, section) <- HM.toList sections ] toMaps :: I2.RawIni -> HashMap Text (HashMap Text Text) toMaps (I2.RawIni m) = conv (fmap sectionToPair m) where sectionToPair (name, section) = (I2.normalizedText name, conv (fmap valueToPair (I2.isVals section))) valueToPair (name, value) = (I2.normalizedText name, T.strip (I2.vValue value)) conv = HM.fromList . Fold.toList textChunk :: Gen Text textChunk = Gen.text (Range.linear 1 20) Gen.alphaNum mkIni :: Gen I1.Ini mkIni = do ss <- Gen.list (Range.linear 0 10) $ do name <- textChunk section <- Gen.list (Range.linear 0 10) $ (,) <$> textChunk <*> textChunk return (name, section) return (I1.Ini (HM.fromList ss) []) mkComments :: Gen (Seq.Seq I2.BlankLine) mkComments = fmap Seq.fromList $ Gen.list (Range.linear 0 5) $ Gen.choice [ return I2.BlankLine, I2.CommentLine <$> Gen.element (";#" :: String) <*> textChunk ] mkRichIni :: Gen I2.RawIni mkRichIni = do ss <- Gen.list (Range.linear 0 100) $ do name <- textChunk section <- Gen.list (Range.linear 0 100) $ do k <- textChunk v <- textChunk cs <- mkComments return ( I2.normalize k, I2.IniValue 0 k v cs False '=' ) cs <- mkComments return ( I2.normalize name, I2.IniSection name (Seq.fromList (nubBy ((==) `on` fst) section)) 0 0 cs ) return (I2.RawIni (Seq.fromList (nubBy ((==) `on` fst) ss))) main :: IO () main = do _ <- checkParallel $ Group "Test.Example" [ ("propIniEquiv", propIniEquiv), ("propRevIniEquiv", propRevIniEquiv), ("propIniSelfEquiv", propIniSelfEquiv) ] return () config-ini-0.2.7.0/test/prewritten/0000755000000000000000000000000007346545000015253 5ustar0000000000000000config-ini-0.2.7.0/test/prewritten/Main.hs0000644000000000000000000000242007346545000016471 0ustar0000000000000000module Main where import Data.Ini.Config.Raw import Data.List import Data.Sequence (Seq) import Data.Text (Text) import qualified Data.Text as T import qualified Data.Text.IO as T import System.Directory import System.Exit dir :: FilePath dir = "test/prewritten/cases" main :: IO () main = do files <- getDirectoryContents dir let inis = [ f | f <- files, ".ini" `isSuffixOf` f ] mapM_ runTest inis type IniSeq = Seq (Text, Seq (Text, Text)) toMaps :: RawIni -> IniSeq toMaps (RawIni m) = fmap sectionToPair m where sectionToPair (name, section) = (normalizedText name, fmap valueToPair (isVals section)) valueToPair (name, value) = (normalizedText name, T.strip (vValue value)) runTest :: FilePath -> IO () runTest iniF = do let hsF = take (length iniF - 4) iniF ++ ".hs" ini <- T.readFile (dir ++ "/" ++ iniF) hs <- readFile (dir ++ "/" ++ hsF) case parseRawIni ini of Left err -> do putStrLn ("Error parsing " ++ iniF) putStrLn err exitFailure Right x | toMaps x == read hs -> do putStrLn ("Passed: " ++ iniF) | otherwise -> do putStrLn ("Parses do not match for " ++ iniF) putStrLn ("Expected: " ++ hs) putStrLn ("Actual: " ++ show (toMaps x)) exitFailure config-ini-0.2.7.0/test/prewritten/cases/0000755000000000000000000000000007346545000016351 5ustar0000000000000000config-ini-0.2.7.0/test/prewritten/cases/basic.hs0000644000000000000000000000024207346545000017764 0ustar0000000000000000fromList [ ( "s1", fromList [ ("foo", "bar"), ("baz", "quux") ] ), ( "s2", fromList [("argl", "bargl")] ) ] config-ini-0.2.7.0/test/prewritten/cases/basic.ini0000644000000000000000000000024607346545000020135 0ustar0000000000000000# a thorough test # leading comments [S1] # test with equals foo = bar # test with colon baz : quux [S2] ; comments with semicolons argl = bargl ; trailing comments config-ini-0.2.7.0/test/prewritten/cases/unicode.hs0000644000000000000000000000055307346545000020336 0ustar0000000000000000fromList [ ( "中文" , fromList [ ("鸡丁", "宫保") , ("豆腐", "麻婆") ] ) , ( "русский" , fromList [ ( "хорошо", "очень" ) ] ) , ( "العَرَبِيَّة‎‎" , fromList [ ("واحد", "١") , ("اثنان", "٢") , ("ثلاثة", "٣") ] ) ] config-ini-0.2.7.0/test/prewritten/cases/unicode.ini0000644000000000000000000000041607346545000020501 0ustar0000000000000000# some unicode tests, for good measure [中文] # 也有漢字在這個注释 鸡丁 = 宫保 豆腐 : 麻婆 [русский] ; и это комментарии хорошо = очень [العَرَبِيَّة‎‎] واحد = ١ اثنان = ٢ ثلاثة = ٣