Skip to content

Commit 12b2fd2

Browse files
zkatzkat
committed
feat(error): Rename KdlParseFailure back to KdlError
1 parent c486cda commit 12b2fd2

File tree

7 files changed

+53
-53
lines changed

7 files changed

+53
-53
lines changed

‎src/document.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@
22
use miette::SourceSpan;
33
use std::fmt::Display;
44

5-
use crate::{FormatConfig, KdlNode, KdlParseFailure, KdlValue};
5+
use crate::{FormatConfig, KdlError, KdlNode, KdlValue};
66

77
/// Represents a KDL
88
/// [`Document`](https://github.com/kdl-org/kdl/blob/main/SPEC.md#document).
@@ -341,7 +341,7 @@ impl KdlDocument {
341341
/// parse the string as a KDL v2 document, and, if that fails, it will try
342342
/// to parse again as a KDL v1 document. If both fail, only the v2 parse
343343
/// errors will be returned.
344-
pub fn parse(s: &str) -> Result<Self, KdlParseFailure> {
344+
pub fn parse(s: &str) -> Result<Self, KdlError> {
345345
#[cfg(not(feature = "v1-fallback"))]
346346
{
347347
crate::v2_parser::try_parse(crate::v2_parser::document, s)
@@ -355,15 +355,15 @@ impl KdlDocument {
355355

356356
/// Parses a KDL v1 string into a document.
357357
#[cfg(feature = "v1")]
358-
pub fn parse_v1(s: &str) -> Result<Self, KdlParseFailure> {
358+
pub fn parse_v1(s: &str) -> Result<Self, KdlError> {
359359
let ret: Result<kdlv1::KdlDocument, kdlv1::KdlError> = s.parse();
360360
ret.map(|x| x.into()).map_err(|e| e.into())
361361
}
362362

363363
/// Takes a KDL v1 document string and returns the same document, but
364364
/// autoformatted into valid KDL v2 syntax.
365365
#[cfg(feature = "v1")]
366-
pub fn v1_to_v2(s: &str) -> Result<String, KdlParseFailure> {
366+
pub fn v1_to_v2(s: &str) -> Result<String, KdlError> {
367367
let mut doc = KdlDocument::parse_v1(s)?;
368368
doc.autoformat();
369369
Ok(doc.to_string())
@@ -386,7 +386,7 @@ impl From<kdlv1::KdlDocument> for KdlDocument {
386386
}
387387

388388
impl std::str::FromStr for KdlDocument {
389-
type Err = KdlParseFailure;
389+
type Err = KdlError;
390390

391391
fn from_str(s: &str) -> Result<Self, Self::Err> {
392392
KdlDocument::parse(s)

‎src/entry.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@
22
use miette::SourceSpan;
33
use std::{fmt::Display, str::FromStr};
44

5-
use crate::{v2_parser, KdlIdentifier, KdlParseFailure, KdlValue};
5+
use crate::{v2_parser, KdlError, KdlIdentifier, KdlValue};
66

77
/// KDL Entries are the "arguments" to KDL nodes: either a (positional)
88
/// [`Argument`](https://github.com/kdl-org/kdl/blob/main/SPEC.md#argument) or
@@ -248,7 +248,7 @@ impl KdlEntry {
248248
/// parse the string as a KDL v2 entry, and, if that fails, it will try
249249
/// to parse again as a KDL v1 entry. If both fail, only the v2 parse
250250
/// errors will be returned.
251-
pub fn parse(s: &str) -> Result<Self, KdlParseFailure> {
251+
pub fn parse(s: &str) -> Result<Self, KdlError> {
252252
#[cfg(not(feature = "v1-fallback"))]
253253
{
254254
v2_parser::try_parse(v2_parser::padded_node_entry, s)
@@ -262,7 +262,7 @@ impl KdlEntry {
262262

263263
/// Parses a KDL v1 string into an entry.
264264
#[cfg(feature = "v1")]
265-
pub fn parse_v1(s: &str) -> Result<Self, KdlParseFailure> {
265+
pub fn parse_v1(s: &str) -> Result<Self, KdlError> {
266266
let ret: Result<kdlv1::KdlEntry, kdlv1::KdlError> = s.parse();
267267
ret.map(|x| x.into()).map_err(|e| e.into())
268268
}
@@ -353,7 +353,7 @@ where
353353
}
354354

355355
impl FromStr for KdlEntry {
356-
type Err = KdlParseFailure;
356+
type Err = KdlError;
357357

358358
fn from_str(s: &str) -> Result<Self, Self::Err> {
359359
KdlEntry::parse(s)

‎src/error.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,7 @@ use {
3636
/// ```
3737
#[derive(Debug, Diagnostic, Clone, Eq, PartialEq, Error)]
3838
#[error("Failed to parse KDL document")]
39-
pub struct KdlParseFailure {
39+
pub struct KdlError {
4040
/// Original input that this failure came from.
4141
#[source_code]
4242
pub input: Arc<String>,
@@ -76,10 +76,10 @@ pub struct KdlDiagnostic {
7676
}
7777

7878
#[cfg(feature = "v1")]
79-
impl From<kdlv1::KdlError> for KdlParseFailure {
79+
impl From<kdlv1::KdlError> for KdlError {
8080
fn from(value: kdlv1::KdlError) -> Self {
8181
let input = Arc::new(value.input);
82-
KdlParseFailure {
82+
KdlError {
8383
input: input.clone(),
8484
diagnostics: vec![KdlDiagnostic {
8585
input,

‎src/identifier.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@
22
use miette::SourceSpan;
33
use std::{fmt::Display, str::FromStr};
44

5-
use crate::{v2_parser, KdlParseFailure, KdlValue};
5+
use crate::{v2_parser, KdlError, KdlValue};
66

77
/// Represents a KDL
88
/// [Identifier](https://github.com/kdl-org/kdl/blob/main/SPEC.md#identifier).
@@ -94,7 +94,7 @@ impl KdlIdentifier {
9494
/// parse the string as a KDL v2 entry, and, if that fails, it will try
9595
/// to parse again as a KDL v1 entry. If both fail, only the v2 parse
9696
/// errors will be returned.
97-
pub fn parse(s: &str) -> Result<Self, KdlParseFailure> {
97+
pub fn parse(s: &str) -> Result<Self, KdlError> {
9898
#[cfg(not(feature = "v1-fallback"))]
9999
{
100100
v2_parser::try_parse(v2_parser::identifier, s)
@@ -108,7 +108,7 @@ impl KdlIdentifier {
108108

109109
/// Parses a KDL v1 string into an entry.
110110
#[cfg(feature = "v1")]
111-
pub fn parse_v1(s: &str) -> Result<Self, KdlParseFailure> {
111+
pub fn parse_v1(s: &str) -> Result<Self, KdlError> {
112112
let ret: Result<kdlv1::KdlIdentifier, kdlv1::KdlError> = s.parse();
113113
ret.map(|x| x.into()).map_err(|e| e.into())
114114
}
@@ -165,7 +165,7 @@ impl From<KdlIdentifier> for String {
165165
}
166166

167167
impl FromStr for KdlIdentifier {
168-
type Err = KdlParseFailure;
168+
type Err = KdlError;
169169

170170
fn from_str(s: &str) -> Result<Self, Self::Err> {
171171
KdlIdentifier::parse(s)

‎src/node.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -10,8 +10,8 @@ use std::{
1010
use miette::SourceSpan;
1111

1212
use crate::{
13-
v2_parser, FormatConfig, KdlDocument, KdlDocumentFormat, KdlEntry, KdlIdentifier,
14-
KdlParseFailure, KdlValue,
13+
v2_parser, FormatConfig, KdlDocument, KdlDocumentFormat, KdlEntry, KdlError, KdlIdentifier,
14+
KdlValue,
1515
};
1616

1717
/// Represents an individual KDL
@@ -332,7 +332,7 @@ impl KdlNode {
332332
/// parse the string as a KDL v2 node, and, if that fails, it will try
333333
/// to parse again as a KDL v1 node. If both fail, only the v2 parse
334334
/// errors will be returned.
335-
pub fn parse(s: &str) -> Result<Self, KdlParseFailure> {
335+
pub fn parse(s: &str) -> Result<Self, KdlError> {
336336
#[cfg(not(feature = "v1-fallback"))]
337337
{
338338
v2_parser::try_parse(v2_parser::padded_node, s)
@@ -346,7 +346,7 @@ impl KdlNode {
346346

347347
/// Parses a KDL v1 string into a document.
348348
#[cfg(feature = "v1")]
349-
pub fn parse_v1(s: &str) -> Result<Self, KdlParseFailure> {
349+
pub fn parse_v1(s: &str) -> Result<Self, KdlError> {
350350
let ret: Result<kdlv1::KdlNode, kdlv1::KdlError> = s.parse();
351351
ret.map(|x| x.into()).map_err(|e| e.into())
352352
}
@@ -753,7 +753,7 @@ impl IndexMut<&str> for KdlNode {
753753
}
754754

755755
impl FromStr for KdlNode {
756-
type Err = KdlParseFailure;
756+
type Err = KdlError;
757757

758758
fn from_str(input: &str) -> Result<Self, Self::Err> {
759759
v2_parser::try_parse(v2_parser::padded_node, input)

‎src/v2_parser.rs

Lines changed: 26 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -20,8 +20,8 @@ use winnow::{
2020
};
2121

2222
use crate::{
23-
KdlDiagnostic, KdlDocument, KdlDocumentFormat, KdlEntry, KdlEntryFormat, KdlIdentifier,
24-
KdlNode, KdlNodeFormat, KdlParseFailure, KdlValue,
23+
KdlDiagnostic, KdlDocument, KdlDocumentFormat, KdlEntry, KdlEntryFormat, KdlError,
24+
KdlIdentifier, KdlNode, KdlNodeFormat, KdlValue,
2525
};
2626

2727
type Input<'a> = Recoverable<Located<&'a str>, KdlParseError>;
@@ -30,7 +30,7 @@ type PResult<T> = winnow::PResult<T, KdlParseError>;
3030
pub(crate) fn try_parse<'a, P: Parser<Input<'a>, T, KdlParseError>, T>(
3131
mut parser: P,
3232
input: &'a str,
33-
) -> Result<T, KdlParseFailure> {
33+
) -> Result<T, KdlError> {
3434
let (_, maybe_val, errs) = parser.recoverable_parse(Located::new(input));
3535
if let (Some(v), true) = (maybe_val, errs.is_empty()) {
3636
Ok(v)
@@ -39,9 +39,9 @@ pub(crate) fn try_parse<'a, P: Parser<Input<'a>, T, KdlParseError>, T>(
3939
}
4040
}
4141

42-
pub(crate) fn failure_from_errs(errs: Vec<KdlParseError>, input: &str) -> KdlParseFailure {
42+
pub(crate) fn failure_from_errs(errs: Vec<KdlParseError>, input: &str) -> KdlError {
4343
let src = Arc::new(String::from(input));
44-
KdlParseFailure {
44+
KdlError {
4545
input: src.clone(),
4646
diagnostics: errs
4747
.into_iter()
@@ -2050,13 +2050,13 @@ impl_negatable_unsigned!(u8, u16, u32, u64, u128, usize);
20502050
mod failure_tests {
20512051
use miette::Severity;
20522052

2053-
use crate::{KdlDiagnostic, KdlDocument, KdlParseFailure};
2053+
use crate::{KdlDiagnostic, KdlDocument, KdlError};
20542054
use std::sync::Arc;
20552055

20562056
#[test]
20572057
fn bad_node_name_test() -> miette::Result<()> {
20582058
let input = Arc::new("foo { bar; { baz; }; }".to_string());
2059-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2059+
let res: Result<KdlDocument, KdlError> = input.parse();
20602060
// super::_print_diagnostic(res);
20612061
// return Ok(());
20622062
assert_eq!(
@@ -2076,7 +2076,7 @@ mod failure_tests {
20762076
))
20772077
);
20782078
let input = Arc::new("no/de 1 {\n 1 2 foo\n bad#\n}".to_string());
2079-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2079+
let res: Result<KdlDocument, KdlError> = input.parse();
20802080
// super::_print_diagnostic(res);
20812081
// return Ok(());
20822082
assert_eq!(
@@ -2133,7 +2133,7 @@ mod failure_tests {
21332133
#[test]
21342134
fn bad_entry_number_test() -> miette::Result<()> {
21352135
let input = Arc::new("node 1asdf 2".to_string());
2136-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2136+
let res: Result<KdlDocument, KdlError> = input.parse();
21372137
// super::_print_diagnostic(res);
21382138
// return Ok(());
21392139
assert_eq!(
@@ -2152,7 +2152,7 @@ mod failure_tests {
21522152
);
21532153

21542154
let input = Arc::new("node 0x1asdf 2".to_string());
2155-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2155+
let res: Result<KdlDocument, KdlError> = input.parse();
21562156
assert_eq!(
21572157
res,
21582158
Err(mkfail(
@@ -2169,7 +2169,7 @@ mod failure_tests {
21692169
);
21702170

21712171
let input = Arc::new("node 0o1asdf 2".to_string());
2172-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2172+
let res: Result<KdlDocument, KdlError> = input.parse();
21732173
assert_eq!(
21742174
res,
21752175
Err(mkfail(
@@ -2186,7 +2186,7 @@ mod failure_tests {
21862186
);
21872187

21882188
let input = Arc::new("node 0b1asdf 2".to_string());
2189-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2189+
let res: Result<KdlDocument, KdlError> = input.parse();
21902190
assert_eq!(
21912191
res,
21922192
Err(mkfail(
@@ -2203,7 +2203,7 @@ mod failure_tests {
22032203
);
22042204

22052205
let input = Arc::new("node 1.0asdf 2".to_string());
2206-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2206+
let res: Result<KdlDocument, KdlError> = input.parse();
22072207
assert_eq!(
22082208
res,
22092209
Err(mkfail(
@@ -2220,7 +2220,7 @@ mod failure_tests {
22202220
);
22212221

22222222
let input = Arc::new("node 1.asdf 2".to_string());
2223-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2223+
let res: Result<KdlDocument, KdlError> = input.parse();
22242224
assert_eq!(
22252225
res,
22262226
Err(mkfail(
@@ -2237,7 +2237,7 @@ mod failure_tests {
22372237
);
22382238

22392239
let input = Arc::new("node 1.0easdf 2".to_string());
2240-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2240+
let res: Result<KdlDocument, KdlError> = input.parse();
22412241
assert_eq!(
22422242
res,
22432243
Err(mkfail(
@@ -2263,7 +2263,7 @@ mod failure_tests {
22632263
#[test]
22642264
fn bad_string_test() -> miette::Result<()> {
22652265
let input = Arc::new("node \" 1".to_string());
2266-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2266+
let res: Result<KdlDocument, KdlError> = input.parse();
22672267
assert_eq!(
22682268
res,
22692269
Err(mkfail(
@@ -2280,7 +2280,7 @@ mod failure_tests {
22802280
);
22812281

22822282
let input = Arc::new("node \"foo\"1".to_string());
2283-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2283+
let res: Result<KdlDocument, KdlError> = input.parse();
22842284
// if let Err(e) = res {
22852285
// println!("{:?}", miette::Report::from(e));
22862286
// }
@@ -2300,7 +2300,7 @@ mod failure_tests {
23002300
);
23012301

23022302
let input = Arc::new("node \"\nlet's do multiline!\"".to_string());
2303-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2303+
let res: Result<KdlDocument, KdlError> = input.parse();
23042304
assert_eq!(
23052305
res,
23062306
Err(mkfail(
@@ -2331,7 +2331,7 @@ mod failure_tests {
23312331
#[test]
23322332
fn bad_child_test() -> miette::Result<()> {
23332333
let input = Arc::new("node {".to_string());
2334-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2334+
let res: Result<KdlDocument, KdlError> = input.parse();
23352335
// _print_diagnostic(res);
23362336
// return Ok(());
23372337
assert_eq!(
@@ -2350,7 +2350,7 @@ mod failure_tests {
23502350
);
23512351

23522352
let input = Arc::new("node {}}".to_string());
2353-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2353+
let res: Result<KdlDocument, KdlError> = input.parse();
23542354
// _print_diagnostic(res);
23552355
// return Ok(());
23562356
// println!("{res:#?}");
@@ -2370,7 +2370,7 @@ mod failure_tests {
23702370
);
23712371

23722372
let input = Arc::new("node }{".to_string());
2373-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2373+
let res: Result<KdlDocument, KdlError> = input.parse();
23742374
// _print_diagnostic(res);
23752375
// return Ok(());
23762376
assert_eq!(
@@ -2421,7 +2421,7 @@ mod failure_tests {
24212421
);
24222422

24232423
let input = Arc::new("node {\n".to_string());
2424-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2424+
let res: Result<KdlDocument, KdlError> = input.parse();
24252425
// _print_diagnostic(res);
24262426
// return Ok(());
24272427
assert_eq!(
@@ -2450,7 +2450,7 @@ mod failure_tests {
24502450
);
24512451

24522452
let input = Arc::new("node {\nnode2{{}}".to_string());
2453-
let res: Result<KdlDocument, KdlParseFailure> = input.parse();
2453+
let res: Result<KdlDocument, KdlError> = input.parse();
24542454
// _print_diagnostic(res);
24552455
// return Ok(());
24562456
println!("{res:#?}");
@@ -2504,13 +2504,13 @@ mod failure_tests {
25042504
Ok(())
25052505
}
25062506

2507-
fn mkfail(input: Arc<String>, diagnostics: Vec<KdlDiagnostic>) -> KdlParseFailure {
2508-
KdlParseFailure { input, diagnostics }
2507+
fn mkfail(input: Arc<String>, diagnostics: Vec<KdlDiagnostic>) -> KdlError {
2508+
KdlError { input, diagnostics }
25092509
}
25102510
}
25112511

25122512
#[cfg(test)]
2513-
fn _print_diagnostic<T>(res: Result<T, KdlParseFailure>) {
2513+
fn _print_diagnostic<T>(res: Result<T, KdlError>) {
25142514
if let Err(e) = res {
25152515
println!("{:?}", miette::Report::from(e));
25162516
}

0 commit comments

Comments
 (0)