src/compare/diff.rs

@@ -60,7 +60,6 @@ use crate::types::TableCell;
 use crate::types::TableRow;
 use crate::types::Target;
 use crate::types::Timestamp;
-use crate::types::TodoKeywordType;
 use crate::types::Underline;
 use crate::types::Verbatim;
 use crate::types::VerseBlock;
@@ -511,9 +510,9 @@ fn compare_heading<'s>(
         .map(Token::as_atom)
         .map_or(Ok(None), |r| r.map(Some))?
         .unwrap_or("nil");
-    match (todo_keyword, &rust.todo_keyword, unquote(todo_keyword)) {
+    match (todo_keyword, rust.todo_keyword, unquote(todo_keyword)) {
         ("nil", None, _) => {}
-        (_, Some((_rust_todo_type, rust_todo)), Ok(emacs_todo)) if emacs_todo == *rust_todo => {}
+        (_, Some(rust_todo), Ok(emacs_todo)) if emacs_todo == rust_todo => {}
         (emacs_todo, rust_todo, _) => {
             this_status = DiffStatus::Bad;
             message = Some(format!(
@@ -522,24 +521,6 @@ fn compare_heading<'s>(
             ));
         }
     };
-    // Compare todo-type
-    let todo_type = get_property(emacs, ":todo-type")?
-        .map(Token::as_atom)
-        .map_or(Ok(None), |r| r.map(Some))?
-        .unwrap_or("nil");
-    // todo-type is an unquoted string either todo, done, or nil
-    match (todo_type, &rust.todo_keyword) {
-        ("nil", None) => {}
-        ("todo", Some((TodoKeywordType::Todo, _))) => {}
-        ("done", Some((TodoKeywordType::Done, _))) => {}
-        (emacs_todo, rust_todo) => {
-            this_status = DiffStatus::Bad;
-            message = Some(format!(
-                "(emacs != rust) {:?} != {:?}",
-                emacs_todo, rust_todo
-            ));
-        }
-    };
 
     // Compare title
     let title = get_property(emacs, ":title")?.ok_or("Missing :title attribute.")?;
@@ -551,7 +532,7 @@ fn compare_heading<'s>(
         .collect::<Result<Vec<_>, _>>()?;
     child_status.push(artificial_diff_scope("title".to_owned(), title_status)?);
 
-    // TODO: Compare priority, :footnote-section-p, :archivedp, :commentedp
+    // TODO: Compare todo-type, priority, :footnote-section-p, :archivedp, :commentedp
 
     // Compare section
     let section_status = children
@@ -1411,30 +1392,7 @@ fn compare_keyword<'s>(
         Ok(_) => {}
     };
 
-    let key = unquote(
-        get_property(emacs, ":key")?
-            .ok_or("Emacs keywords should have a :key")?
-            .as_atom()?,
-    )?;
-    if key != rust.key.to_uppercase() {
-        this_status = DiffStatus::Bad;
-        message = Some(format!(
-            "Mismatchs keyword keys (emacs != rust) {:?} != {:?}",
-            key, rust.key
-        ))
-    }
-    let value = unquote(
-        get_property(emacs, ":value")?
-            .ok_or("Emacs keywords should have a :value")?
-            .as_atom()?,
-    )?;
-    if value != rust.value {
-        this_status = DiffStatus::Bad;
-        message = Some(format!(
-            "Mismatchs keyword values (emacs != rust) {:?} != {:?}",
-            value, rust.value
-        ))
-    }
+    // TODO: Compare key and value
 
     Ok(DiffResult {
         status: this_status,

src/context/context.rs

@@ -90,10 +90,7 @@ impl<'g, 'r, 's> Context<'g, 'r, 's> {
         self.global_settings
     }
 
-    pub fn with_global_settings<'gg>(
-        &self,
-        new_settings: &'gg GlobalSettings<'gg, 's>,
-    ) -> Context<'gg, 'r, 's> {
+    pub fn with_global_settings<'gg>(&self, new_settings: &'gg GlobalSettings<'gg, 's>) -> Context<'gg, 'r, 's> {
         Context {
             global_settings: new_settings,
             tree: self.tree.clone(),

src/context/file_access_interface.rs

@@ -18,6 +18,7 @@ impl FileAccessInterface for LocalFileAccessInterface {
             .map(PathBuf::as_path)
             .map(|pb| pb.join(path))
             .unwrap_or_else(|| PathBuf::from(path));
+        eprintln!("Reading file: {}", final_path.display());
         Ok(std::fs::read_to_string(final_path)?)
     }
 }

