unilang_parser 0.38.0

Parser for Unilang CLI instruction syntax. 
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Error Handling and Diagnostics Example
//!
//! This example demonstrates :
//! - Different types of parsing errors
//! - Error location information
//! - Comprehensive error handling patterns

use unilang_parser :: { ErrorKind, Parser, UnilangParserOptions };

#[ allow(clippy ::too_many_lines) ]
fn main()
{
  let parser = Parser ::new( UnilangParserOptions ::default() );

  // Test various error scenarios
  println!( "=== Error Handling Examples ===" );

  // Invalid command path (double dots)
  println!( "\n1. Invalid Command Path: " );
  match parser.parse_repl_input( "invalid..command" )
  {
  Ok( _ ) => println!( "Unexpected success!" ),
  Err( error ) =>
  {
   println!( "Error type: {:?}", error.kind );
   println!
   (
  "Error location: {} to {}",
  error.location.as_ref().map_or( 0, unilang_parser ::SourceLocation ::start ),
  error.location.as_ref().map_or( 0, unilang_parser ::SourceLocation ::end )
 );
   println!( "Error message: {error}" );

   // The specific ErrorKind variants might have changed, so we check for Syntax error with specific message
   if matches!( error.kind, ErrorKind ::Syntax( _ ) )
   {
  println!( "✓ Correctly identified syntax error for invalid command path" );
 }
 }
 }

  // Unterminated quoted string
  println!( "\n2. Unterminated Quoted String: " );
  match parser.parse_repl_input( r#"cmd arg :: "unterminated string"# )
  {
  Ok( _ ) => println!( "Unexpected success!" ),
  Err( error ) =>
  {
   println!( "Error type: {:?}", error.kind );
   println!
   (
  "Error location: {} to {}",
  error.location.as_ref().map_or( 0, unilang_parser ::SourceLocation ::start ),
  error.location.as_ref().map_or( 0, unilang_parser ::SourceLocation ::end )
 );
   println!( "Error message: {error}" );
 }
 }

  // Invalid escape sequence
  println!( "\n3. Invalid Escape Sequence: " );
  match parser.parse_repl_input( r#"cmd text :: "invalid \x escape""# )
  {
  Ok( _ ) => println!( "Unexpected success!" ),
  Err( error ) =>
  {
   println!( "Error type: {:?}", error.kind );
   println!
   (
  "Error location: {} to {}",
  error.location.as_ref().map_or( 0, unilang_parser ::SourceLocation ::start ),
  error.location.as_ref().map_or( 0, unilang_parser ::SourceLocation ::end )
 );
   println!( "Error message: {error}" );
 }
 }

  // Empty command path
  println!( "\n4. Empty Command Path: " );
  match parser.parse_repl_input( "" )
  {
  Ok( _ ) => println!( "Unexpected success!" ),
  Err( error ) =>
  {
   println!( "Error type: {:?}", error.kind );
   println!( "Error message: {error}" );
 }
 }

  // Invalid argument format
  println!( "\n5. Invalid Argument Format: " );
  match parser.parse_repl_input( "cmd arg :::invalid" )
  {
  Ok( _ ) => println!( "Unexpected success!" ),
  Err( error ) =>
  {
   println!( "Error type: {:?}", error.kind );
   println!
   (
  "Error location: {} to {}",
  error.location.as_ref().map_or( 0, unilang_parser ::SourceLocation ::start ),
  error.location.as_ref().map_or( 0, unilang_parser ::SourceLocation ::end )
 );
   println!( "Error message: {error}" );
 }
 }

  // Helper function to demonstrate error categorization
  fn categorize_error( error: &unilang_parser ::ParseError ) -> &'static str
  {
  match &error.kind
  {
   ErrorKind ::Syntax( _ ) => "General syntax error",
   ErrorKind ::InvalidEscapeSequence( _ ) => "Invalid escape sequence",
   ErrorKind ::EmptyInstructionSegment => "Empty instruction segment",
   ErrorKind ::TrailingDelimiter => "Trailing delimiter",
   ErrorKind ::Unknown => "Unknown error",
 }
 }

  println!( "\n=== Error Categorization Demo ===" );
  let test_cases = ["invalid..path",
  r#"cmd "unterminated"#,
  "cmd arg :::bad",
  ""];

  for ( i, test_case ) in test_cases.iter().enumerate()
  {
  match parser.parse_repl_input( test_case )
  {
   Ok( _ ) => println!( "Test {} : Unexpected success for '{}'", i + 1, test_case ),
   Err( error ) =>
   {
  println!( "Test {} : {} - {}", i + 1, categorize_error( &error ), error );
 }
 }
 }

  println!( "\n✓ Error handling and diagnostics demonstration complete!" );
}