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.
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.
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.
17 static TO_DO_CHARS: &'static [char] = &['T', 'O', 'D', 'O'];
18 static FIX_ME_CHARS: &'static [char] = &['F', 'I', 'X', 'M', 'E'];
20 #[derive(Clone, Copy)]
21 pub enum ReportTactic {
28 fn is_enabled(&self) -> bool {
30 ReportTactic::Always => true,
31 ReportTactic::Unnumbered => true,
32 ReportTactic::Never => false,
37 impl_enum_decodable!(ReportTactic, Always, Unnumbered, Never);
39 #[derive(Clone, Copy)]
51 #[derive(Clone, Copy)]
59 #[derive(PartialEq, Eq, Debug, Clone, Copy)]
61 issue_type: IssueType,
62 // Indicates whether we're looking for issues with missing numbers, or
63 // all issues of this type.
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",
73 let details = if self.missing_number {
74 " without issue number"
79 write!(fmt, "{}{}", msg, details)
83 #[derive(PartialEq, Eq, Debug, Clone, Copy)]
89 enum IssueClassification {
95 pub struct BadIssueSeeker {
97 report_todo: ReportTactic,
98 report_fixme: ReportTactic,
101 impl BadIssueSeeker {
102 pub fn new(report_todo: ReportTactic, report_fixme: ReportTactic) -> BadIssueSeeker {
104 state: Seeking::Issue { todo_idx: 0, fixme_idx: 0 },
105 report_todo: report_todo,
106 report_fixme: report_fixme,
110 // Check whether or not the current char is conclusive evidence for an
111 // unnumbered TO-DO or FIX-ME.
112 pub fn inspect(&mut self, c: char) -> Option<Issue> {
114 Seeking::Issue { todo_idx, fixme_idx } => {
115 self.state = self.inspect_issue(c, todo_idx, fixme_idx);
117 Seeking::Number { issue, part } => {
118 let result = self.inspect_number(c, issue, part);
120 if let IssueClassification::None = result {
124 self.state = Seeking::Issue { todo_idx: 0, fixme_idx: 0 };
126 if let IssueClassification::Bad(issue) = result {
135 fn inspect_issue(&mut self, c: char, mut todo_idx: usize, mut fixme_idx: usize) -> Seeking {
136 // FIXME: Should we also check for lower case characters?
137 if self.report_todo.is_enabled() && c == TO_DO_CHARS[todo_idx] {
139 if todo_idx == TO_DO_CHARS.len() {
140 return Seeking::Number {
142 issue_type: IssueType::Todo,
143 missing_number: if let ReportTactic::Unnumbered = self.report_todo {
149 part: NumberPart::OpenParen,
153 } else if self.report_fixme.is_enabled() && c == FIX_ME_CHARS[fixme_idx] {
154 // Exploit the fact that the character sets of todo and fixme
155 // are disjoint by adding else.
157 if fixme_idx == FIX_ME_CHARS.len() {
158 return Seeking::Number {
160 issue_type: IssueType::Fixme,
161 missing_number: if let ReportTactic::Unnumbered = self.report_fixme {
167 part: NumberPart::OpenParen,
176 Seeking::Issue { todo_idx: todo_idx, fixme_idx: fixme_idx }
179 fn inspect_number(&mut self,
182 mut part: NumberPart)
183 -> IssueClassification {
184 if !issue.missing_number || c == '\n' {
185 return IssueClassification::Bad(issue);
187 return if let NumberPart::CloseParen = part {
188 IssueClassification::Good
190 IssueClassification::Bad(issue)
195 NumberPart::OpenParen => {
197 return IssueClassification::Bad(issue);
199 part = NumberPart::Pound;
202 NumberPart::Pound => {
204 part = NumberPart::Number;
207 NumberPart::Number => {
208 if c >= '0' && c <= '9' {
209 part = NumberPart::CloseParen;
211 return IssueClassification::Bad(issue);
214 NumberPart::CloseParen => {}
217 self.state = Seeking::Number { part: part, issue: issue };
219 IssueClassification::None
224 fn find_unnumbered_issue() {
225 fn check_fail(text: &str, failing_pos: usize) {
226 let mut seeker = BadIssueSeeker::new(ReportTactic::Unnumbered, ReportTactic::Unnumbered);
227 assert_eq!(Some(failing_pos), text.chars().position(|c| seeker.inspect(c).is_some()));
230 fn check_pass(text: &str) {
231 let mut seeker = BadIssueSeeker::new(ReportTactic::Unnumbered, ReportTactic::Unnumbered);
232 assert_eq!(None, text.chars().position(|c| seeker.inspect(c).is_some()));
235 check_fail("TODO\n", 4);
236 check_pass(" TO FIX DOME\n");
237 check_fail(" \n FIXME\n", 8);
238 check_fail("FIXME(\n", 6);
239 check_fail("FIXME(#\n", 7);
240 check_fail("FIXME(#1\n", 8);
241 check_fail("FIXME(#)1\n", 7);
242 check_pass("FIXME(#1222)\n");
243 check_fail("FIXME(#12\n22)\n", 9);
244 check_pass("FIXME(@maintainer, #1222, hello)\n");
245 check_fail("TODO(#22) FIXME\n", 15);
250 fn is_bad_issue(text: &str, report_todo: ReportTactic, report_fixme: ReportTactic) -> bool {
251 let mut seeker = BadIssueSeeker::new(report_todo, report_fixme);
252 text.chars().any(|c| seeker.inspect(c).is_some())
255 assert!(is_bad_issue("TODO(@maintainer, #1222, hello)\n",
256 ReportTactic::Always,
257 ReportTactic::Never));
259 assert!(!is_bad_issue("TODO: no number\n", ReportTactic::Never, ReportTactic::Always));
261 assert!(is_bad_issue("This is a FIXME(#1)\n", ReportTactic::Never, ReportTactic::Always));
263 assert!(!is_bad_issue("bad FIXME\n", ReportTactic::Always, ReportTactic::Never));
268 let mut seeker = BadIssueSeeker::new(ReportTactic::Always, ReportTactic::Never);
269 let expected = Some(Issue { issue_type: IssueType::Todo, missing_number: false });
272 "TODO(#100): more awesomeness"
274 .map(|c| seeker.inspect(c))
275 .find(Option::is_some)
278 let mut seeker = BadIssueSeeker::new(ReportTactic::Never, ReportTactic::Unnumbered);
279 let expected = Some(Issue { issue_type: IssueType::Fixme, missing_number: true });
282 "Test. FIXME: bad, bad, not good"
284 .map(|c| seeker.inspect(c))
285 .find(Option::is_some)