src/context/global_settings.rs

@@ -1,5 +1,3 @@
-use std::collections::BTreeSet;
-
 use super::FileAccessInterface;
 use super::LocalFileAccessInterface;
 use crate::types::Object;
@@ -10,8 +8,6 @@ use crate::types::Object;
 pub struct GlobalSettings<'g, 's> {
     pub radio_targets: Vec<&'g Vec<Object<'s>>>,
     pub file_access: &'g dyn FileAccessInterface,
-    pub in_progress_todo_keywords: BTreeSet<String>,
-    pub complete_todo_keywords: BTreeSet<String>,
 }
 
 impl<'g, 's> GlobalSettings<'g, 's> {
@@ -21,8 +17,6 @@ impl<'g, 's> GlobalSettings<'g, 's> {
             file_access: &LocalFileAccessInterface {
                 working_directory: None,
             },
-            in_progress_todo_keywords: BTreeSet::new(),
-            complete_todo_keywords: BTreeSet::new(),
         }
     }
 }

src/main.rs

@@ -111,13 +111,11 @@ fn run_parse_on_file<P: AsRef<Path>>(org_path: P) -> Result<(), Box<dyn std::err
         .ok_or("Should be contained inside a directory.")?;
     let org_contents = std::fs::read_to_string(org_path)?;
     let org_contents = org_contents.as_str();
