my_xml_parser 0.1.2

XML parser, which can be used to parse XML to pairs of tokens. See source https://github.com/giginfee/my_parser
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use pest::Parser;
use pest_derive::Parser;
use anyhow::*; 


#[derive(Parser)]
#[grammar = "./grammar.pest"]
pub struct XMLParser;
pub fn parse_xml(input:&str) -> anyhow::Result <pest::iterators::Pairs<'_, Rule>>{

    let successful_parse = XMLParser::parse(Rule::xml, input)?;
    Ok(successful_parse)

}
pub fn parse_field(input:&str) -> anyhow::Result <pest::iterators::Pairs<'_, Rule>>{

  let parse = XMLParser::parse(Rule::field, input)?;
  Ok(parse)
  
}
pub fn parse_text(input:&str) -> anyhow::Result <pest::iterators::Pairs<'_, Rule>>{
  // let parse = XMLParser::parse(Rule::field, input)?;


  let parse = XMLParser::parse(Rule::text, input)?;
  Ok(parse)
  
}
#[cfg(test)]
mod tests {
  use super::*;
#[test]
fn field_test() -> anyhow::Result< ()>{
  let str ="<>";
  let field = parse_field(str)?.next().ok_or_else( || anyhow!( "no pair" ) )?;
   assert_eq!(field.as_str(),"");

  let str ="field";
  let field = parse_field(str)?.next().ok_or_else( || anyhow!( "no pair" ) );
  assert_eq!(field?.as_span().end(), str.len());


  let str ="<field></field>";
  let field = parse_field(str)?.next().ok_or_else( || anyhow!( "no pair" ) );
  assert_eq!(field.is_err(), false);
  assert_eq!(field?.as_span().end(), str.len());
  

  let str ="<field>fff</field>";
  let field = parse_field(str)?.next().ok_or_else( || anyhow!( "no pair" ) );
  assert_eq!(field?.as_span().end(), str.len());


  let str ="<field><f></field>";
  let field = parse_field(str)?.next().ok_or_else( || anyhow!( "no pair" ) );
  assert_eq!(field?.as_str(),"");

 Ok(())
}

#[test]
fn text_without_brackets_test() -> anyhow::Result< ()>{
  let str ="<>";
  let field = parse_text(str);
  assert!(field.is_err());

  let str: &str ="field";
  let field = parse_text(str)?.next().ok_or_else( || anyhow!( "no pair" ) );
  assert!(field.is_ok());

  let str ="<field>";
  let field = parse_text(str);
  assert!(field.is_err());

  let str ="";
  let field = parse_text(str);
  assert!(field.is_err());

 Ok(())
}

#[test]
fn xml_test() -> anyhow::Result< ()>{
  let str ="<r>
     <a>    
     </a>
     <b>
     </b>
  </r>";
  let field = parse_xml(str);
  assert!(field.is_ok());
  assert_eq!(field?.as_str(),str);

  let str ="";
  let field = parse_xml(str);
  assert!(field.is_ok());
  assert_eq!(field?.as_str(),str);

  let str ="<a></b>";
  let field = parse_xml(str);
  assert!(field.is_err());

  let str ="<a></a><a></a>";
  let field = parse_xml(str);
  assert!(field.is_err());

  let str ="<r><a>text</a><a></a></r>";
  let field = parse_xml(str);
  assert!(field.is_ok());
  assert_eq!(field?.as_str(),str);

  let str ="<r>text<a></a><a></a></r>";
  let field = parse_xml(str);
  assert!(field.is_ok());
  assert_eq!(field?.as_str(),str);




 Ok(())
}
}