feat: Implement type3

src/parse/mod.rs

@@ -1,5 +1,6 @@
 mod type1;
 mod type2;
+mod type3;
 mod util;
 
 use std::{
@@ -61,7 +62,9 @@ where
   S: AsRef<str>,
 {
   let text = text.as_ref();
-  type1::parse(text).or_else(|| type2::parse(text))
+  type1::parse(text)
+    .or_else(|| type2::parse(text))
+    .or_else(|| type3::parse(text))
 }
 
 /// Decompress a manpage if necessary

src/parse/type1.rs

@@ -6,10 +6,8 @@ use super::{util, Flag};
 ///
 /// todo implement fallback and fallback2 like the Fish script
 pub fn parse(page_text: &str) -> Option<Vec<Flag>> {
-  let re = util::regex_for_section(r#""OPTIONS""#);
-  match re.captures(page_text) {
-    Some(captures) => {
-      let content = captures.get(1).unwrap().as_str();
+  match util::get_section(r#""OPTIONS""#, page_text) {
+    Some(content) => {
       let mut flags = Vec::new();
 
       let mut paras = content.split(".PP");

src/parse/type2.rs

@@ -4,13 +4,9 @@ use regex::Regex;
 use super::{util, Flag};
 
 /// Ported from Fish's `Type2ManParser`
-///
-/// TODO actually test this
 pub fn parse(page_text: &str) -> Option<Vec<Flag>> {
-  let re = util::regex_for_section("OPTIONS");
-  match re.captures(page_text) {
-    Some(captures) => {
-      let content = captures.get(1).unwrap().as_str();
+  match util::get_section("OPTIONS", page_text) {
+    Some(content) => {
       let mut flags = Vec::new();
 
       // todo this diverges from the Fish impl for splitting, check if it's okay
@@ -19,7 +15,7 @@ pub fn parse(page_text: &str) -> Option<Vec<Flag>> {
         Regex::new(&format!(r"\.[IT]P( {}i?)?", util::NUM_RE)).unwrap();
       let para_end = Regex::new(r"\.(IP|TP|UNINDENT|UN|SH)").unwrap();
 
-      let mut paras = para_re.split(content);
+      let mut paras = para_re.split(&content);
       paras.next(); // Discard the part before the first option
       for para in paras {
         let data = if let Some(mat) = para_end.find(para) {

src/parse/type3.rs

@@ -0,0 +1,67 @@
+use log::debug;
+use regex::{Regex, RegexBuilder};
+
+use super::{util, Flag};
+
+/// Ported from Fish's `Type3ManParser`
+/// Fish's `Type3ManParser` doesn't handle HP...IP...HP, but the man page for
+/// sed, at least, uses that, so this parser handles that too.
+pub fn parse(page_text: &str) -> Option<Vec<Flag>> {
+  match util::get_section("DESCRIPTION", page_text) {
+    Some(content) => {
+      let mut flags = Vec::new();
+
+      let start_re = RegexBuilder::new(r"\.[HT]P(.*?)(\.[HPT]P|\z)")
+        .dot_matches_new_line(true)
+        .build()
+        .unwrap();
+
+      // Where the last match ended
+      let mut last_end = 0;
+
+      while let Some(mat) = start_re.find_at(&content, last_end) {
+        let data = &content[mat.start() + 3..mat.end()];
+        // Remove the .HP/.TP/.PP at the end
+        // todo this is kinda verbose
+        let end_offset = if data.ends_with(".HP")
+          || data.ends_with(".TP")
+          || data.ends_with(".PP")
+        {
+          3
+        } else {
+          0
+        };
+        let data = &data[..data.len() - end_offset];
+        last_end = mat.end() - end_offset;
+
+        if let Some((options, desc)) = data.split_once(".IP") {
+          // This means there is a .HP before the options
+          let options = util::remove_groff_formatting(options);
+          let desc = util::remove_groff_formatting(desc);
+          if let Some(flag) = util::make_flag(&options, Some(&desc)) {
+            flags.push(flag);
+          }
+        } else {
+          // This means there is a .TP before the options
+          let data = util::remove_groff_formatting(data);
+          let data = data.trim();
+          if let Some((options, desc)) = data.split_once('\n') {
+            if let Some(flag) = util::make_flag(options, Some(desc)) {
+              flags.push(flag);
+            }
+          } else {
+            // todo should this be an error instead?
+            debug!("No description, data: {}", util::truncate(data, 40));
+          }
+        }
+      }
+
+      if flags.is_empty() {
+        None
+      } else {
+        Some(flags)
+      }
+    }
+    None => None,
+  }
+}

src/parse/util.rs

@@ -29,13 +29,17 @@ pub fn trim_desc(desc: &str) -> String {
   }
 }
 
-/// Regex to get the contents of a section with the given title
-pub fn regex_for_section(title: &str) -> Regex {
-  RegexBuilder::new(&format!(r#"\.SH {title}(.*?)(\.SH|\z)"#))
+/// Get the contents of a section with the given title
+pub fn get_section(title: &str, text: &str) -> Option<String> {
+  let re = RegexBuilder::new(&format!(r#"\.SH {title}(.*?)(\.SH|\z)"#))
     .multi_line(true)
     .dot_matches_new_line(true)
     .build()
-    .unwrap()
+    .unwrap();
+  re.captures(text).map(|captures| {
+    let content = captures.get(1).unwrap().as_str();
+    content.strip_suffix(".SH").unwrap_or(content).to_string()
+  })
 }
 
 /// Copied more or less directly from Fish's `remove_groff_formatting`

tests/integration_tests.rs

@@ -54,9 +54,15 @@ fn run_test(shell: &str, outputs: &[&str], args: &[&str]) {
       continue;
     }
 
-    let expected = fs::read(exp_file).unwrap();
-    let got = fs::read(&got_file).unwrap();
-    if expected != got {
+    if exp_file.exists() {
+      let expected = fs::read(exp_file).unwrap();
+      let got = fs::read(&got_file).unwrap();
+      if expected != got {
+        not_match.push(file_name);
+        continue;
+      }
+    } else {
+      println!("No {file_name} found in expected folder");
       not_match.push(file_name);
       continue;
     }
@@ -125,3 +131,8 @@ fn git_json() {
 fn rfcomm_json() {
   run_test("json", &["rfcomm"], &["--cmds", "^rfcomm"]);
 }
+
+#[test]
+fn sed_json() {
+  run_test("json", &["sed"], &["--cmds", "^sed"]);
+}