-    let file_access_interface = LocalFileAccessInterface {
-        working_directory: Some(parent_directory.to_path_buf()),
-    };
-    let global_settings = {
-        let mut global_settings = GlobalSettings::default();
-        global_settings.file_access = &file_access_interface;
-        global_settings
+    let global_settings = GlobalSettings {
+        radio_targets: Vec::new(),
+        file_access: &LocalFileAccessInterface {
+            working_directory: Some(parent_directory.to_path_buf()),
+        },
     };
     let rust_parsed = parse_with_settings(org_contents, &global_settings)?;
     let org_sexp = emacs_parse_file_org_document(org_path)?;
@@ -150,13 +148,11 @@ fn run_parse_on_file<P: AsRef<Path>>(org_path: P) -> Result<(), Box<dyn std::err
         .ok_or("Should be contained inside a directory.")?;
     let org_contents = std::fs::read_to_string(org_path)?;
     let org_contents = org_contents.as_str();
-    let file_access_interface = LocalFileAccessInterface {
-        working_directory: Some(parent_directory.to_path_buf()),
-    };
-    let global_settings = {
-        let mut global_settings = GlobalSettings::default();
-        global_settings.file_access = &file_access_interface;
-        global_settings
+    let global_settings = GlobalSettings {
+        radio_targets: Vec::new(),
+        file_access: &LocalFileAccessInterface {
+            working_directory: Some(parent_directory.to_path_buf()),
+        },
     };
     let rust_parsed = parse_with_settings(org_contents, &global_settings)?;
     println!("{:#?}", rust_parsed);

src/parser/document.rs

@@ -18,7 +18,6 @@ use nom::multi::many_till;
 use nom::multi::separated_list1;
 use nom::sequence::tuple;
 
-use super::in_buffer_settings::apply_in_buffer_settings;
 use super::in_buffer_settings::scan_for_in_buffer_settings;
 use super::org_source::OrgSource;
 use super::token::AllTokensIterator;
@@ -51,7 +50,6 @@ use crate::types::Element;
 use crate::types::Heading;
 use crate::types::Object;
 use crate::types::Section;
-use crate::types::TodoKeywordType;
 
 /// Parse a full org-mode document.
 ///
@@ -126,15 +124,7 @@ fn document_org_source<'b, 'g, 'r, 's>(
         final_settings.extend(setup_file_settings);
     }
     final_settings.extend(document_settings);
-    let new_settings = apply_in_buffer_settings(final_settings, context.get_global_settings())
-        .map_err(|_err| {
-            nom::Err::Error(CustomError::MyError(MyError(
-                "TODO: make this take an owned string so I can dump err.to_string() into it."
-                    .into(),
-            )))
-        })?;
-    let new_context = context.with_global_settings(&new_settings);
-    let context = &new_context;
+    // TODO: read the keywords into settings and apply them to the GlobalSettings.
 
     let (remaining, document) =
         _document(context, input).map(|(rem, out)| (Into::<&str>::into(rem), out))?;
@@ -347,9 +337,8 @@ fn _heading<'b, 'g, 'r, 's>(
         Heading {
             source: source.into(),
             stars: star_count,
-            todo_keyword: maybe_todo_keyword.map(|((todo_keyword_type, todo_keyword), _ws)| {
-                (todo_keyword_type, Into::<&str>::into(todo_keyword))
-            }),
+            todo_keyword: maybe_todo_keyword
+                .map(|(todo_keyword, _ws)| Into::<&str>::into(todo_keyword)),
             title,
             tags: heading_tags,
             children,
@@ -373,7 +362,7 @@ fn headline<'b, 'g, 'r, 's>(
     (
         usize,
         OrgSource<'s>,
-        Option<((TodoKeywordType, OrgSource<'s>), OrgSource<'s>)>,
+        Option<(OrgSource<'s>, OrgSource<'s>)>,
         Vec<Object<'s>>,
         Vec<&'s str>,
     ),
@@ -383,6 +372,7 @@ fn headline<'b, 'g, 'r, 's>(
         exit_matcher: &headline_title_end,
     });
     let parser_context = context.with_additional_node(&parser_context);
+    let standard_set_object_matcher = parser_with_context!(standard_set_object)(&parser_context);
 
     let (
         remaining,
@@ -393,11 +383,8 @@ fn headline<'b, 'g, 'r, 's>(
             *star_count > parent_stars
         }),
         space1,
-        opt(tuple((
-            parser_with_context!(heading_keyword)(&parser_context),
-            space1,
-        ))),
-        many1(parser_with_context!(standard_set_object)(&parser_context)),
+        opt(tuple((heading_keyword, space1))),
+        many1(standard_set_object_matcher),
         opt(tuple((space0, tags))),
         space0,
         alt((line_ending, eof)),
@@ -446,49 +433,9 @@ fn single_tag<'r, 's>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>>
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn heading_keyword<'b, 'g, 'r, 's>(
-    context: RefContext<'b, 'g, 'r, 's>,
-    input: OrgSource<'s>,
-) -> Res<OrgSource<'s>, (TodoKeywordType, OrgSource<'s>)> {
-    let global_settings = context.get_global_settings();
-    if global_settings.in_progress_todo_keywords.is_empty()
-        && global_settings.complete_todo_keywords.is_empty()
-    {
-        alt((
-            map(tag("TODO"), |capture| (TodoKeywordType::Todo, capture)),
-            map(tag("DONE"), |capture| (TodoKeywordType::Done, capture)),
-        ))(input)
-    } else {
-        for todo_keyword in global_settings
-            .in_progress_todo_keywords
-            .iter()
-            .map(String::as_str)
-        {
-            let result = tag::<_, _, CustomError<_>>(todo_keyword)(input);
-            match result {
-                Ok((remaining, ent)) => {
-                    return Ok((remaining, (TodoKeywordType::Todo, ent)));
-                }
-                Err(_) => {}
-            }
-        }
-        for todo_keyword in global_settings
-            .complete_todo_keywords
-            .iter()
-            .map(String::as_str)
-        {
-            let result = tag::<_, _, CustomError<_>>(todo_keyword)(input);
-            match result {
-                Ok((remaining, ent)) => {
-                    return Ok((remaining, (TodoKeywordType::Done, ent)));
-                }
-                Err(_) => {}
-            }
-        }
-        Err(nom::Err::Error(CustomError::MyError(MyError(
-            "NoTodoKeyword".into(),
-        ))))
-    }
+fn heading_keyword<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
+    // TODO: This should take into account the value of "#+TODO:" ref https://orgmode.org/manual/Per_002dfile-keywords.html and possibly the configurable variable org-todo-keywords ref https://orgmode.org/manual/Workflow-states.html. Case is significant.
+    alt((tag("TODO"), tag("DONE")))(input)
 }
 
 impl<'s> Document<'s> {

src/parser/in_buffer_settings.rs

@@ -6,11 +6,9 @@ use nom::multi::many0;
 use nom::multi::many_till;
 
 use super::keyword::filtered_keyword;
-use super::keyword_todo::todo_keywords;
 use super::OrgSource;
 use crate::error::Res;
 use crate::types::Keyword;
-use crate::GlobalSettings;
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn scan_for_in_buffer_settings<'s>(
@@ -43,27 +41,3 @@ fn in_buffer_settings_key<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSou
         tag_no_case("typ_todo"),
     ))(input)
 }
-
-pub fn apply_in_buffer_settings<'g, 's, 'sf>(
-    keywords: Vec<Keyword<'sf>>,
-    original_settings: &'g GlobalSettings<'g, 's>,
-) -> Result<GlobalSettings<'g, 's>, String> {
-    let mut new_settings = original_settings.clone();
-
-    for kw in keywords.iter().filter(|kw| {
-        kw.key.eq_ignore_ascii_case("todo")
-            || kw.key.eq_ignore_ascii_case("seq_todo")
-            || kw.key.eq_ignore_ascii_case("typ_todo")
-    }) {
-        let (_, (in_progress_words, complete_words)) =
-            todo_keywords(kw.value).map_err(|err| err.to_string())?;
-        new_settings
-            .in_progress_todo_keywords
-            .extend(in_progress_words.into_iter().map(str::to_string));
-        new_settings
-            .complete_todo_keywords
-            .extend(complete_words.into_iter().map(str::to_string));
-    }
-
-    Ok(new_settings)
-}

src/parser/keyword_todo.rs

@@ -12,18 +12,14 @@ use nom::sequence::tuple;
 
 use crate::error::Res;
 
-// ref https://orgmode.org/manual/Per_002dfile-keywords.html
-// ref https://orgmode.org/manual/Workflow-states.html
-// Case is significant.
-
 /// Parses the text in the value of a #+TODO keyword.
 ///
 /// Example input: "foo bar baz | lorem ipsum"
-pub fn todo_keywords<'s>(input: &'s str) -> Res<&'s str, (Vec<&'s str>, Vec<&'s str>)> {
-    let (remaining, mut before_pipe_words) = separated_list0(space1, todo_keyword_word)(input)?;
+pub fn keyword_todo<'s>(input: &'s str) -> Res<&'s str, (Vec<&'s str>, Vec<&'s str>)> {
+    let (remaining, mut before_pipe_words) = separated_list0(space1, keyword_word)(input)?;
     let (remaining, after_pipe_words) = opt(tuple((
         tuple((space0, tag("|"), space0)),
-        separated_list0(space1, todo_keyword_word),
+        separated_list0(space1, keyword_word),
     )))(remaining)?;
     let (remaining, _eol) = alt((line_ending, eof))(remaining)?;
     if let Some((_pipe, after_pipe_words)) = after_pipe_words {
@@ -43,7 +39,7 @@ pub fn todo_keywords<'s>(input: &'s str) -> Res<&'s str, (Vec<&'s str>, Vec<&'s
     }
 }
 
