77e0dbb42e
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.
1901 lines
61 KiB
Rust
1901 lines
61 KiB
Rust
use std::borrow::Cow;
|
|
|
|
use super::diff::WasmDiffResult;
|
|
use super::diff::WasmDiffStatus;
|
|
use super::elisp_compare::WasmElispCompare;
|
|
use super::logic::wasm_compare_additional_properties;
|
|
use super::logic::wasm_compare_list;
|
|
use super::logic::wasm_compare_property_quoted_string;
|
|
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>(
|
|
source: &'s str,
|
|
emacs: &'b Token<'s>,
|
|
wasm: WasmDocument<'s, 'p>,
|
|
) -> 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) {
|
|
(serde_json::Value::Object(wasm), Token::List(el)) if wasm.contains_key("__ast_node") => {
|
|
// 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
|
|
.get("__ast_node")
|
|
.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)
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|