Compare warning delay and repeater.

src/compare/diff.rs

@@ -72,6 +72,8 @@ use crate::types::PropertyDrawer;
 use crate::types::RadioLink;
 use crate::types::RadioTarget;
 use crate::types::RegularLink;
+use crate::types::RepeaterType;
+use crate::types::RepeaterWarningDelayValueType;
 use crate::types::Section;
 use crate::types::SrcBlock;
 use crate::types::StandardProperties;
@@ -84,6 +86,7 @@ use crate::types::TableCell;
 use crate::types::TableRow;
 use crate::types::Target;
 use crate::types::Time;
+use crate::types::TimeUnit;
 use crate::types::Timestamp;
 use crate::types::TimestampRangeType;
 use crate::types::TimestampType;
@@ -91,6 +94,7 @@ use crate::types::TodoKeywordType;
 use crate::types::Underline;
 use crate::types::Verbatim;
 use crate::types::VerseBlock;
+use crate::types::WarningDelayType;
 use crate::types::Year;
 use crate::types::YearInner;
 
@@ -2304,18 +2308,104 @@ fn compare_timestamp<'b, 's>(
         ));
     }
 
-    // TODO: Compare :repeater-type :repeater-value :repeater-unit :warning-type :warning-value :warning-unit
-    //
-    // :type unquoted atom either diary, active, inactive, active-range, or inactive-range.
-    // :range-type unquoted atom either nil, daterange
-    // :raw-value quoted string of the source
-    // :*-start :*-end unquoted integers
-    // :repeater-type optional unquoted atom with value cumulate
-    // :repeater-value unquoted integer
-    // :repeater-unit unquoted atom with value week
-    // :warning-type optional unquoted atom with value all
-    // :warning-value unquoted integer
-    // :warning-unit unquoted atom with value day
+    // Compare repeater
+    let repeater_type = get_property_unquoted_atom(emacs, ":repeater-type")?;
+    let repeater_value: Option<RepeaterWarningDelayValueType> =
+        get_property_numeric(emacs, ":repeater-value")?;
+    let repeater_unit = get_property_unquoted_atom(emacs, ":repeater-unit")?;
+    let rust_repeater_type = rust
+        .repeater
+        .as_ref()
+        .map(|repeater| &repeater.repeater_type);
+    let rust_repeater_value = rust.repeater.as_ref().map(|repeater| repeater.value);
+    let rust_repeater_unit = rust.repeater.as_ref().map(|repeater| &repeater.unit);
+    match (repeater_type, rust_repeater_type) {
+        (Some("cumulate"), Some(RepeaterType::Cumulative)) => {}
+        (Some("catch-up"), Some(RepeaterType::CatchUp)) => {}
+        (Some("restart"), Some(RepeaterType::Restart)) => {}
+        (None, None) => {}
+        _ => {
+            this_status = DiffStatus::Bad;
+            message = Some(format!(
+                "Repeater type mismatch (emacs != rust) {:?} != {:?}",
+                repeater_type, rust_repeater_type
+            ));
+        }
+    }
+    if repeater_value != rust_repeater_value {
+        this_status = DiffStatus::Bad;
+        message = Some(format!(
+            "Repeater value mismatch (emacs != rust) {:?} != {:?}",
+            repeater_value, rust_repeater_value
+        ));
+    }
+    match (repeater_unit, rust_repeater_unit) {
+        (Some("hour"), Some(TimeUnit::Hour)) => {}
+        (Some("day"), Some(TimeUnit::Day)) => {}
+        (Some("week"), Some(TimeUnit::Week)) => {}
+        (Some("month"), Some(TimeUnit::Month)) => {}
+        (Some("year"), Some(TimeUnit::Year)) => {}
+        (None, None) => {}
+        _ => {
+            this_status = DiffStatus::Bad;
+            message = Some(format!(
+                "Repeater unit mismatch (emacs != rust) {:?} != {:?}",
+                repeater_unit, rust_repeater_unit
+            ));
+        }
+    }
+
+    // Compare warning_delay
+    let warning_delay_type = get_property_unquoted_atom(emacs, ":warning-type")?;
+    let warning_delay_value: Option<RepeaterWarningDelayValueType> =
+        get_property_numeric(emacs, ":warning-value")?;
+    let warning_delay_unit = get_property_unquoted_atom(emacs, ":warning-unit")?;
+    let rust_warning_delay_type = rust
+        .warning_delay
+        .as_ref()
+        .map(|warning_delay| &warning_delay.warning_delay_type);
+    let rust_warning_delay_value = rust
+        .warning_delay
+        .as_ref()
+        .map(|warning_delay| warning_delay.value);
+    let rust_warning_delay_unit = rust
+        .warning_delay
+        .as_ref()
+        .map(|warning_delay| &warning_delay.unit);
+    match (warning_delay_type, rust_warning_delay_type) {
+        (Some("all"), Some(WarningDelayType::All)) => {}
+        (Some("first"), Some(WarningDelayType::First)) => {}
+        (None, None) => {}
+        _ => {
+            this_status = DiffStatus::Bad;
+            message = Some(format!(
+                "Warning delay type mismatch (emacs != rust) {:?} != {:?}",
+                warning_delay_type, rust_warning_delay_type
+            ));
+        }
+    }
+    if warning_delay_value != rust_warning_delay_value {
+        this_status = DiffStatus::Bad;
+        message = Some(format!(
+            "Warning delay value mismatch (emacs != rust) {:?} != {:?}",
+            warning_delay_value, rust_warning_delay_value
+        ));
+    }
+    match (warning_delay_unit, rust_warning_delay_unit) {
+        (Some("hour"), Some(TimeUnit::Hour)) => {}
+        (Some("day"), Some(TimeUnit::Day)) => {}
+        (Some("week"), Some(TimeUnit::Week)) => {}
+        (Some("month"), Some(TimeUnit::Month)) => {}
+        (Some("year"), Some(TimeUnit::Year)) => {}
+        (None, None) => {}
+        _ => {
+            this_status = DiffStatus::Bad;
+            message = Some(format!(
+                "Warning delay unit mismatch (emacs != rust) {:?} != {:?}",
+                warning_delay_unit, rust_warning_delay_unit
+            ));
+        }
+    }
 
     Ok(DiffResult {
         status: this_status,