🟠XmlParser.hs

Module Documentation: XmlParser

The XmlParser module in Haskell provides robust tools for parsing XML content into a structured format defined by the XmlValue data type. It leverages combinatory parsing techniques to decode XML into its component elements and text, facilitating the processing and manipulation of XML data within the application.

Interface and Functionality Overview

Data Types

• XmlValue: Represents elements of an XML document.

  • XmlElement: Represents an XML element with a name, attributes, and children.

  • XmlText: Represents text within an XML document.

Core Functions

parseXmlFile

• Purpose: Parses an entire XML file into an XmlValue.

• Parameters: String - the XML data as a string.

• Returns: Maybe XmlValue - the parsed XML document if successful; otherwise, Nothing.

parseXmlDocument

• Purpose: Parses the root element of an XML document.

• Returns: Parser XmlValue - a parser that yields the root XML element.

parseXmlElement

• Purpose: Parses a single XML element, including its name, attributes, and children.

• Returns: Parser XmlValue - a parser that yields an XML element.

parseXmlText

• Purpose: Parses text within XML tags.

• Returns: Parser XmlValue - a parser that yields text as XmlText.

Detailed Parsing Logic

• Element Parsing: Begins by consuming any irrelevant characters (whitespace, new lines), then reads the element's opening tag, attributes, and contents, concluding with the matching end tag.

• Attribute Parsing: Attributes of an element are parsed within the opening tag, capturing both attribute names and their corresponding values.

• Content Parsing: Handles mixed content within XML elements, distinguishing between nested elements and text nodes.

• Conditional Skipping: Certain tags may be programmatically skipped based on their names, simplifying the parsing process for elements that are not relevant or needed.

Advanced Features

• parseAttributes: Collects and returns all attributes of an XML element as a list of key-value pairs.

• parseName and parseString: Utility parsers for extracting XML names and matching string literals.

• parseAnyCharExcept and satisfy: Custom parsers that exclude specific characters, facilitating granular control over the parsing process.

Conclusion

The XmlParser module is essential for applications that require direct interaction with XML data, providing a flexible and efficient mechanism to convert XML into programmatically manipulable structures. This capability is crucial for a wide range of applications, from data interchange to configuration and content management systems.

{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-}
{-# HLINT ignore "Use newtype instead of data" #-}
{-# OPTIONS_GHC -Wno-unused-do-bind #-}
{-# OPTIONS_GHC -Wno-type-defaults #-}
{-# HLINT ignore "Use when" #-}
{-# HLINT ignore "Use lambda-case" #-}

module XmlParser
    ( parseXmlFile
    , XmlValue(..)
    ) where

import Parser(Parser(..), (<|>), parseChar, parseMany, parseSome,
    parseAnyChar)
import Control.Monad (void)
import Control.Applicative (optional)
import Data.Maybe (fromMaybe)

data XmlValue = XmlElement String [(String, String)] [XmlValue]
              | XmlText String
              deriving (Show, Eq)

parseXmlFile :: String -> Maybe XmlValue
parseXmlFile xml = case runParser parseXmlDocument xml of
    Just (xmlValue, "") -> Just xmlValue
    _ -> Nothing

parseXmlDocument :: Parser XmlValue
parseXmlDocument = do
    parseMany ignoreParser
    root <- parseXmlElement
    parseMany ignoreParser
    return root

ignoreParser :: Parser Char
ignoreParser = parseAnyChar "\n \t\11\12\13\28\29\30\31\133\160"

skipByName :: String -> Bool
skipByName name = case name of
    "author" -> False
    "date" -> False
    "bold" -> False
    "italic" -> False
    "code" -> False
    "paragraph" -> False
    "link" -> False
    "image" -> False
    _ -> True

skipByEndName :: String -> Bool
skipByEndName name = case name of
    "bold" -> False
    "italic" -> False
    "code" -> False
    "link" -> False
    "image" -> False
    "underlined" -> False
    _ -> True

parseXmlElement :: Parser XmlValue
parseXmlElement = do
    parseMany ignoreParser
    parseChar '<'
    name <- parseName
    attrs <- parseAttributes
    parseChar '>'
    if skipByName name then parseMany ignoreParser else return ""
    contents <- parseContents
    parseEndTag name
    return $ XmlElement name attrs contents

parseEndTag :: String -> Parser ()
parseEndTag name =
    parseChar '<' >>
    parseChar '/' >>
    parseMany ignoreParser >>
    parseString name >>
    parseMany ignoreParser >>
    void (parseChar '>') >>
    (if skipByEndName name
        then void (parseMany ignoreParser)
        else return ())


parseContents :: Parser [XmlValue]
parseContents = parseMany $ parseXmlText <|> parseXmlElement

parseXmlText :: Parser XmlValue
parseXmlText = do
    text <- parseSome $ parseAnyCharExcept "<"
    return $ XmlText text

parseAttributeValue :: Parser (Maybe String)
parseAttributeValue = optional (parseSome $ parseAnyCharExcept "\"")

parseAttributes :: Parser [(String, String)]
parseAttributes = parseMany $ do
    parseMany ignoreParser
    name <- parseName
    parseChar '='
    parseChar '"'
    value <- parseAttributeValue
    parseChar '"'
    return (name, fromMaybe "" value)

parseName :: Parser String
parseName = parseSome $ parseAnyCharExcept " \t\n\r/>="

parseString :: String -> Parser String
parseString str = foldr (\c p -> parseChar c *> p) (pure str) str

parseAnyCharExcept :: String -> Parser Char
parseAnyCharExcept exclusions = satisfy (`notElem` exclusions)

satisfy :: (Char -> Bool) -> Parser Char
satisfy f = Parser $ \str -> case str of
    [] -> Nothing
    (x:xs) -> if f x then Just (x, xs) else Nothing