75 lines
2.4 KiB
Rust
75 lines
2.4 KiB
Rust
use std::{fs, path::Path};
|
|
|
|
use pretty_assertions::assert_eq;
|
|
use reconcile::{CursorPosition, TextWithCursors, reconcile_with_cursors};
|
|
use serde::Deserialize;
|
|
|
|
/// ExampleDocument represents a test case for the reconciliation process.
|
|
/// It contains a parent string, left and right strings with cursor positions,
|
|
/// and the expected result after reconciliation.
|
|
///
|
|
/// '|' characters in the left, right, and expected strings are treated as
|
|
/// cursor positions and are converted into `CursorPosition` objects.
|
|
#[derive(Debug, Deserialize, Clone, PartialEq, Eq)]
|
|
pub struct ExampleDocument {
|
|
parent: String,
|
|
left: String,
|
|
right: String,
|
|
expected: String,
|
|
}
|
|
|
|
impl ExampleDocument {
|
|
pub fn from_yaml(path: &Path) -> Self {
|
|
let file = fs::File::open(path).expect("Failed to open example file");
|
|
serde_yaml::from_reader(file).expect("Failed to parse example file")
|
|
}
|
|
|
|
pub fn parent(&self) -> String { self.parent.clone() }
|
|
|
|
pub fn left(&self) -> TextWithCursors<'static> {
|
|
ExampleDocument::string_to_text_with_cursors(&self.left)
|
|
}
|
|
|
|
pub fn right(&self) -> TextWithCursors<'static> {
|
|
ExampleDocument::string_to_text_with_cursors(&self.right)
|
|
}
|
|
|
|
pub fn assert_eq(&self, result: TextWithCursors<'static>) {
|
|
let result_str = ExampleDocument::text_with_cursors_to_string(&result);
|
|
assert_eq!(result_str, self.expected);
|
|
}
|
|
|
|
pub fn assert_eq_without_cursors(&self, result: &str) {
|
|
assert_eq!(
|
|
result,
|
|
ExampleDocument::string_to_text_with_cursors(&self.expected).text,
|
|
);
|
|
}
|
|
|
|
fn text_with_cursors_to_string<'a>(text: &TextWithCursors<'a>) -> String {
|
|
let mut result = text.text.clone().into_owned();
|
|
for (i, cursor) in text.cursors.iter().enumerate() {
|
|
result.insert(cursor.char_index + i, '|');
|
|
}
|
|
result
|
|
}
|
|
|
|
fn string_to_text_with_cursors(text: &str) -> TextWithCursors<'static> {
|
|
let cursors = Self::parse_cursors(&text);
|
|
let text = text.replace("|", "");
|
|
TextWithCursors::new_owned(text, cursors)
|
|
}
|
|
|
|
fn parse_cursors(text: &str) -> Vec<CursorPosition> {
|
|
let mut cursors = Vec::new();
|
|
for (i, c) in text.chars().enumerate() {
|
|
if c == '|' {
|
|
cursors.push(CursorPosition {
|
|
id: 0,
|
|
char_index: i - cursors.len(),
|
|
});
|
|
}
|
|
}
|
|
cursors
|
|
}
|
|
}
|