diff --git a/src/wasm/mod.rs b/src/wasm/mod.rs index 0b9ddef1..5eb1b9b2 100644 --- a/src/wasm/mod.rs +++ b/src/wasm/mod.rs @@ -65,12 +65,66 @@ mod verse_block; pub use additional_property::AdditionalProperties; pub use additional_property::AdditionalPropertyValue; +pub(crate) use angle_link::WasmAngleLink; pub use ast_node::WasmAstNode; +pub(crate) use babel_call::WasmBabelCall; +pub(crate) use bold::WasmBold; +pub(crate) use center_block::WasmCenterBlock; +pub(crate) use citation::WasmCitation; +pub(crate) use citation_reference::WasmCitationReference; +pub(crate) use clock::WasmClock; +pub(crate) use code::WasmCode; +pub(crate) use comment::WasmComment; +pub(crate) use comment_block::WasmCommentBlock; +pub(crate) use diary_sexp::WasmDiarySexp; pub use document::WasmDocument; +pub(crate) use drawer::WasmDrawer; +pub(crate) use dynamic_block::WasmDynamicBlock; +pub(crate) use entity::WasmEntity; +pub(crate) use example_block::WasmExampleBlock; +pub(crate) use export_block::WasmExportBlock; +pub(crate) use export_snippet::WasmExportSnippet; +pub(crate) use fixed_width_area::WasmFixedWidthArea; +pub(crate) use footnote_definition::WasmFootnoteDefinition; +pub(crate) use footnote_reference::WasmFootnoteReference; pub(crate) use headline::WasmHeadline; +pub(crate) use horizontal_rule::WasmHorizontalRule; +pub(crate) use inline_babel_call::WasmInlineBabelCall; +pub(crate) use inline_source_block::WasmInlineSourceBlock; +pub(crate) use italic::WasmItalic; +pub(crate) use keyword::WasmKeyword; +pub(crate) use latex_environment::WasmLatexEnvironment; +pub(crate) use latex_fragment::WasmLatexFragment; +pub(crate) use line_break::WasmLineBreak; +pub(crate) use node_property::WasmNodeProperty; +pub(crate) use org_macro::WasmOrgMacro; pub(crate) use paragraph::WasmParagraph; pub use parse_result::ParseResult; +pub(crate) use plain_link::WasmPlainLink; +pub(crate) use plain_list::WasmPlainList; +pub(crate) use plain_list_item::WasmPlainListItem; +pub(crate) use plain_text::WasmPlainText; +pub(crate) use planning::WasmPlanning; +pub(crate) use property_drawer::WasmPropertyDrawer; +pub(crate) use quote_block::WasmQuoteBlock; +pub(crate) use radio_link::WasmRadioLink; +pub(crate) use radio_target::WasmRadioTarget; +pub(crate) use regular_link::WasmRegularLink; pub(crate) use section::WasmSection; +pub(crate) use special_block::WasmSpecialBlock; +pub(crate) use src_block::WasmSrcBlock; pub(crate) use standard_properties::WasmStandardProperties; +pub(crate) use statistics_cookie::WasmStatisticsCookie; +pub(crate) use strike_through::WasmStrikeThrough; +pub(crate) use subscript::WasmSubscript; +pub(crate) use superscript::WasmSuperscript; +pub(crate) use table::WasmTable; +pub(crate) use table_cell::WasmTableCell; +pub(crate) use table_row::WasmTableRow; +pub(crate) use target::WasmTarget; +pub(crate) use timestamp::WasmTimestamp; pub use to_wasm::ToWasm; pub use to_wasm::ToWasmContext; +pub(crate) use underline::WasmUnderline; +pub(crate) use verbatim::WasmVerbatim; +pub(crate) use verse_block::WasmVerseBlock; diff --git a/src/wasm_test/compare.rs b/src/wasm_test/compare.rs index 64dd260a..b301f6b2 100644 --- a/src/wasm_test/compare.rs +++ b/src/wasm_test/compare.rs @@ -8,11 +8,65 @@ use super::logic::wasm_compare_standard_properties; use crate::compare::ElispFact; use crate::compare::EmacsField; use crate::compare::Token; +use crate::wasm::WasmAngleLink; use crate::wasm::WasmAstNode; +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; use crate::wasm::WasmDocument; +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; use crate::wasm::WasmHeadline; +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; use crate::wasm::WasmParagraph; +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; use crate::wasm::WasmSection; +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; use crate::wasm_test::macros::wasm_compare; pub fn wasm_compare_document<'b, 's, 'p>( @@ -44,60 +98,60 @@ impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmAstNode<'s, 'p> { 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(_) => todo!(), - WasmAstNode::PlainListItem(_) => todo!(), - WasmAstNode::CenterBlock(_) => todo!(), - WasmAstNode::QuoteBlock(_) => todo!(), - WasmAstNode::SpecialBlock(_) => todo!(), - WasmAstNode::DynamicBlock(_) => todo!(), - WasmAstNode::FootnoteDefinition(_) => todo!(), - WasmAstNode::Comment(_) => todo!(), - WasmAstNode::Drawer(_) => todo!(), - WasmAstNode::PropertyDrawer(_) => todo!(), - WasmAstNode::NodeProperty(_) => todo!(), - WasmAstNode::Table(_) => todo!(), - WasmAstNode::TableRow(_) => todo!(), - WasmAstNode::VerseBlock(_) => todo!(), - WasmAstNode::CommentBlock(_) => todo!(), - WasmAstNode::ExampleBlock(_) => todo!(), - WasmAstNode::ExportBlock(_) => todo!(), - WasmAstNode::SrcBlock(_) => todo!(), - WasmAstNode::Clock(_) => todo!(), - WasmAstNode::DiarySexp(_) => todo!(), - WasmAstNode::Planning(_) => todo!(), - WasmAstNode::FixedWidthArea(_) => todo!(), - WasmAstNode::HorizontalRule(_) => todo!(), - WasmAstNode::Keyword(_) => todo!(), - WasmAstNode::BabelCall(_) => todo!(), - WasmAstNode::LatexEnvironment(_) => todo!(), - WasmAstNode::Bold(_) => todo!(), - WasmAstNode::Italic(_) => todo!(), - WasmAstNode::Underline(_) => todo!(), - WasmAstNode::StrikeThrough(_) => todo!(), - WasmAstNode::Code(_) => todo!(), - WasmAstNode::Verbatim(_) => todo!(), - WasmAstNode::PlainText(_) => todo!(), - WasmAstNode::RegularLink(_) => todo!(), - WasmAstNode::RadioLink(_) => todo!(), - WasmAstNode::RadioTarget(_) => todo!(), - WasmAstNode::PlainLink(_) => todo!(), - WasmAstNode::AngleLink(_) => todo!(), - WasmAstNode::OrgMacro(_) => todo!(), - WasmAstNode::Entity(_) => todo!(), - WasmAstNode::LatexFragment(_) => todo!(), - WasmAstNode::ExportSnippet(_) => todo!(), - WasmAstNode::FootnoteReference(_) => todo!(), - WasmAstNode::Citation(_) => todo!(), - WasmAstNode::CitationReference(_) => todo!(), - WasmAstNode::InlineBabelCall(_) => todo!(), - WasmAstNode::InlineSourceBlock(_) => todo!(), - WasmAstNode::LineBreak(_) => todo!(), - WasmAstNode::Target(_) => todo!(), - WasmAstNode::StatisticsCookie(_) => todo!(), - WasmAstNode::Subscript(_) => todo!(), - WasmAstNode::Superscript(_) => todo!(), - WasmAstNode::TableCell(_) => todo!(), - WasmAstNode::Timestamp(_) => todo!(), + 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), } } } @@ -133,6 +187,7 @@ impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmHeadline<'s, 'p> { source: &'s str, emacs: &'b Token<'s>, ) -> Result, Box> { + // TODO: Implement this. let result = WasmDiffResult::default(); // let result = wasm_compare!( // source, @@ -172,6 +227,1504 @@ impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmParagraph<'s, 'p> { source: &'s str, emacs: &'b Token<'s>, ) -> Result, Box> { + // 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 WasmPlainList<'s, 'p> { + fn compare_ast_node<'b>( + &self, + source: &'s str, + emacs: &'b Token<'s>, + ) -> Result, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // 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, Box> { + // TODO: Implement this. let result = WasmDiffResult::default(); // let result = wasm_compare!( // source,