module Data.Yaml.YamlLight
(
YamlLight(..)
, parseYaml, parseYamlFile, parseYamlBytes
, fromYamlNode, lookupYL, lookupYLWith
, unSeq, unMap, unStr
) where
import Control.Applicative
import Data.Data
import Data.List
import qualified Data.Yaml.Syck as Syck
import qualified Data.Map as Map
import qualified Data.ByteString as ByteString
data YamlLight = YMap (Map.Map YamlLight YamlLight)
| YSeq [YamlLight]
| YStr ByteString.ByteString
| YNil
deriving (Show, Ord, Eq)
convert :: (a -> Syck.YamlNode) -> (a -> YamlLight)
convert f = fromYamlNode . f
convertIO :: (a -> IO Syck.YamlNode) -> (a -> IO YamlLight)
convertIO f yn = fromYamlNode <$> f yn
parseYaml :: String -> IO YamlLight
parseYaml = convertIO Syck.parseYaml
parseYamlFile :: String -> IO YamlLight
parseYamlFile = convertIO Syck.parseYamlFile
parseYamlBytes :: ByteString.ByteString -> IO YamlLight
parseYamlBytes = convertIO Syck.parseYamlBytes
fromYamlNode :: Syck.YamlNode -> YamlLight
fromYamlNode = yamlElemToLight . Syck.n_elem
yamlElemToLight :: Syck.YamlElem -> YamlLight
yamlElemToLight (Syck.EMap ms) = YMap . Map.fromList . map (\(a,b) -> (fromYamlNode a, fromYamlNode b)) $ ms
yamlElemToLight (Syck.ESeq s) = YSeq $ map fromYamlNode s
yamlElemToLight (Syck.EStr buf) = YStr buf
yamlElemToLight (Syck.ENil) = YNil
lookupYL :: YamlLight -> YamlLight -> Maybe YamlLight
lookupYL key (YMap m) = Map.lookup key m
lookupYL _ _ = Nothing
lookupYLWith :: (YamlLight -> Bool) -> YamlLight -> Maybe YamlLight
lookupYLWith p (YMap m) = snd <$> (find (p . fst) $ Map.toList m)
lookupYLWith _ _ = Nothing
unSeq :: YamlLight -> Maybe [YamlLight]
unSeq (YSeq s) = Just s
unSeq _ = Nothing
unMap :: YamlLight -> Maybe (Map.Map YamlLight YamlLight)
unMap (YMap m) = Just m
unMap _ = Nothing
unStr :: YamlLight -> Maybe ByteString.ByteString
unStr (YStr s) = Just s
unStr _ = Nothing