feat(Sections): adds breaking changes

kbknapp · kbknapp · commit 66dd7adc81b3 · 2015-10-24T20:57:00.000-04:00
Closes #5
diff --git a/src/clog.rs b/src/clog.rs
@@ -69,6 +69,9 @@ pub struct Clog {
     pub regex: Regex,
     /// The regex used to get closes issue links
     pub closes_regex: Regex,
+    /// The regex used to get closes issue links
+    pub breaks_regex: Regex,
+    pub breaking_regex: Regex,
     /// The format to output the changelog in (Defaults to Markdown)
     pub out_format: ChangelogFormat
 }
@@ -92,6 +95,8 @@ impl fmt::Debug for Clog {
             git_work_tree: {:?}
             regex: {:?}
             closes_regex: {:?}
+            breaks_regex: {:?}
+            breaking_regex: {:?}
             out_format: {:?}
         }}",
         self.grep,
@@ -110,6 +115,8 @@ impl fmt::Debug for Clog {
         self.git_work_tree,
         self.regex,
         self.closes_regex,
+        self.breaks_regex,
+        self.breaking_regex,
         self.out_format,
         )
     }
@@ -124,7 +131,7 @@ impl Clog {
         sections.insert("Bug Fixes".to_owned(), vec!["fx".to_owned(), "fix".to_owned()]);
         sections.insert("Performance".to_owned(), vec!["perf".to_owned()]);
         sections.insert("Unknown".to_owned(), vec!["unk".to_owned()]);
-        sections.insert("Breaks".to_owned(), vec![]);
+        sections.insert("Breaking Changes".to_owned(), vec!["breaks".to_owned()]);
 
         Clog {
             grep: format!("{}BREAKING'",
@@ -150,7 +157,9 @@ impl Clog {
             git_dir: None,
             git_work_tree: None,
             regex: regex!(r"^([^:\(]+?)(?:\(([^:\)]*?)?\))?:(.*)"),
-            closes_regex: regex!(r"(?:Closes|Fixes|Resolves)\s((?:#(\d+)(?:,\s)?)+)")
+            closes_regex: regex!(r"(?:Closes|Fixes|Resolves)\s((?:#(\d+)(?:,\s)?)+)"),
+            breaks_regex: regex!(r"(?:Breaks|Broke)\s((?:#(\d+)(?:,\s)?)+)"),
+            breaking_regex: regex!(r"(?i:breaking)")
         }
     }
 
@@ -774,7 +783,7 @@ impl Clog {
     }
 
     fn parse_raw_commit(&self, commit_str: &str) -> Commit {
-        let mut lines = commit_str.split('\n');
+        let mut lines = commit_str.lines();
 
         let hash = lines.next().unwrap_or("").to_owned();
 
@@ -789,16 +798,29 @@ impl Clog {
                 }
                 None => (Some(""), Some(""), self.section_for("unk").clone()),
             };
-        let closes = lines.filter_map(|line| self.closes_regex.captures(line))
-                          .map(|caps| caps.at(2).unwrap_or("").to_owned())
-                          .collect();
+        let mut closes = vec![];
+        let mut breaks = vec![];
+        for line in lines {
+            if let Some(caps) = self.closes_regex.captures(line) {
+                if let Some(cap) = caps.at(2) {
+                    closes.push(cap.to_owned());
+                }
+            }
+            if let Some(caps) = self.breaks_regex.captures(line) {
+                if let Some(cap) = caps.at(2) {
+                    breaks.push(cap.to_owned());
+                }
+            } else if self.breaking_regex.captures(line).is_some() {
+                breaks.push("".to_owned());
+            }
+        }
 
         Commit {
             hash: hash,
             subject: subject.unwrap().to_owned(),
             component: component.unwrap_or("").to_owned(),
             closes: closes,
-            breaks: vec![],
+            breaks: breaks,
             commit_type: commit_type
         }
     }
diff --git a/src/fmt/json_writer.rs b/src/fmt/json_writer.rs
@@ -124,7 +124,7 @@ impl<'a> JsonWriter<'a> {
                            .commit_link(&*entry.hash, &*options.repo)
                 ).unwrap();
 
-                if entry.closes.len() > 0 {
+                if !entry.closes.is_empty() {
                     write!(self.0, "[").unwrap();
                     let mut c_it = entry.closes.iter().peekable();
                     while let Some(issue) = c_it.next() {
@@ -140,9 +140,31 @@ impl<'a> JsonWriter<'a> {
                             debugln!("There are no more close commits, no comma required");
                         }
                     }
+                    write!(self.0,
+                        "],").unwrap();
+                }  else {
+                    write!(self.0, "null,").unwrap();
+                }
+                write!(self.0 , "\"breaks\":").unwrap();
+                if !entry.breaks.is_empty() {
+                    write!(self.0, "[").unwrap();
+                    let mut c_it = entry.closes.iter().peekable();
+                    while let Some(issue) = c_it.next() {
+                        write!(self.0,
+                            "{{\"issue\":{},\"issue_link\":{:?}}}",
+                            issue,
+                            options.link_style.issue_link(issue, &options.repo)
+                        ).unwrap();
+                        if c_it.peek().is_some() {
+                            debugln!("There are more breaks commits, adding comma");
+                            write!(self.0, ",").unwrap();
+                        } else {
+                            debugln!("There are no more breaks commits, no comma required");
+                        }
+                    }
                     write!(self.0,
                         "]}}").unwrap();
-                } else {
+                }  else {
                     write!(self.0, "null}}").unwrap();
                 }
                 if e_it.peek().is_some() {
diff --git a/src/fmt/md_writer.rs b/src/fmt/md_writer.rs
@@ -133,7 +133,7 @@ impl<'a> MarkdownWriter<'a> {
                     return Err(Error::WriteErr);
                 }
 
-                if entry.closes.len() > 0 {
+                if !entry.closes.is_empty() {
                     let closes_string = entry.closes.iter()
                                                     .map(|s| format!("[#{}]({})",
                                                         &*s,
@@ -145,6 +145,21 @@ impl<'a> MarkdownWriter<'a> {
                         return Err(Error::WriteErr);
                     }
                 }
+                if !entry.breaks.is_empty() {
+                    let breaks_string = entry.breaks.iter()
+                                                    .map(|s| format!("[#{}]({})",
+                                                        &*s,
+                                                        options.link_style.issue_link(&*s, &options.repo)))
+                                                    .collect::<Vec<String>>()
+                                                    .join(", ");
+
+                    // 5 = "[#]()" i.e. a commit message that only said "BREAKING"
+                    if breaks_string.len() != 5 {
+                        if let Err(..) = write!(self.0 , ", breaks {}", breaks_string) {
+                            return Err(Error::WriteErr);
+                        }
+                    }
+                }
 
                 if let Err(..) = write!(self.0 , ")\n") {
                     return Err(Error::WriteErr);
diff --git a/src/sectionmap.rs b/src/sectionmap.rs
@@ -21,7 +21,7 @@ impl SectionMap {
     /// # use std::fs::File;
     /// # use clog::{Clog, SectionMap};
     /// # use clog::fmt::{FormatWriter, MarkdownWriter};
-    /// let clog = Clog::new().unwrap_or_else(|e| { 
+    /// let clog = Clog::new().unwrap_or_else(|e| {
     ///     e.exit();
     /// });
     ///
@@ -34,9 +34,9 @@ impl SectionMap {
     ///
     /// // Create the MarkdownWriter
     /// let mut writer = MarkdownWriter::new(&mut file);
-    /// 
+    ///
     /// // Use the MarkdownWriter to write the changelog
-    /// clog.write_changelog_with(&mut writer).unwrap_or_else(|e| { 
+    /// clog.write_changelog_with(&mut writer).unwrap_or_else(|e| {
     ///     e.exit();
     /// });
     /// ```
@@ -45,11 +45,16 @@ impl SectionMap {
             sections: HashMap::new()
         };
 
-        commits.into_iter().map(|entry| {
+        for entry in commits {
+            if !entry.breaks.is_empty() {
+                let comp_map = sm.sections.entry("Breaking Changes".to_owned()).or_insert(BTreeMap::new());
+                let sec_map = comp_map.entry(entry.component.clone()).or_insert(vec![]);
+                sec_map.push(entry.clone());
+            }
             let comp_map = sm.sections.entry(entry.commit_type.clone()).or_insert(BTreeMap::new());
             let sec_map = comp_map.entry(entry.component.clone()).or_insert(vec![]);
             sec_map.push(entry);
-        }).collect::<Vec<_>>();
+        }
 
         sm
     }
