Compare value.

src/compare/diff.rs

@@ -2273,8 +2273,6 @@ fn compare_fixed_width_area<'b, 's>(
     let mut this_status = DiffStatus::Good;
     let mut message = None;
 
-    // TODO: Compare :value
-
     // TODO: Compare :caption
     // Compare name
     let name = get_property_quoted_string(emacs, ":name")?;
@@ -2286,6 +2284,18 @@ fn compare_fixed_width_area<'b, 's>(
         ));
     }
 
+    // Compare value
+    let value = get_property_quoted_string(emacs, ":value")?
+        .ok_or("Fixed width area should have a value.")?;
+    let rust_value = rust.get_value();
+    if value != rust_value {
+        this_status = DiffStatus::Bad;
+        message = Some(format!(
+            "Value mismatch (emacs != rust) {:?} != {:?}",
+            value, rust_value
+        ));
+    }
+
     Ok(DiffResult {
         status: this_status,
         name: rust.get_elisp_name(),

src/parser/fixed_width_area.rs

@@ -1,19 +1,17 @@
 use nom::branch::alt;
-use nom::bytes::complete::is_not;
 use nom::bytes::complete::tag;
-use nom::character::complete::line_ending;
+use nom::character::complete::anychar;
 use nom::character::complete::space0;
-use nom::combinator::eof;
 use nom::combinator::not;
 use nom::combinator::recognize;
 use nom::multi::many0;
+use nom::multi::many_till;
 use nom::sequence::preceded;
 use nom::sequence::tuple;
 
 use super::keyword::affiliated_keyword;
 use super::org_source::OrgSource;
 use super::util::get_name;
-use super::util::only_space1;
 use super::util::org_line_ending;
 use crate::context::parser_with_context;
 use crate::context::RefContext;
@@ -31,16 +29,30 @@ pub(crate) fn fixed_width_area<'b, 'g, 'r, 's>(
     let (input, affiliated_keywords) = many0(affiliated_keyword)(input)?;
     let fixed_width_area_line_matcher = parser_with_context!(fixed_width_area_line)(context);
     let exit_matcher = parser_with_context!(exit_matcher_parser)(context);
-    let (remaining, _first_line) = fixed_width_area_line_matcher(input)?;
-    let (remaining, _remaining_lines) =
+    let (remaining, first_line) = fixed_width_area_line_matcher(input)?;
+    let (remaining, mut remaining_lines) =
         many0(preceded(not(exit_matcher), fixed_width_area_line_matcher))(remaining)?;
 
     let source = get_consumed(input, remaining);
+    let mut value = Vec::with_capacity(remaining_lines.len() + 1);
+    let last_line = remaining_lines.pop();
+    if let Some(last_line) = last_line {
+        value.push(Into::<&str>::into(first_line));
+        value.extend(remaining_lines.into_iter().map(Into::<&str>::into));
+        let last_line = Into::<&str>::into(last_line);
+        // Trim the line ending from the final line.
+        value.push(&last_line[..(last_line.len() - 1)])
+    } else {
+        // Trim the line ending from the only line.
+        let only_line = Into::<&str>::into(first_line);
+        value.push(&only_line[..(only_line.len() - 1)])
+    }
     Ok((
         remaining,
         FixedWidthArea {
             source: source.into(),
             name: get_name(&affiliated_keywords),
+            value,
         },
     ))
 }
@@ -51,14 +63,13 @@ fn fixed_width_area_line<'b, 'g, 'r, 's>(
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
     start_of_line(input)?;
-    let (remaining, _indent) = space0(input)?;
-    let (remaining, _) = tuple((
-        tag(":"),
-        alt((recognize(tuple((only_space1, is_not("\r\n")))), space0)),
-        org_line_ending,
-    ))(remaining)?;
-    let source = get_consumed(input, remaining);
-    Ok((remaining, source))
+    let (remaining, _) = tuple((space0, tag(":")))(input)?;
+    if let Ok((remaining, line_break)) = org_line_ending(remaining) {
+        return Ok((remaining, line_break));
+    }
+    let (remaining, _) = tag(" ")(remaining)?;
+    let (remaining, value) = recognize(many_till(anychar, org_line_ending))(remaining)?;
+    Ok((remaining, value))
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
@@ -68,7 +79,7 @@ pub(crate) fn detect_fixed_width_area<'s>(input: OrgSource<'s>) -> Res<OrgSource
         start_of_line,
         space0,
         tag(":"),
-        alt((tag(" "), line_ending, eof)),
+        alt((tag(" "), org_line_ending)),
     ))(input)?;
     Ok((input, ()))
 }

src/types/lesser_element.rs

@@ -117,6 +117,7 @@ pub struct Planning<'s> {
 pub struct FixedWidthArea<'s> {
     pub source: &'s str,
     pub name: Option<&'s str>,
+    pub value: Vec<&'s str>,
 }
 
 #[derive(Debug)]
@@ -267,7 +268,18 @@ impl<'s> StandardProperties<'s> for LatexEnvironment<'s> {
 
 impl<'s> Comment<'s> {
     pub fn get_value(&self) -> String {
-        // TODO: maybe we should handle parsing here instead of storing the parsing result in the AST since I imagine getting the value of comments won't be a common operation.
+        let final_size = self.value.iter().map(|line| line.len()).sum();
+        let mut ret = String::with_capacity(final_size);
+        for line in &self.value {
+            ret.push_str(line);
+        }
+
+        ret
+    }
+}
+
+impl<'s> FixedWidthArea<'s> {
+    pub fn get_value(&self) -> String {
         let final_size = self.value.iter().map(|line| line.len()).sum();
         let mut ret = String::with_capacity(final_size);
         for line in &self.value {