sitemapo 0.2.0

The implementation of the Sitemap.xml (or URL inclusion) protocol with the support of txt & xml formats, and video, image, news extensions.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use std::fmt::{Display, Formatter};
use std::num::ParseFloatError;

use thiserror::Error;

/// [Priority] parsing error.
#[derive(Debug, Error)]
pub enum PriorityError {
    #[error("parse float error: {0}")]
    Parse(#[from] ParseFloatError),
    #[error("range error: [0.0, 1.0]")]
    Range,
}

/// Used to specify the priority of this URL relative to other URLs on your site.
///
/// Valid values range from 0.0 to 1.0. This value does not affect how your
/// pages are compared to pages on other sites. It only lets the search engines
/// know which pages you deem most important for the crawlers.
#[derive(Debug, Clone, PartialEq)]
pub struct Priority(f32);

impl Priority {
    /// Creates the priority from the valid underlying value.
    ///
    /// ```rust
    /// use sitemapo::attribute::Priority;
    ///
    /// let frequency = Priority::new(0.6f32).unwrap();
    /// assert_eq!(frequency.as_inner(), 0.6);
    /// ```
    pub fn new(priority: f32) -> Result<Self, PriorityError> {
        match priority {
            x if (0.0..=1.0).contains(&priority) => Ok(Self(x)),
            _ => Err(PriorityError::Range),
        }
    }

    /// Creates the priority from any underlying value by
    /// clamping the input into the acceptable range.
    ///
    /// ```rust
    /// use sitemapo::attribute::Priority;
    ///
    /// let frequency = Priority::new_fallback(2.6f32);
    /// assert_eq!(frequency.as_inner(), 1.0);
    /// ```
    pub fn new_fallback(priority: f32) -> Self {
        Self(priority.max(0.0).min(1.0))
    }

    /// Tries to parse the string into the valid priority value.
    ///
    /// ```rust
    /// use sitemapo::attribute::Priority;
    ///
    /// let frequency = Priority::parse("0.6").unwrap();
    /// assert_eq!(frequency.as_inner(), 0.6);
    /// ```
    pub fn parse(priority: &str) -> Result<Self, PriorityError> {
        let priority = priority.parse::<f32>()?;
        Self::new(priority)
    }

    /// Returns the internal value.
    pub fn as_inner(&self) -> f32 {
        self.0
    }

    /// Default (or average) priority value.
    pub const AVG: Self = Self(0.5);

    /// Minimal priority value.
    pub const MIN: Self = Self(0.0);

    /// Maximal priority value.
    pub const MAX: Self = Self(1.0);
}

impl Default for Priority {
    fn default() -> Self {
        Self::AVG.clone()
    }
}

impl Display for Priority {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        Display::fmt(format!("{:.1}", self.0).as_str(), f)
    }
}

impl TryFrom<&str> for Priority {
    type Error = PriorityError;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        Self::parse(value)
    }
}