src/issues.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 // Objects for seeking through a char stream for occurences of TODO and FIXME.
  12 // Depending on the loaded configuration, may also check that these have an
  13 // associated issue number.
  14
  15 use std::fmt;
  16
  17 static TO_DO_CHARS: &'static [char] = &['T', 'O', 'D', 'O'];
  18 static FIX_ME_CHARS: &'static [char] = &['F', 'I', 'X', 'M', 'E'];
  19
  20 #[derive(Clone, Copy)]
  21 pub enum ReportTactic {
  22     Always,
  23     Unnumbered,
  24     Never,
  25 }
  26
  27 impl ReportTactic {
  28     fn is_enabled(&self) -> bool {
  29         match *self {
  30             ReportTactic::Always => true,
  31             ReportTactic::Unnumbered => true,
  32             ReportTactic::Never => false
  33         }
  34     }
  35 }
  36
  37 impl_enum_decodable!(ReportTactic, Always, Unnumbered, Never);
  38
  39 #[derive(Clone, Copy)]
  40 enum Seeking {
  41     Issue {
  42         todo_idx: usize,
  43         fixme_idx: usize,
  44     },
  45     Number {
  46         issue: Issue,
  47         part: NumberPart,
  48     },
  49 }
  50
  51 #[derive(Clone, Copy)]
  52 enum NumberPart {
  53     OpenParen,
  54     Pound,
  55     Number,
  56     CloseParen,
  57 }
  58
  59 #[derive(PartialEq, Eq, Debug, Clone, Copy)]
  60 pub struct Issue {
  61     issue_type: IssueType,
  62     // Indicates whether we're looking for issues with missing numbers, or
  63     // all issues of this type.
  64     missing_number: bool,
  65 }
  66
  67 impl fmt::Display for Issue {
  68     fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
  69         let msg = match self.issue_type {
  70             IssueType::Todo => "TODO",
  71             IssueType::Fixme => "FIXME",
  72         };
  73         let details = if self.missing_number { " without issue number" } else { "" };
  74
  75         write!(fmt, "{}{}", msg, details)
  76     }
  77 }
  78
  79 #[derive(PartialEq, Eq, Debug, Clone, Copy)]
  80 enum IssueType {
  81     Todo,
  82     Fixme,
  83 }
  84
  85 enum IssueClassification {
  86     Good,
  87     Bad(Issue),
  88     None,
  89 }
  90
  91 pub struct BadIssueSeeker {
  92     state: Seeking,
  93     report_todo: ReportTactic,
  94     report_fixme: ReportTactic,
  95 }
  96
  97 impl BadIssueSeeker {
  98     pub fn new(report_todo: ReportTactic, report_fixme: ReportTactic) -> BadIssueSeeker {
  99         BadIssueSeeker {
 100             state: Seeking::Issue { todo_idx: 0, fixme_idx: 0 },
 101             report_todo: report_todo,
 102             report_fixme: report_fixme,
 103         }
 104     }
 105
 106     // Check whether or not the current char is conclusive evidence for an
 107     // unnumbered TO-DO or FIX-ME.
 108     pub fn inspect(&mut self, c: char) -> Option<Issue> {
 109         match self.state {
 110             Seeking::Issue { todo_idx, fixme_idx } => {
 111                 self.state = self.inspect_issue(c, todo_idx, fixme_idx);
 112             },
 113             Seeking::Number { issue, part } => {
 114                 let result = self.inspect_number(c, issue, part);
 115
 116                 if let IssueClassification::None = result {
 117                     return None;
 118                 }
 119
 120                 self.state = Seeking::Issue { todo_idx: 0, fixme_idx: 0 };
 121
 122                 if let IssueClassification::Bad(issue) = result {
 123                     return Some(issue);
 124                 }
 125             }
 126         }
 127
 128         None
 129     }
 130
 131     fn inspect_issue(&mut self, c: char, mut todo_idx: usize, mut fixme_idx: usize) -> Seeking {
 132         // FIXME: Should we also check for lower case characters?
 133         if self.report_todo.is_enabled() && c == TO_DO_CHARS[todo_idx] {
 134             todo_idx += 1;
 135             if todo_idx == TO_DO_CHARS.len() {
 136                 return Seeking::Number {
 137                     issue: Issue {
 138                         issue_type: IssueType::Todo,
 139                         missing_number: if let ReportTactic::Unnumbered = self.report_todo {
 140                             true
 141                         } else {
 142                             false
 143                         }
 144                     },
 145                     part: NumberPart::OpenParen
 146                 };
 147             }
 148             fixme_idx = 0;
 149         } else if self.report_fixme.is_enabled() && c == FIX_ME_CHARS[fixme_idx] {
 150             // Exploit the fact that the character sets of todo and fixme
 151             // are disjoint by adding else.
 152             fixme_idx += 1;
 153             if fixme_idx == FIX_ME_CHARS.len() {
 154                 return Seeking::Number {
 155                     issue: Issue {
 156                         issue_type: IssueType::Fixme,
 157                         missing_number: if let ReportTactic::Unnumbered = self.report_fixme {
 158                             true
 159                         } else {
 160                             false
 161                         }
 162                     },
 163                     part: NumberPart::OpenParen
 164                 };
 165             }
 166             todo_idx = 0;
 167         } else {
 168             todo_idx = 0;
 169             fixme_idx = 0;
 170         }
 171
 172         Seeking::Issue { todo_idx: todo_idx, fixme_idx: fixme_idx }
 173     }
 174
 175     fn inspect_number(&mut self,
 176                       c: char,
 177                       issue: Issue,
 178                       mut part: NumberPart)
 179                       -> IssueClassification {
 180         if ! issue.missing_number || c == '\n' {
 181             return IssueClassification::Bad(issue);
 182         } else if c == ')' {
 183             return if let NumberPart::CloseParen = part {
 184                 IssueClassification::Good
 185             } else {
 186                 IssueClassification::Bad(issue)
 187             };
 188         }
 189
 190         match part {
 191             NumberPart::OpenParen => {
 192                 if c != '(' {
 193                     return IssueClassification::Bad(issue);
 194                 } else {
 195                     part = NumberPart::Pound;
 196                 }
 197             },
 198             NumberPart::Pound => {
 199                 if c == '#' {
 200                     part = NumberPart::Number;
 201                 }
 202             },
 203             NumberPart::Number => {
 204                 if c >= '0' && c <= '9' {
 205                     part = NumberPart::CloseParen;
 206                 } else {
 207                     return IssueClassification::Bad(issue);
 208                 }
 209             },
 210             NumberPart::CloseParen => {}
 211         }
 212
 213         self.state = Seeking::Number {
 214             part: part,
 215             issue: issue
 216         };
 217
 218         IssueClassification::None
 219     }
 220 }
 221
 222 #[test]
 223 fn find_unnumbered_issue() {
 224     fn check_fail(text: &str, failing_pos: usize) {
 225         let mut seeker = BadIssueSeeker::new(ReportTactic::Unnumbered, ReportTactic::Unnumbered);
 226         assert_eq!(Some(failing_pos), text.chars().position(|c| seeker.inspect(c).is_some()));
 227     }
 228
 229     fn check_pass(text: &str) {
 230         let mut seeker = BadIssueSeeker::new(ReportTactic::Unnumbered, ReportTactic::Unnumbered);
 231         assert_eq!(None, text.chars().position(|c| seeker.inspect(c).is_some()));
 232     }
 233
 234     check_fail("TODO\n", 4);
 235     check_pass(" TO FIX DOME\n");
 236     check_fail(" \n FIXME\n", 8);
 237     check_fail("FIXME(\n", 6);
 238     check_fail("FIXME(#\n", 7);
 239     check_fail("FIXME(#1\n", 8);
 240     check_fail("FIXME(#)1\n", 7);
 241     check_pass("FIXME(#1222)\n");
 242     check_fail("FIXME(#12\n22)\n", 9);
 243     check_pass("FIXME(@maintainer, #1222, hello)\n");
 244     check_fail("TODO(#22) FIXME\n", 15);
 245 }
 246
 247 #[test]
 248 fn find_issue() {
 249     fn is_bad_issue(text: &str, report_todo: ReportTactic, report_fixme: ReportTactic) -> bool {
 250         let mut seeker = BadIssueSeeker::new(report_todo, report_fixme);
 251         text.chars().any(|c| seeker.inspect(c).is_some())
 252     }
 253
 254     assert!(is_bad_issue("TODO(@maintainer, #1222, hello)\n",
 255                          ReportTactic::Always,
 256                          ReportTactic::Never));
 257
 258     assert!(! is_bad_issue("TODO: no number\n",
 259                            ReportTactic::Never,
 260                            ReportTactic::Always));
 261
 262     assert!(is_bad_issue("This is a FIXME(#1)\n",
 263                          ReportTactic::Never,
 264                          ReportTactic::Always));
 265
 266     assert!(! is_bad_issue("bad FIXME\n",
 267                            ReportTactic::Always,
 268                            ReportTactic::Never));
 269 }
 270
 271 #[test]
 272 fn issue_type() {
 273     let mut seeker = BadIssueSeeker::new(ReportTactic::Always, ReportTactic::Never);
 274     let expected = Some(Issue { issue_type: IssueType::Todo, missing_number: false });
 275
 276     assert_eq!(expected,
 277                "TODO(#100): more awesomeness".chars()
 278                                        .map(|c| seeker.inspect(c))
 279                                        .find(Option::is_some)
 280                                        .unwrap());
 281
 282     let mut seeker = BadIssueSeeker::new(ReportTactic::Never, ReportTactic::Unnumbered);
 283     let expected = Some(Issue { issue_type: IssueType::Fixme, missing_number: true });
 284
 285     assert_eq!(expected,
 286                "Test. FIXME: bad, bad, not good".chars()
 287                                                 .map(|c| seeker.inspect(c))
 288                                                 .find(Option::is_some)
 289                                                 .unwrap());
 290 }