parse/xml/

element.rs

use roxmltree::{
    Node,
    NodeType,
};
use std::ops::Range;

use crate::{
    LowerName,
    NameError,
};

use super::{
    Once,
    Parsed,
    ParseError,
    missing_attribute,
    unexpected_attribute,
};

/// Raise a `Duplicate element` error
pub fn duplicate_element<E>(
    element_name: &str,
    duplicate_range: Range<usize>,
    existing_range: Range<usize>,
    errors: &mut Vec<E>,
)
where
    E: From<ParseError>,
{
    errors.push(ParseError::DuplicateElement {
        element: element_name.to_owned(),
        duplicate: duplicate_range.into(),
        existing: existing_range.into(),
    }.into());
}

/// Used when iterating over node children
/// and you are only expecting elements.
///
/// For each element, return it's name
///
/// For all other comments, pi & text raise an error.
///
/// # Example:
///
/// ```
/// for child in element.children() {
///     let Some(name) = element_name(&child, errors) else {
///         continue;
///     };
///
///     match name {
///         "..." =>
///             do_somthing(),
///
///         _ =>
///             unexpected_element(child, errors),
///     }
/// }
/// ```
pub fn element_name<'input, E>(
    child: &Node<'input, 'input>,
    errors: &mut Vec<E>,
) -> Option<&'input str>
where
    E: From<ParseError>,
{
    match child.node_type() {
        NodeType::Element =>
            return Some(child.tag_name().name()),

        NodeType::Text =>
            if let Some(text) = child.text() {
                if text.split_ascii_whitespace().next().is_some() {
                    errors.push(
                        ParseError::UnexpectedElement {
                            unexpected: child.range().into(),
                        }.into(),
                    );
                }
            },

        NodeType::Comment =>
            (),

        _ =>
            errors.push(
                ParseError::UnexpectedElement {
                    unexpected: child.range().into(),
                }.into(),
            ),
    }

    None
}

impl<T> Once<T> {
    /// Check if duplicate element is being parsed.
    ///
    /// If a duplicate is being parsed, return `true` and
    /// raise an error.
    ///
    /// Otherwise, return `false`.
    pub fn is_duplicate_element<'input, E>(
        &self,
        element: &Node<'input, 'input>,
        errors: &mut Vec<E>,
    ) -> bool
    where
        E: From<ParseError>,
    {
        match self {
            Once::Success { name_range, .. } |
            Once::Failure { name_range, .. } => {
                duplicate_element(
                    element.tag_name().name(),
                    element.range(),
                    name_range.clone(),
                    errors,
                );

                true
            }

            Once::Missing { .. } =>
                false,
        }
    }
}

impl Once<usize> {
    /// Parse a single length element,
    /// a `usize` with bounded range.
    pub fn length_element<'input, E>(
        &mut self,
        attribute_name: &'static str,
        range: std::ops::RangeInclusive<usize>,
        element: Node<'input, 'input>,
        errors: &mut Vec<E>,
    )
    where
        E: From<ParseError>,
    {
        if self.is_duplicate_element(&element, errors) {
            return;
        }

        let mut value = Once::new(attribute_name);

        for attribute in element.attributes() {
            if attribute.name() == attribute_name {
                value.length_attribute(range.clone(), attribute, errors);
            } else {
                unexpected_attribute(attribute, errors);
            }
        }

        for child in element.children() {
            unexpected_element(child, errors);
        }

        match value {
            Once::Success { value, .. } =>
                self.element_success(element, value),

            Once::Failure { .. } =>
                self.element_failure(element),

            Once::Missing { name } => {
                missing_attribute(name, &element, errors);

                self.element_failure(element);
            }
        }
    }
}

