{-# LANGUAGE ViewPatterns  #-}
{- |
   Module      : Text.Pandoc.Reader.ODT.Generic.Utils
   Copyright   : Copyright (C) 2015 Martin Linnemann
   License     : GNU GPL, version 2 or above

   Maintainer  : Martin Linnemann <theCodingMarlin@googlemail.com>
   Stability   : alpha
   Portability : portable

General utility functions for the odt reader.
-}

module Text.Pandoc.Readers.ODT.Generic.Utils
( tryToRead
, Lookupable(..)
, readLookupable
, readPercent
, findBy
) where

import Data.Char (isSpace)
import Data.Maybe
import Data.Text (Text)
import qualified Data.Text as T

-- | Alternative to 'read'/'reads'. The former of these throws errors
-- (nobody wants that) while the latter returns "to much" for simple purposes.
-- This function instead applies 'reads' and returns the first match (if any)
-- in a 'Maybe'.
tryToRead :: (Read r) => Text -> Maybe r
tryToRead :: forall r. Read r => Text -> Maybe r
tryToRead = ((r, String) -> r) -> Maybe (r, String) -> Maybe r
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (r, String) -> r
forall a b. (a, b) -> a
fst (Maybe (r, String) -> Maybe r)
-> (Text -> Maybe (r, String)) -> Text -> Maybe r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(r, String)] -> Maybe (r, String)
forall a. [a] -> Maybe a
listToMaybe ([(r, String)] -> Maybe (r, String))
-> (Text -> [(r, String)]) -> Text -> Maybe (r, String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReadS r
forall a. Read a => ReadS a
reads ReadS r -> (Text -> String) -> Text -> [(r, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack

-- | A version of 'reads' that requires a '%' sign after the number
readPercent :: ReadS Int
readPercent :: ReadS Int
readPercent String
s = [ (Int
i,String
s') | (Int
i   , String
r ) <- ReadS Int
forall a. Read a => ReadS a
reads String
s
                         , (String
"%" , String
s') <- ReadS String
lex   String
r
              ]

-- | Data that can be looked up.
-- This is mostly a utility to read data with kind *.
class Lookupable a where
  lookupTable :: [(Text, a)]

-- | Very similar to a simple 'lookup' in the 'lookupTable', but with a lexer.
readLookupable :: (Lookupable a) => Text -> Maybe a
readLookupable :: forall a. Lookupable a => Text -> Maybe a
readLookupable Text
s =
  Text -> [(Text, a)] -> Maybe a
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup ((Char -> Bool) -> Text -> Text
T.takeWhile (Bool -> Bool
not (Bool -> Bool) -> (Char -> Bool) -> Char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Bool
isSpace) (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> Text -> Text
T.dropWhile Char -> Bool
isSpace Text
s) [(Text, a)]
forall a. Lookupable a => [(Text, a)]
lookupTable

-- | A version of "Data.List.find" that uses a converter to a Maybe instance.
-- The returned value is the first which the converter returns in a 'Just'
-- wrapper.
findBy :: (a -> Maybe b) -> [a] -> Maybe b
findBy :: forall a b. (a -> Maybe b) -> [a] -> Maybe b
findBy a -> Maybe b
_               []   = Maybe b
forall a. Maybe a
Nothing
findBy a -> Maybe b
f ((a -> Maybe b
f -> Just b
x):[a]
_ ) = b -> Maybe b
forall a. a -> Maybe a
Just b
x
findBy a -> Maybe b
f (            a
_:[a]
xs) = (a -> Maybe b) -> [a] -> Maybe b
forall a b. (a -> Maybe b) -> [a] -> Maybe b
findBy a -> Maybe b
f [a]
xs