compare_properties example block.

src/compare/compare_field.rs

@@ -13,6 +13,10 @@ use super::util::get_property_numeric;
 use super::util::get_property_quoted_string;
 use super::util::get_property_unquoted_atom;
 use crate::types::AstNode;
+use crate::types::CharOffsetInLine;
+use crate::types::LineNumber;
+use crate::types::RetainLabels;
+use crate::types::SwitchNumberLines;
 
 #[derive(Debug)]
 pub(crate) enum EmacsField<'s> {
@@ -376,3 +380,115 @@ where
     }
     Ok(ComparePropertiesResult::NoChange)
 }
+
+pub(crate) fn compare_property_number_lines<
+    'b,
+    's,
+    'x,
+    'y,
+    R,
+    RG: Fn(R) -> Option<&'y SwitchNumberLines>,
+>(
+    _source: &'s str,
+    emacs: &'b Token<'s>,
+    rust_node: R,
+    emacs_field: &'x str,
+    rust_value_getter: RG,
+) -> Result<ComparePropertiesResult<'b, 's>, Box<dyn std::error::Error>> {
+    let number_lines = get_property(emacs, emacs_field)?;
+    let rust_value = rust_value_getter(rust_node);
+    match (number_lines, &rust_value) {
+        (None, None) => {}
+        (Some(number_lines), Some(rust_number_lines)) => {
+            let token_list = number_lines.as_list()?;
+            let number_type = token_list
+                .get(0)
+                .map(Token::as_atom)
+                .map_or(Ok(None), |r| r.map(Some))?
+                .ok_or(":number-lines should have a type.")?;
+            let number_value = token_list
+                .get(2)
+                .map(Token::as_atom)
+                .map_or(Ok(None), |r| r.map(Some))?
+                .map(|val| val.parse::<LineNumber>())
+                .map_or(Ok(None), |r| r.map(Some))?
+                .ok_or(":number-lines should have a value.")?;
+            match (number_type, number_value, rust_number_lines) {
+                ("new", emacs_val, SwitchNumberLines::New(rust_val)) if emacs_val == *rust_val => {}
+                ("continued", emacs_val, SwitchNumberLines::Continued(rust_val))
+                    if emacs_val == *rust_val => {}
+                _ => {
+                    let this_status = DiffStatus::Bad;
+                    let message = Some(format!(
+                        "{} mismatch (emacs != rust) {:?} != {:?}",
+                        emacs_field, number_lines, rust_value
+                    ));
+                    return Ok(ComparePropertiesResult::SelfChange(this_status, message));
+                }
+            }
+        }
+        _ => {
+            let this_status = DiffStatus::Bad;
+            let message = Some(format!(
+                "{} mismatch (emacs != rust) {:?} != {:?}",
+                emacs_field, number_lines, rust_value
+            ));
+            return Ok(ComparePropertiesResult::SelfChange(this_status, message));
+        }
+    };
+
+    Ok(ComparePropertiesResult::NoChange)
+}
+
+pub(crate) fn compare_property_retain_labels<'b, 's, 'x, 'y, R, RG: Fn(R) -> &'y RetainLabels>(
+    _source: &'s str,
+    emacs: &'b Token<'s>,
+    rust_node: R,
+    emacs_field: &'x str,
+    rust_value_getter: RG,
+) -> Result<ComparePropertiesResult<'b, 's>, Box<dyn std::error::Error + 's>> {
+    let rust_value = rust_value_getter(rust_node);
+    let retain_labels = get_property_unquoted_atom(emacs, ":retain-labels")?;
+    if let Some(retain_labels) = retain_labels {
+        if retain_labels == "t" {
+            match rust_value {
+                RetainLabels::Yes => {}
+                _ => {
+                    let this_status = DiffStatus::Bad;
+                    let message = Some(format!(
+                        "{} mismatch (emacs != rust) {:?} != {:?}",
+                        emacs_field, retain_labels, rust_value
+                    ));
+                    return Ok(ComparePropertiesResult::SelfChange(this_status, message));
+                }
+            }
+        } else {
+            let retain_labels: CharOffsetInLine = get_property_numeric(emacs, ":retain-labels")?.expect("Cannot be None or else the earlier get_property_unquoted_atom would have been None.");
+            match (retain_labels, rust_value) {
+                (e, RetainLabels::Keep(r)) if e == *r => {}
+                _ => {
+                    let this_status = DiffStatus::Bad;
+                    let message = Some(format!(
+                        "{} mismatch (emacs != rust) {:?} != {:?}",
+                        emacs_field, retain_labels, rust_value
+                    ));
+                    return Ok(ComparePropertiesResult::SelfChange(this_status, message));
+                }
+            }
+        }
+    } else {
+        match rust_value {
+            RetainLabels::No => {}
+            _ => {
+                let this_status = DiffStatus::Bad;
+                let message = Some(format!(
+                    "{} mismatch (emacs != rust) {:?} != {:?}",
+                    emacs_field, retain_labels, rust_value
+                ));
+                return Ok(ComparePropertiesResult::SelfChange(this_status, message));
+            }
+        }
+    }
+
+    Ok(ComparePropertiesResult::NoChange)
+}