/// Parse a single lowercase name of the form
/// `<element attribute=''/>`
pub fn lower_name_attribute_in_element<'input, E>(
    attribute_name: &'static str,
    element: &Node<'input, 'input>,
    errors: &mut Vec<E>,
) -> Option<Parsed<LowerName>>
where
    E: From<NameError> + From<ParseError>,
{
    let mut found = Once::new(attribute_name);

    for attribute in element.attributes() {
        if attribute.name() == attribute_name {
            found.lower_name_attribute(attribute, errors);
        } else {
            unexpected_attribute(attribute, errors);
        }
    }

    for child in element.children() {
        unexpected_element(child, errors);
    }

    found.required_parsed_attribute(element, errors)
}

/// Raise a `Missing element` error
pub fn missing_element<'input, E>(
    name: &str,
    parent: &Node<'input, 'input>,
    errors: &mut Vec<E>,
)
where
    E: From<ParseError>,
{
    errors.push(ParseError::MissingElement {
        element: name.to_owned(),
        parent: parent.range().into(),
    }.into());
}

/// Raise a `Missing element` error
pub fn missing_element_range<E>(
    name: &str,
    range: Range<usize>,
    errors: &mut Vec<E>,
)
where
    E: From<ParseError>,
{
    errors.push(ParseError::MissingElement {
        element: name.to_owned(),
        parent: range.into(),
    }.into());
}

impl Once<String> {
    /// Parse a string element checking for duplicates
    pub fn string_element<'input, E>(
        &mut self,
        element: Node<'input, 'input>,
        errors: &mut Vec<E>,
    )
    where
        E: From<ParseError>,
    {
        if self.is_duplicate_element(&element, errors) {
            return;
        }

        if let Some(value) = string_in_element(&element, errors) {
            self.element_parsed_success(element, value);
        } else {
            self.element_failure(element);
        }
    }

    /// Parse a string element checking for duplicates
    ///
    /// Ignore attributes
    pub fn string_element_ignore_attributes<'input, E>(
        &mut self,
        element: Node<'input, 'input>,
        errors: &mut Vec<E>,
    )
    where
        E: From<ParseError>,
    {
        if self.is_duplicate_element(&element, errors) {
            return;
        }

        if let Some(value) = string_in_element_ignore_attributes(&element, errors) {
            self.element_parsed_success(element, value);
        } else {
            self.element_failure(element);
        }
    }
}

/// Parse and return a string in an element
pub fn string_in_element<'input, E>(
    element: &Node<'input, 'input>,
    errors: &mut Vec<E>,
) -> Option<Parsed<String>>
where
    E: From<ParseError>,
{
    for attribute in element.attributes() {
        unexpected_attribute(attribute, errors);
    }

    string_in_element_ignore_attributes(element, errors)
}

/// Parse and return a string in an element
pub fn string_in_element_ignore_attributes<'input, E>(
    element: &Node<'input, 'input>,
    errors: &mut Vec<E>,
) -> Option<Parsed<String>>
where
    E: From<ParseError>,
{
    let mut parsed = None;

    for child in element.children() {
        if child.is_text() && parsed.is_none() {
            if let Some(value) = child.text() {
                parsed = Some(Parsed {
                    range: child.range(),
                    value,
                });
            }
        } else {
            unexpected_element(child, errors);
        }
    }

    if let Some(parsed) = parsed {
        let value = parsed.value.trim_ascii();

        if value.is_empty() {
            errors.push(ParseError::StringEmpty {
                value: element.range().into(),
            }.into());

            None
        } else {
            Some(Parsed {
                range: parsed.range,
                value: value.to_owned(),
            })
        }
    } else {
        errors.push(ParseError::StringEmpty {
            value: element.range().into(),
        }.into());

        None
    }
}

/// Raise an 'Unexpected element' error
pub fn unexpected_element<'input, E>(
    element: Node<'input, 'input>,
    errors: &mut Vec<E>,
)
where
    E: From<ParseError>,
{
    errors.push(ParseError::UnexpectedElement {
        unexpected: element.range().into(),
    }.into());
}

/// Raise an 'Unexpected element' error
pub fn unexpected_element_range<E>(
    range: Range<usize>,
    errors: &mut Vec<E>,
)
where
    E: From<ParseError>,
{
    errors.push(ParseError::UnexpectedElement {
        unexpected: range.into(),
    }.into());
}