Text.XML.DOM.Parser

Parser internals

data ParserData

Constructors

ParserData

Fields

_pdCursor :: !Cursor

Cursor to current parser's environment

_pdAxis :: !Axis

Context axis to follow deeper

_pdPath :: ![Text]

Path for errors

Instances

Generic ParserData

type Rep ParserData

pdCursor :: Lens' ParserData Cursor

pdAxis :: Lens' ParserData Axis

pdPath :: Lens' ParserData [Text]

data ParserError

DOM parser error description.

Constructors

PENotFound

Tag not found which should be.

Fields

_pePath :: ![Text]

path of element

PEWrongFormat

Tag contents has wrong format, (could not read text to value)

Fields

_pePath :: ![Text]

path of element

_peDetails :: Text

PEWrongTagName

Such tag name is not expected in this place

Fields

_pePath :: ![Text]

path of element

_peDetails :: !Text

PENotElement

Node is not an element but should be

Fields

_pePath :: ![Text]

path of element

PEContentNotFound

Node should have text content, but it does not.

Fields

_pePath :: ![Text]

path of element

PEOther

Any other error

Fields

_pePath :: ![Text]

path of element

_peDetails :: !Text

Instances

Eq ParserError

Ord ParserError

Show ParserError

Generic ParserError

Exception ParserError

type Rep ParserError

pePath :: Lens' ParserError [Text]

peDetails :: Traversal' ParserError Text

newtype ParserErrors

Constructors

ParserErrors

Fields

unParserErrors :: [ParserError]

Instances

Eq ParserErrors

Ord ParserErrors

Show ParserErrors

Generic ParserErrors

Exception ParserErrors

Wrapped ParserErrors

(~) * ParserErrors t0 => Rewrapped ParserErrors t

type Rep ParserErrors

type Unwrapped ParserErrors = [ParserError]

throwParserError :: ([Text] -> ParserError) -> DomParser a

renderPath :: [Text] -> String

Render path for showing error

Parser itself

type DomParser = ExceptT [ParserError] (Reader ParserData)

Parser monad where all parsing actions live

runDomParser :: Document -> DomParser a -> Either [ParserError] a

Run parser on root element of Document.

type ContentParser a = Text -> Either Text a

Content parser type. Parser is just a function taking Text and returning either error description or successfully parsed value.

Common parsers

unitFromDom :: DomParser ()

Always successfully parses any DOM to ()

voidFromDom :: DomParser Void

Never parses successfully. It is just mzero

textFromContent :: ContentParser Text

Does not strip content. Returns content unmodified.

stringFromContent :: ContentParser String

Does not strip content. Returns content unmodified.

charFromContent :: ContentParser Char

Expects content to be a singe non-blank character. Blank characters are stripped to parse pretty-printed XML files.

intFromContent :: ContentParser Int

integerFromContent :: ContentParser Integer

doubleFromContent :: ContentParser Double

fixedFromContent :: (HasResolution a, Typeable a) => ContentParser (Fixed a)

boolFromContent :: ContentParser Bool

Expects content to be y, yes, t, true or 1 for True value. n, no, f, false or 0 for False value. Case is not significant, blank characters are striped.

Parser classes

class FromDom a where

Typeclass for structures which may be parsed from XML DOM. Usually you should pass parsing function explicitly to combinators like inElem, maybeInElem or inTags , but sometimes you need term search. Especially when you try to parse polymorphic types. Or you maybe generate parser with TH for your types, so typeclass would be convenient also.

Methods

fromDom :: DomParser a

Instances

FromDom ()

FromContent a => FromDom (CurrentContent a)

class FromContent a where

Usually you should pass ContentParser to combinators like elemContent or maybeElemContent explicitly. But sometimes you need term search. Especially for code generated with TH.

Methods

fromContent :: ContentParser a

Should return either error message (what was wrong) or parsed value

Instances

FromContent Bool

This isntance might be not very obvious but anyway

FromContent Char

FromContent Double

FromContent Int

FromContent Integer

FromContent String

FromContent Text

(HasResolution a, Typeable * a) => FromContent (Fixed a)

Combinators

inElem :: Text -> DomParser a -> DomParser a

Find first element with given name in current element and run parser inside of found element. Throws PENotFound error if element not found.

inElems :: Text -> DomParser a -> DomParser [a]

Find all elements with gievn name in current element and run parser inside of this elements.

nonEmptyInElems :: Text -> DomParser a -> DomParser (NonEmpty a)

maybeInElem :: Text -> DomParser a -> DomParser (Maybe a)

Try to find element with given name and run parser inside of it. If not found return Nothing

inElemsPred

Arguments

:: Traversable f

=> ([Cursor] -> f Cursor)

Some predicate like listToMaybe

-> Text

Name of tags to find in current tag

-> DomParser a

Parser to run inside found cursors

-> DomParser (f a)

Generic elements combinator. Takes predicate filtering/converting list of cursors to some traversable (with posible filtering and/or reordering)

inAxis

Arguments

:: [Text]

Path suffix to append to path before run parser

-> Axis

Axis to append to context

-> DomParser a

Parser to run

-> DomParser a

Run parser within axis context. Expected to not use directly.

inDescendants :: DomParser a -> DomParser a

Given parser will match tag in arbitrary deepness

inTags

Arguments

:: [Text]

Sequence of tag names parser must match inside

-> DomParser a

Parser to run

-> DomParser a

Given parser will match inside specific

Content getters

tryCurrentContent :: ContentParser a -> DomParser (Maybe a)

tryCurrentContentText :: DomParser (Maybe Text)

Get concatenated text from current parser's node(s). If current context have no Content nodes then return Nothing.

currentContent :: ContentParser a -> DomParser a

tryCurrentName :: DomParser (Maybe Name)

Return the name of current cursor we staying in. Return Nothing if we are not staying on element node

currentName :: DomParser Name

Return name of current element the parser in.

tryCurrentAttr :: Text -> DomParser (Maybe Text)

currentAttr :: Text -> DomParser Text

Take attribute from current node (if it is an element). Throws PENotFound or PENotElement

elemContent :: Text -> ContentParser a -> DomParser a

nonEmptyElemsContent :: Text -> ContentParser a -> DomParser (NonEmpty a)

elemsContent :: Text -> ContentParser a -> DomParser [a]

maybeElemContent :: Text -> ContentParser a -> DomParser (Maybe a)

Helpers

fromContentR :: forall a. (Read a, Typeable a) => Text -> Either Text a

newtype CurrentContent a

Helper newtype returning currentContent for any type with instance FromContent

Constructors

CurrentContent

Fields

unCurrentContent :: a

Instances

Eq a => Eq (CurrentContent a)

Ord a => Ord (CurrentContent a)

Show a => Show (CurrentContent a)

Generic (CurrentContent a)

FromContent a => FromDom (CurrentContent a)

type Rep (CurrentContent a)

Raw node getters

currentNodes :: DomParser [Node]

Get children nodes from current parser's node.

Checkers

checkCurrentLaxName :: Text -> DomParser ()

Throw PEWrongTagName if name of current element does not match with given.

checkCurrentName

Arguments

:: (Name -> Maybe Text)

name checking predicate

-> DomParser ()

Run predicate with current tag name. Parser fails if predicate returned (Just msg) or node is not an element.