-fn todo_keyword_word<'s>(input: &'s str) -> Res<&'s str, &'s str> {
+fn keyword_word<'s>(input: &'s str) -> Res<&'s str, &'s str> {
     verify(take_till(|c| " \t\r\n|".contains(c)), |result: &str| {
         !result.is_empty()
     })(input)
@@ -55,7 +51,7 @@ mod tests {
     #[test]
     fn before_and_after() -> Result<(), Box<dyn std::error::Error>> {
         let input = "foo bar baz | lorem ipsum";
-        let (remaining, (before_pipe_words, after_pipe_words)) = todo_keywords(input)?;
+        let (remaining, (before_pipe_words, after_pipe_words)) = keyword_todo(input)?;
         assert_eq!(remaining, "");
         assert_eq!(before_pipe_words, vec!["foo", "bar", "baz"]);
         assert_eq!(after_pipe_words, vec!["lorem", "ipsum"]);
@@ -65,7 +61,7 @@ mod tests {
     #[test]
     fn no_pipe() -> Result<(), Box<dyn std::error::Error>> {
         let input = "foo bar baz";
-        let (remaining, (before_pipe_words, after_pipe_words)) = todo_keywords(input)?;
+        let (remaining, (before_pipe_words, after_pipe_words)) = keyword_todo(input)?;
         assert_eq!(remaining, "");
         assert_eq!(before_pipe_words, vec!["foo", "bar"]);
         assert_eq!(after_pipe_words, vec!["baz"]);
@@ -75,7 +71,7 @@ mod tests {
     #[test]
     fn early_pipe() -> Result<(), Box<dyn std::error::Error>> {
         let input = "| foo bar baz";
-        let (remaining, (before_pipe_words, after_pipe_words)) = todo_keywords(input)?;
+        let (remaining, (before_pipe_words, after_pipe_words)) = keyword_todo(input)?;
         assert_eq!(remaining, "");
         assert_eq!(before_pipe_words, Vec::<&str>::new());
         assert_eq!(after_pipe_words, vec!["foo", "bar", "baz"]);
@@ -85,7 +81,7 @@ mod tests {
     #[test]
     fn late_pipe() -> Result<(), Box<dyn std::error::Error>> {
         let input = "foo bar baz |";
-        let (remaining, (before_pipe_words, after_pipe_words)) = todo_keywords(input)?;
+        let (remaining, (before_pipe_words, after_pipe_words)) = keyword_todo(input)?;
         assert_eq!(remaining, "");
         assert_eq!(before_pipe_words, vec!["foo", "bar", "baz"]);
         assert_eq!(after_pipe_words, Vec::<&str>::new());

src/types/document.rs

@@ -13,7 +13,7 @@ pub struct Document<'s> {
 pub struct Heading<'s> {
     pub source: &'s str,
     pub stars: usize,
-    pub todo_keyword: Option<(TodoKeywordType, &'s str)>,
+    pub todo_keyword: Option<&'s str>,
     // TODO: add todo-type enum
     pub title: Vec<Object<'s>>,
     pub tags: Vec<&'s str>,
@@ -32,12 +32,6 @@ pub enum DocumentElement<'s> {
     Section(Section<'s>),
 }
 
-#[derive(Debug)]
-pub enum TodoKeywordType {
-    Todo,
-    Done,
-}
-
 impl<'s> Source<'s> for Document<'s> {
     fn get_source(&'s self) -> &'s str {
         self.source

src/types/mod.rs

@@ -8,7 +8,6 @@ pub use document::Document;
 pub use document::DocumentElement;
 pub use document::Heading;
 pub use document::Section;
-pub use document::TodoKeywordType;
 pub use element::Element;
 pub use greater_element::Drawer;
 pub use greater_element::DynamicBlock;