module Data.Yaml.YamlLight
(
YamlLight(..)
, parseYaml, parseYamlFile, parseYamlBytes
, fromYamlNode, lookupYL, lookupYLWith, combineSequencedMaps, combineMappedSequences
, unSeq, unMap, unStr
) where
import Control.Applicative
import Data.List
import Data.Maybe
import Control.Arrow
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
combineSequencedMaps :: YamlLight -> Maybe [(YamlLight, YamlLight)]
combineSequencedMaps (YSeq ys) = Just . concatMap Map.assocs . catMaybes $ map unMap ys
combineSequencedMaps _ = Nothing
combineMappedSequences :: YamlLight -> Maybe [(YamlLight, YamlLight)]
combineMappedSequences (YMap m) = Just . concatMap flattenTags . removeSndMaybes $ mapThenList unSeq m
combineMappedSequences _ = Nothing
mapThenList :: (b -> Maybe [c]) -> Map.Map a b -> [(a, Maybe [c])]
mapThenList f m = Map.toList $ Map.map f m
removeSndMaybes :: [(a,Maybe [b])] -> [(a,[b])]
removeSndMaybes = map (second fromJust) . filter (isJust . snd)
flattenTags :: (a,[b]) -> [(a,b)]
flattenTags (a,bs) = map ((,) a) bs
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
performTest :: Show a => (YamlLight -> a) -> String -> IO ()
performTest f s = parseYaml s >>= print . f
cSeqMap1 = "[{key1: val1, key2: val2}, {key3: val3}]"
cMapSeq1 = "{key1: [val1, val2, val3], key2: [val4, val5]}"
testCombineSequencedMaps1 = performTest combineSequencedMaps cSeqMap1
testCombineMappedSequences1 = performTest combineMappedSequences cMapSeq1