sexpfmt 0.2.2

A command-line tool to format S-expressions
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use std::fmt;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum SexpfmtError {
	#[error("IO error: {source}")]
	Io {
		#[from]
		source: std::io::Error,
	},

	#[error("UTF-8 encoding error: {source}")]
	Utf8 {
		#[from]
		source: std::string::FromUtf8Error,
	},

	#[error("Form reader error{}: {message}", position.as_ref().map(|p| format!(" at {}", p)).unwrap_or_default())]
	FormReader {
		message: String,
		position: Option<Loc>,
		#[source]
		source: Option<Box<dyn std::error::Error + Send + Sync>>,
	},

	#[error("Parse error at {position}: {message}")]
	Parse {
		message: String,
		position: Loc,
		#[source]
		source: Option<Box<dyn std::error::Error + Send + Sync>>,
	},

	#[error("Mismatched bookends at {position}: got {got:?}, expected {expected:?}")]
	MismatchedBookends {
		position: Loc,
		got: crate::SExpBookendStyle,
		expected: crate::SExpBookendStyle,
	},

	#[error("Unexpected EOF at {position}: {unclosed_count} unclosed bookends")]
	UnexpectedEof {
		position: Loc,
		unclosed_count: usize,
	},

	#[error("Invalid input at {position}: {message}")]
	InvalidInput { message: String, position: Loc },
}

impl fmt::Display for Loc {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		write!(
			f,
			"line {}, column {} (offset {})",
			self.line, self.column, self.offset
		)
	}
}

impl SexpfmtError {
	pub fn form_reader_error<S: Into<String>>(
		message: S,
		position: Option<Loc>,
		source: Option<Box<dyn std::error::Error + Send + Sync>>,
	) -> Self {
		Self::FormReader {
			message: message.into(),
			position,
			source,
		}
	}

	pub fn parse_error<S: Into<String>>(
		message: S,
		position: Loc,
		source: Option<Box<dyn std::error::Error + Send + Sync>>,
	) -> Self {
		Self::Parse {
			message: message.into(),
			position,
			source,
		}
	}

	pub fn mismatched_bookends(
		position: Loc,
		got: crate::SExpBookendStyle,
		expected: crate::SExpBookendStyle,
	) -> Self {
		Self::MismatchedBookends {
			position,
			got,
			expected,
		}
	}

	pub fn unexpected_eof(position: Loc, unclosed_count: usize) -> Self {
		Self::UnexpectedEof {
			position,
			unclosed_count,
		}
	}

	pub fn invalid_input<S: Into<String>>(message: S, position: Loc) -> Self {
		Self::InvalidInput {
			message: message.into(),
			position,
		}
	}
}

// Convenience type alias
pub type Result<T> = std::result::Result<T, SexpfmtError>;

// InputLoc is used for error messages:
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Loc {
	offset: usize,
	line: usize,
	column: usize,
}
impl Loc {
	pub fn new(offset: usize, line: usize, column: usize) -> Self {
		Self {
			offset,
			line,
			column,
		}
	}
	pub fn offset(self) -> usize {
		self.offset
	}
	pub fn line(self) -> usize {
		self.line
	}
	pub fn column(self) -> usize {
		self.column
	}

	pub fn in_form(start_of_form_loc: Self, span: nom_locate::LocatedSpan<&str>) -> Self {
		// Calculate position within the form based on nom's position
		let offset_in_form = span.location_offset();
		let line_in_form = span.location_line() as usize;
		let column_in_form = span.get_column();

		// Adjust position to be relative to the original input
		Self {
			offset: start_of_form_loc.offset() + offset_in_form,
			line: start_of_form_loc.line() + line_in_form - 1,
			column: if line_in_form == 1 {
				start_of_form_loc.column() + column_in_form - 1
			} else {
				column_in_form
			},
		}
	}
}