talexander/organic
1
0
Fork 0
Code Issues Pull Requests Releases Activity
cad2be43bf
organic/src/wasm_test/compare.rs

1896 lines
65 KiB
Rust
Raw Normal View History

Start working on a version of compare based on json values. This will be a better test because it will be testing that what we export to json is equivalent to the elisp AST generated from emacs. Because of these tests, we could also confidently use the wasm structure to elisp.
2023-12-29 16:37:30 +00:00
use std::borrow::Cow;
Move wasm diff structs to their own module.
2023-12-28 00:15:39 +00:00
use super::diff::WasmDiffResult;
use super::diff::WasmDiffStatus;
Starting the wasm_compare macro.
2023-12-27 20:14:42 +00:00
use crate::compare::ElispFact;
use crate::compare::EmacsField;
Invoking wasm_compare_document.
2023-12-27 14:31:54 +00:00
use crate::compare::Token;
Add default implementations for WasmElispCompare.
2023-12-28 00:42:45 +00:00
use crate::wasm::WasmAngleLink;
More of the test structure.
2023-12-27 16:10:40 +00:00
use crate::wasm::WasmAstNode;
Add default implementations for WasmElispCompare.
2023-12-28 00:42:45 +00:00
use crate::wasm::WasmBabelCall;
use crate::wasm::WasmBold;
use crate::wasm::WasmCenterBlock;
use crate::wasm::WasmCitation;
use crate::wasm::WasmCitationReference;
use crate::wasm::WasmClock;
use crate::wasm::WasmCode;
use crate::wasm::WasmComment;
use crate::wasm::WasmCommentBlock;
use crate::wasm::WasmDiarySexp;
Invoking wasm_compare_document.
2023-12-27 14:31:54 +00:00
use crate::wasm::WasmDocument;
Add default implementations for WasmElispCompare.
2023-12-28 00:42:45 +00:00
use crate::wasm::WasmDrawer;
use crate::wasm::WasmDynamicBlock;
use crate::wasm::WasmEntity;
use crate::wasm::WasmExampleBlock;
use crate::wasm::WasmExportBlock;
use crate::wasm::WasmExportSnippet;
use crate::wasm::WasmFixedWidthArea;
use crate::wasm::WasmFootnoteDefinition;
use crate::wasm::WasmFootnoteReference;
Enable child checking.
2023-12-27 21:47:02 +00:00
use crate::wasm::WasmHeadline;
Add default implementations for WasmElispCompare.
2023-12-28 00:42:45 +00:00
use crate::wasm::WasmHorizontalRule;
use crate::wasm::WasmInlineBabelCall;
use crate::wasm::WasmInlineSourceBlock;
use crate::wasm::WasmItalic;
use crate::wasm::WasmKeyword;
use crate::wasm::WasmLatexEnvironment;
use crate::wasm::WasmLatexFragment;
use crate::wasm::WasmLineBreak;
use crate::wasm::WasmNodeProperty;
use crate::wasm::WasmOrgMacro;
Start adding paragraph.
2023-12-27 23:47:59 +00:00
use crate::wasm::WasmParagraph;
Add default implementations for WasmElispCompare.
2023-12-28 00:42:45 +00:00
use crate::wasm::WasmPlainLink;
use crate::wasm::WasmPlainList;
use crate::wasm::WasmPlainListItem;
use crate::wasm::WasmPlainText;
use crate::wasm::WasmPlanning;
use crate::wasm::WasmPropertyDrawer;
use crate::wasm::WasmQuoteBlock;
use crate::wasm::WasmRadioLink;
use crate::wasm::WasmRadioTarget;
use crate::wasm::WasmRegularLink;
Enable child checking.
2023-12-27 21:47:02 +00:00
use crate::wasm::WasmSection;
Add default implementations for WasmElispCompare.
2023-12-28 00:42:45 +00:00
use crate::wasm::WasmSpecialBlock;
use crate::wasm::WasmSrcBlock;
use crate::wasm::WasmStatisticsCookie;
use crate::wasm::WasmStrikeThrough;
use crate::wasm::WasmSubscript;
use crate::wasm::WasmSuperscript;
use crate::wasm::WasmTable;
use crate::wasm::WasmTableCell;
use crate::wasm::WasmTableRow;
use crate::wasm::WasmTarget;
use crate::wasm::WasmTimestamp;
use crate::wasm::WasmUnderline;
use crate::wasm::WasmVerbatim;
use crate::wasm::WasmVerseBlock;
Starting the wasm_compare macro.
2023-12-27 20:14:42 +00:00
use crate::wasm_test::macros::wasm_compare;
Invoking wasm_compare_document.
2023-12-27 14:31:54 +00:00
Remove lifetimes from wasm ast nodes.
2023-12-29 17:49:43 +00:00
pub fn wasm_compare_document<'e, 's, 'w>(
More of the test structure.
2023-12-27 16:10:40 +00:00
source: &'s str,
Remove lifetimes from wasm ast nodes.
2023-12-29 17:49:43 +00:00
emacs: &'e Token<'s>,
wasm: &'w WasmDocument,
Start working on a version of compare based on json values. This will be a better test because it will be testing that what we export to json is equivalent to the elisp AST generated from emacs. Because of these tests, we could also confidently use the wasm structure to elisp.
2023-12-29 16:37:30 +00:00
) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
let wasm_json = serde_json::to_string(&wasm)?;
let wasm_json_parsed = serde_json::from_str(&wasm_json)?;
compare_json_value(&wasm_json_parsed, source, emacs)
}
fn compare_json_value<'b, 's>(
value: &serde_json::Value,
source: &'s str,
emacs: &'b Token<'s>,
) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
match (value, emacs) {
Implement a wrapper type for AST nodes. This is to make it impossible to have a collision for attribute names that are real attributes vs attributes I've added for structure (like children and ast_node).
2023-12-29 16:56:28 +00:00
(serde_json::Value::Object(wasm), Token::List(el)) if wasm.contains_key("ast_node") => {
Start working on a version of compare based on json values. This will be a better test because it will be testing that what we export to json is equivalent to the elisp AST generated from emacs. Because of these tests, we could also confidently use the wasm structure to elisp.
2023-12-29 16:37:30 +00:00
// We hit a regular ast node.
compare_ast_node(source, el, wasm)
}
(serde_json::Value::Null, Token::Atom(_)) => todo!(),
(serde_json::Value::Null, Token::List(_)) => todo!(),
(serde_json::Value::Null, Token::TextWithProperties(_)) => todo!(),
(serde_json::Value::Null, Token::Vector(_)) => todo!(),
(serde_json::Value::Bool(_), Token::Atom(_)) => todo!(),
(serde_json::Value::Bool(_), Token::List(_)) => todo!(),
(serde_json::Value::Bool(_), Token::TextWithProperties(_)) => todo!(),
(serde_json::Value::Bool(_), Token::Vector(_)) => todo!(),
(serde_json::Value::Number(_), Token::Atom(_)) => todo!(),
(serde_json::Value::Number(_), Token::List(_)) => todo!(),
(serde_json::Value::Number(_), Token::TextWithProperties(_)) => todo!(),
(serde_json::Value::Number(_), Token::Vector(_)) => todo!(),
(serde_json::Value::String(_), Token::Atom(_)) => todo!(),
(serde_json::Value::String(_), Token::List(_)) => todo!(),
(serde_json::Value::String(_), Token::TextWithProperties(_)) => todo!(),
(serde_json::Value::String(_), Token::Vector(_)) => todo!(),
(serde_json::Value::Array(_), Token::Atom(_)) => todo!(),
(serde_json::Value::Array(_), Token::List(_)) => todo!(),
(serde_json::Value::Array(_), Token::TextWithProperties(_)) => todo!(),
(serde_json::Value::Array(_), Token::Vector(_)) => todo!(),
(serde_json::Value::Object(_), Token::Atom(_)) => todo!(),
(serde_json::Value::Object(_), Token::List(_)) => todo!(),
(serde_json::Value::Object(_), Token::TextWithProperties(_)) => todo!(),
(serde_json::Value::Object(_), Token::Vector(_)) => todo!(),
}
}
fn compare_ast_node<'b, 's, 'p>(
source: &'s str,
emacs: &'b Vec<Token<'s>>,
wasm: &serde_json::Map<String, serde_json::Value>,
) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
let mut result = WasmDiffResult::default();
let mut emacs_list_iter = emacs.iter();
{
// Compare ast node type.
let emacs_name = emacs_list_iter
.next()
.ok_or("Should have a name as the first child.")?
.as_atom()?;
let wasm_name = wasm
Implement a wrapper type for AST nodes. This is to make it impossible to have a collision for attribute names that are real attributes vs attributes I've added for structure (like children and ast_node).
2023-12-29 16:56:28 +00:00
.get("ast_node")
Start working on a version of compare based on json values. This will be a better test because it will be testing that what we export to json is equivalent to the elisp AST generated from emacs. Because of these tests, we could also confidently use the wasm structure to elisp.
2023-12-29 16:37:30 +00:00
.ok_or("Should have a ast node type.")?
.as_str()
.ok_or("Ast node type should be a string.")?;
result.name = emacs_name.into();
if emacs_name != wasm_name {
result.status.push(WasmDiffStatus::Bad(
format!(
"AST node name mismatch. Emacs=({emacs}) Wasm=({wasm}).",
emacs = emacs_name,
wasm = wasm_name,
)
.into(),
));
}
}
if result.is_bad() {
return Ok(result);
}
let emacs_attributes_map = emacs_list_iter
.next()
.ok_or("Should have an attributes child.")?
.as_map()?;
{
// Compare attribute names.
let emacs_keys: std::collections::BTreeSet<String> = emacs_attributes_map
.keys()
.map(|s| (*s).to_owned())
.collect();
let wasm_keys: std::collections::BTreeSet<String> = wasm
.keys()
.filter(|k| !k.starts_with("__"))
.map(wasm_key_to_emacs_key)
.collect();
let emacs_only_attributes: Vec<&String> = emacs_keys.difference(&wasm_keys).collect();
let wasm_only_attributes: Vec<&String> = wasm_keys.difference(&emacs_keys).collect();
if !emacs_only_attributes.is_empty() {
result.status.push(WasmDiffStatus::Bad(
format!(
"Wasm node lacked field present in elisp node ({name}).",
name = emacs_only_attributes
.iter()
.map(|s| s.as_str())
.intersperse(", ")
.collect::<String>(),
)
.into(),
));
}
if !wasm_only_attributes.is_empty() {
result.status.push(WasmDiffStatus::Bad(
format!(
"Elisp node lacked field present in wasm node ({name}).",
name = wasm_only_attributes
.iter()
.map(|s| s.as_str())
.intersperse(", ")
.collect::<String>(),
)
.into(),
));
}
}
if result.is_bad() {
return Ok(result);
}
{
// Compare attributes.
for attribute_name in wasm
.keys()
.filter(|k| !k.starts_with("__") && k.as_str() != "standard-properties")
{
let mut layer = WasmDiffResult::default();
layer.name = Cow::Owned(attribute_name.clone());
let wasm_attribute_value = wasm
.get(attribute_name)
.ok_or("Key should exist in both wasm and elisp at this point.")?;
let emacs_key = wasm_key_to_emacs_key(attribute_name);
let emacs_attribute_value = *emacs_attributes_map
.get(emacs_key.as_str())
.ok_or("Key should exist in both wasm and elisp at this point.")?;
layer.extend(compare_json_value(
wasm_attribute_value,
source,
emacs_attribute_value,
)?)?;
result.children.push(layer);
}
}
// TODO: compare standard-properties.
// TODO: compare children
Ok(result)
}
fn wasm_key_to_emacs_key<WK: std::fmt::Display>(wasm_key: WK) -> String {
format!(":{key}", key = wasm_key)
}
Remove lifetimes from wasm ast nodes.
2023-12-29 17:49:43 +00:00
// pub fn old_wasm_compare_document<'b, 's, 'p>(
// source: &'s str,
// emacs: &'b Token<'s>,
// wasm: WasmDocument<'s, 'p>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// wasm.compare_ast_node(source, emacs)
// }
// impl<'s, 'p, WAN: WasmElispCompare<'s, 'p>> WasmElispCompare<'s, 'p> for &WAN {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// (*self).compare_ast_node(source, emacs)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmAstNode<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// match self {
// WasmAstNode::Document(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Headline(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Section(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Paragraph(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::PlainList(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::PlainListItem(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::CenterBlock(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::QuoteBlock(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::SpecialBlock(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::DynamicBlock(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::FootnoteDefinition(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Comment(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Drawer(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::PropertyDrawer(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::NodeProperty(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Table(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::TableRow(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::VerseBlock(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::CommentBlock(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::ExampleBlock(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::ExportBlock(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::SrcBlock(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Clock(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::DiarySexp(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Planning(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::FixedWidthArea(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::HorizontalRule(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Keyword(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::BabelCall(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::LatexEnvironment(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Bold(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Italic(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Underline(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::StrikeThrough(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Code(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Verbatim(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::PlainText(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::RegularLink(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::RadioLink(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::RadioTarget(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::PlainLink(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::AngleLink(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::OrgMacro(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Entity(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::LatexFragment(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::ExportSnippet(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::FootnoteReference(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Citation(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::CitationReference(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::InlineBabelCall(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::InlineSourceBlock(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::LineBreak(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Target(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::StatisticsCookie(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Subscript(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Superscript(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::TableCell(inner) => inner.compare_ast_node(source, emacs),
// WasmAstNode::Timestamp(inner) => inner.compare_ast_node(source, emacs),
// }
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmDocument<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// let result = wasm_compare!(
// source,
// emacs,
// self,
// (
// EmacsField::Required(":path"),
// |w| w.path.as_ref().and_then(|p| p.to_str()),
// wasm_compare_property_quoted_string
// ),
// (
// EmacsField::Required(":CATEGORY"),
// |w| w.category.as_ref(),
// wasm_compare_property_quoted_string
// )
// );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmHeadline<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSection<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// let result = wasm_compare!(source, emacs, self,);
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmParagraph<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// let result = wasm_compare!(source, emacs, self,);
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlainList<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlainListItem<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCenterBlock<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmQuoteBlock<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSpecialBlock<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmDynamicBlock<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmFootnoteDefinition<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmComment<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmDrawer<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPropertyDrawer<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmNodeProperty<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTable<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTableRow<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmVerseBlock<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCommentBlock<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmExampleBlock<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmExportBlock<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSrcBlock<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmClock<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmDiarySexp<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlanning<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmFixedWidthArea<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmHorizontalRule<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmKeyword<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmBabelCall<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmLatexEnvironment<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmBold<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmItalic<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmUnderline<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmStrikeThrough<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCode<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmVerbatim<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlainText<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmRegularLink<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmRadioLink<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmRadioTarget<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlainLink<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmAngleLink<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmOrgMacro<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmEntity<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmLatexFragment<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmExportSnippet<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmFootnoteReference<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCitation<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCitationReference<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmInlineBabelCall<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmInlineSourceBlock<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmLineBreak<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTarget<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmStatisticsCookie<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSubscript<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSuperscript<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTableCell<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTimestamp<'s, 'p> {
// fn compare_ast_node<'b>(
// &self,
// source: &'s str,
// emacs: &'b Token<'s>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
// // TODO: Implement this.
// let result = WasmDiffResult::default();
// // let result = wasm_compare!(
// // source,
// // emacs,
// // self,
// // (
// // EmacsField::Required(":path"),
// // |w| w.path.as_ref().and_then(|p| p.to_str()),
// // wasm_compare_property_quoted_string
// // ),
// // (
// // EmacsField::Required(":CATEGORY"),
// // |w| w.category.as_ref(),
// // wasm_compare_property_quoted_string
// // )
// // );
// Ok(result)
// }
// }
Reference in New Issue Copy Permalink