1 ///////////////////////////////////////////////////////////////////////////////////////////////
2 // checkstyle: Checks Java source code and other text files for adherence to a set of rules.
3 // Copyright (C) 2001-2024 the original author or authors.
4 //
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU Lesser General Public
7 // License as published by the Free Software Foundation; either
8 // version 2.1 of the License, or (at your option) any later version.
9 //
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 // Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with this library; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 ///////////////////////////////////////////////////////////////////////////////////////////////
19
20 package com.puppycrawl.tools.checkstyle.checks.javadoc;
21
22 import java.util.ArrayList;
23 import java.util.Arrays;
24 import java.util.BitSet;
25 import java.util.List;
26 import java.util.Optional;
27 import java.util.regex.Pattern;
28 import java.util.stream.Stream;
29
30 import com.puppycrawl.tools.checkstyle.StatelessCheck;
31 import com.puppycrawl.tools.checkstyle.api.DetailNode;
32 import com.puppycrawl.tools.checkstyle.api.JavadocTokenTypes;
33 import com.puppycrawl.tools.checkstyle.utils.CommonUtil;
34 import com.puppycrawl.tools.checkstyle.utils.JavadocUtil;
35 import com.puppycrawl.tools.checkstyle.utils.TokenUtil;
36
37 /**
38 * <div>
39 * Checks that
40 * <a href="https://www.oracle.com/technical-resources/articles/java/javadoc-tool.html#firstsentence">
41 * Javadoc summary sentence</a> does not contain phrases that are not recommended to use.
42 * Summaries that contain only the {@code {@inheritDoc}} tag are skipped.
43 * Summaries that contain a non-empty {@code {@return}} are allowed.
44 * Check also violate Javadoc that does not contain first sentence, though with {@code {@return}} a
45 * period is not required as the Javadoc tool adds it.
46 * </div>
47 *
48 * <ul>
49 * <li>
50 * Property {@code forbiddenSummaryFragments} - Specify the regexp for forbidden summary fragments.
51 * Type is {@code java.util.regex.Pattern}.
52 * Default value is {@code "^$"}.
53 * </li>
54 * <li>
55 * Property {@code period} - Specify the period symbol. Used to check the first sentence ends with a
56 * period. Periods that are not followed by a whitespace character are ignored (eg. the period in
57 * v1.0). Because some periods include whitespace built into the character, if this is set to a
58 * non-default value any period will end the sentence, whether it is followed by whitespace or not.
59 * Type is {@code java.lang.String}.
60 * Default value is {@code "."}.
61 * </li>
62 * <li>
63 * Property {@code violateExecutionOnNonTightHtml} - Control when to print violations
64 * if the Javadoc being examined by this check violates the tight html rules defined at
65 * <a href="https://checkstyle.org/writingjavadocchecks.html#Tight-HTML_rules">Tight-HTML Rules</a>.
66 * Type is {@code boolean}.
67 * Default value is {@code false}.
68 * </li>
69 * </ul>
70 *
71 * <p>
72 * Parent is {@code com.puppycrawl.tools.checkstyle.TreeWalker}
73 * </p>
74 *
75 * <p>
76 * Violation Message Keys:
77 * </p>
78 * <ul>
79 * <li>
80 * {@code javadoc.missed.html.close}
81 * </li>
82 * <li>
83 * {@code javadoc.parse.rule.error}
84 * </li>
85 * <li>
86 * {@code javadoc.unclosedHtml}
87 * </li>
88 * <li>
89 * {@code javadoc.wrong.singleton.html.tag}
90 * </li>
91 * <li>
92 * {@code summary.first.sentence}
93 * </li>
94 * <li>
95 * {@code summary.javaDoc}
96 * </li>
97 * <li>
98 * {@code summary.javaDoc.missing}
99 * </li>
100 * <li>
101 * {@code summary.javaDoc.missing.period}
102 * </li>
103 * </ul>
104 *
105 * @since 6.0
106 */
107 @StatelessCheck
108 public class SummaryJavadocCheck extends AbstractJavadocCheck {
109
110 /**
111 * A key is pointing to the warning message text in "messages.properties"
112 * file.
113 */
114 public static final String MSG_SUMMARY_FIRST_SENTENCE = "summary.first.sentence";
115
116 /**
117 * A key is pointing to the warning message text in "messages.properties"
118 * file.
119 */
120 public static final String MSG_SUMMARY_JAVADOC = "summary.javaDoc";
121
122 /**
123 * A key is pointing to the warning message text in "messages.properties"
124 * file.
125 */
126 public static final String MSG_SUMMARY_JAVADOC_MISSING = "summary.javaDoc.missing";
127
128 /**
129 * A key is pointing to the warning message text in "messages.properties" file.
130 */
131 public static final String MSG_SUMMARY_MISSING_PERIOD = "summary.javaDoc.missing.period";
132
133 /**
134 * This regexp is used to convert multiline javadoc to single-line without stars.
135 */
136 private static final Pattern JAVADOC_MULTILINE_TO_SINGLELINE_PATTERN =
137 Pattern.compile("\n +(\\*)|^ +(\\*)");
138
139 /**
140 * This regexp is used to remove html tags, whitespace, and asterisks from a string.
141 */
142 private static final Pattern HTML_ELEMENTS =
143 Pattern.compile("<[^>]*>");
144
145 /** Default period literal. */
146 private static final String DEFAULT_PERIOD = ".";
147
148 /** Summary tag text. */
149 private static final String SUMMARY_TEXT = "@summary";
150
151 /** Return tag text. */
152 private static final String RETURN_TEXT = "@return";
153
154 /** Set of allowed Tokens tags in summary java doc. */
155 private static final BitSet ALLOWED_TYPES = TokenUtil.asBitSet(
156 JavadocTokenTypes.WS,
157 JavadocTokenTypes.DESCRIPTION,
158 JavadocTokenTypes.TEXT);
159
160 /**
161 * Specify the regexp for forbidden summary fragments.
162 */
163 private Pattern forbiddenSummaryFragments = CommonUtil.createPattern("^$");
164
165 /**
166 * Specify the period symbol. Used to check the first sentence ends with a period. Periods that
167 * are not followed by a whitespace character are ignored (eg. the period in v1.0). Because some
168 * periods include whitespace built into the character, if this is set to a non-default value
169 * any period will end the sentence, whether it is followed by whitespace or not.
170 */
171 private String period = DEFAULT_PERIOD;
172
173 /**
174 * Setter to specify the regexp for forbidden summary fragments.
175 *
176 * @param pattern a pattern.
177 * @since 6.0
178 */
179 public void setForbiddenSummaryFragments(Pattern pattern) {
180 forbiddenSummaryFragments = pattern;
181 }
182
183 /**
184 * Setter to specify the period symbol. Used to check the first sentence ends with a period.
185 * Periods that are not followed by a whitespace character are ignored (eg. the period in v1.0).
186 * Because some periods include whitespace built into the character, if this is set to a
187 * non-default value any period will end the sentence, whether it is followed by whitespace or
188 * not.
189 *
190 * @param period period's value.
191 * @since 6.2
192 */
193 public void setPeriod(String period) {
194 this.period = period;
195 }
196
197 @Override
198 public int[] getDefaultJavadocTokens() {
199 return new int[] {
200 JavadocTokenTypes.JAVADOC,
201 };
202 }
203
204 @Override
205 public int[] getRequiredJavadocTokens() {
206 return getAcceptableJavadocTokens();
207 }
208
209 @Override
210 public void visitJavadocToken(DetailNode ast) {
211 final Optional<DetailNode> inlineTagNode = getInlineTagNode(ast);
212 boolean shouldValidateUntaggedSummary = true;
213 if (inlineTagNode.isPresent()) {
214 final DetailNode node = inlineTagNode.get();
215 if (isSummaryTag(node) && isDefinedFirst(node)) {
216 shouldValidateUntaggedSummary = false;
217 validateSummaryTag(node);
218 }
219 else if (isInlineReturnTag(node)) {
220 shouldValidateUntaggedSummary = false;
221 validateInlineReturnTag(node);
222 }
223 }
224 if (shouldValidateUntaggedSummary && !startsWithInheritDoc(ast)) {
225 validateUntaggedSummary(ast);
226 }
227 }
228
229 /**
230 * Checks the javadoc text for {@code period} at end and forbidden fragments.
231 *
232 * @param ast the javadoc text node
233 */
234 private void validateUntaggedSummary(DetailNode ast) {
235 final String summaryDoc = getSummarySentence(ast);
236 if (summaryDoc.isEmpty()) {
237 log(ast.getLineNumber(), MSG_SUMMARY_JAVADOC_MISSING);
238 }
239 else if (!period.isEmpty()) {
240 if (summaryDoc.contains(period)) {
241 final Optional<String> firstSentence = getFirstSentence(ast, period);
242
243 if (firstSentence.isPresent()) {
244 if (containsForbiddenFragment(firstSentence.get())) {
245 log(ast.getLineNumber(), MSG_SUMMARY_JAVADOC);
246 }
247 }
248 else {
249 log(ast.getLineNumber(), MSG_SUMMARY_FIRST_SENTENCE);
250 }
251 }
252 else {
253 log(ast.getLineNumber(), MSG_SUMMARY_FIRST_SENTENCE);
254 }
255 }
256 }
257
258 /**
259 * Gets the node for the inline tag if present.
260 *
261 * @param javadoc javadoc root node.
262 * @return the node for the inline tag if present.
263 */
264 private static Optional<DetailNode> getInlineTagNode(DetailNode javadoc) {
265 return Arrays.stream(javadoc.getChildren())
266 .filter(SummaryJavadocCheck::isInlineTagPresent)
267 .findFirst()
268 .map(SummaryJavadocCheck::getInlineTagNodeForAst);
269 }
270
271 /**
272 * Whether the {@code {@summary}} tag is defined first in the javadoc.
273 *
274 * @param inlineSummaryTag node of type {@link JavadocTokenTypes#JAVADOC_INLINE_TAG}
275 * @return {@code true} if the {@code {@summary}} tag is defined first in the javadoc
276 */
277 private static boolean isDefinedFirst(DetailNode inlineSummaryTag) {
278 boolean isDefinedFirst = true;
279 DetailNode currentAst = inlineSummaryTag;
280 while (currentAst != null && isDefinedFirst) {
281 switch (currentAst.getType()) {
282 case JavadocTokenTypes.TEXT:
283 isDefinedFirst = currentAst.getText().isBlank();
284 break;
285 case JavadocTokenTypes.HTML_ELEMENT:
286 isDefinedFirst = !isTextPresentInsideHtmlTag(currentAst);
287 break;
288 default:
289 break;
290 }
291 currentAst = JavadocUtil.getPreviousSibling(currentAst);
292 }
293 return isDefinedFirst;
294 }
295
296 /**
297 * Whether some text is present inside the HTML element or tag.
298 *
299 * @param node DetailNode of type {@link JavadocTokenTypes#HTML_TAG}
300 * or {@link JavadocTokenTypes#HTML_ELEMENT}
301 * @return {@code true} if some text is present inside the HTML element or tag
302 */
303 public static boolean isTextPresentInsideHtmlTag(DetailNode node) {
304 DetailNode nestedChild = JavadocUtil.getFirstChild(node);
305 if (node.getType() == JavadocTokenTypes.HTML_ELEMENT) {
306 nestedChild = JavadocUtil.getFirstChild(nestedChild);
307 }
308 boolean isTextPresentInsideHtmlTag = false;
309 while (nestedChild != null && !isTextPresentInsideHtmlTag) {
310 switch (nestedChild.getType()) {
311 case JavadocTokenTypes.TEXT:
312 isTextPresentInsideHtmlTag = !nestedChild.getText().isBlank();
313 break;
314 case JavadocTokenTypes.HTML_TAG:
315 case JavadocTokenTypes.HTML_ELEMENT:
316 isTextPresentInsideHtmlTag = isTextPresentInsideHtmlTag(nestedChild);
317 break;
318 default:
319 break;
320 }
321 nestedChild = JavadocUtil.getNextSibling(nestedChild);
322 }
323 return isTextPresentInsideHtmlTag;
324 }
325
326 /**
327 * Checks if the inline tag node is present.
328 *
329 * @param ast ast node to check.
330 * @return true, if the inline tag node is present.
331 */
332 private static boolean isInlineTagPresent(DetailNode ast) {
333 return getInlineTagNodeForAst(ast) != null;
334 }
335
336 /**
337 * Returns an inline javadoc tag node that is within a html tag.
338 *
339 * @param ast html tag node.
340 * @return inline summary javadoc tag node or null if no node is found.
341 */
342 private static DetailNode getInlineTagNodeForAst(DetailNode ast) {
343 DetailNode node = ast;
344 DetailNode result = null;
345 // node can never be null as this method is called when there is a HTML_ELEMENT
346 if (node.getType() == JavadocTokenTypes.JAVADOC_INLINE_TAG) {
347 result = node;
348 }
349 else if (node.getType() == JavadocTokenTypes.HTML_TAG) {
350 // HTML_TAG always has more than 2 children.
351 node = node.getChildren()[1];
352 result = getInlineTagNodeForAst(node);
353 }
354 else if (node.getType() == JavadocTokenTypes.HTML_ELEMENT
355 // Condition for SINGLETON html element which cannot contain summary node
356 && node.getChildren()[0].getChildren().length > 1) {
357 // Html elements have one tested tag before actual content inside it
358 node = node.getChildren()[0].getChildren()[1];
359 result = getInlineTagNodeForAst(node);
360 }
361 return result;
362 }
363
364 /**
365 * Checks if the javadoc inline tag is {@code {@summary}} tag.
366 *
367 * @param javadocInlineTag node of type {@link JavadocTokenTypes#JAVADOC_INLINE_TAG}
368 * @return {@code true} if inline tag is summary tag.
369 */
370 private static boolean isSummaryTag(DetailNode javadocInlineTag) {
371 return isInlineTagWithName(javadocInlineTag, SUMMARY_TEXT);
372 }
373
374 /**
375 * Checks if the first tag inside ast is {@code {@return}} tag.
376 *
377 * @param javadocInlineTag node of type {@link JavadocTokenTypes#JAVADOC_INLINE_TAG}
378 * @return {@code true} if first tag is return tag.
379 */
380 private static boolean isInlineReturnTag(DetailNode javadocInlineTag) {
381 return isInlineTagWithName(javadocInlineTag, RETURN_TEXT);
382 }
383
384 /**
385 * Checks if the first tag inside ast is a tag with the given name.
386 *
387 * @param javadocInlineTag node of type {@link JavadocTokenTypes#JAVADOC_INLINE_TAG}
388 * @param name name of inline tag.
389 *
390 * @return {@code true} if first tag is a tag with the given name.
391 */
392 private static boolean isInlineTagWithName(DetailNode javadocInlineTag, String name) {
393 final DetailNode[] child = javadocInlineTag.getChildren();
394
395 // Checking size of ast is not required, since ast contains
396 // children of Inline Tag, as at least 2 children will be present which are
397 // RCURLY and LCURLY.
398 return name.equals(child[1].getText());
399 }
400
401 /**
402 * Checks the inline summary (if present) for {@code period} at end and forbidden fragments.
403 *
404 * @param inlineSummaryTag node of type {@link JavadocTokenTypes#JAVADOC_INLINE_TAG}
405 */
406 private void validateSummaryTag(DetailNode inlineSummaryTag) {
407 final String inlineSummary = getContentOfInlineCustomTag(inlineSummaryTag);
408 final String summaryVisible = getVisibleContent(inlineSummary);
409 if (summaryVisible.isEmpty()) {
410 log(inlineSummaryTag.getLineNumber(), MSG_SUMMARY_JAVADOC_MISSING);
411 }
412 else if (!period.isEmpty()) {
413 final boolean isPeriodNotAtEnd =
414 summaryVisible.lastIndexOf(period) != summaryVisible.length() - 1;
415 if (isPeriodNotAtEnd) {
416 log(inlineSummaryTag.getLineNumber(), MSG_SUMMARY_MISSING_PERIOD);
417 }
418 else if (containsForbiddenFragment(inlineSummary)) {
419 log(inlineSummaryTag.getLineNumber(), MSG_SUMMARY_JAVADOC);
420 }
421 }
422 }
423
424 /**
425 * Checks the inline return for forbidden fragments.
426 *
427 * @param inlineReturnTag node of type {@link JavadocTokenTypes#JAVADOC_INLINE_TAG}
428 */
429 private void validateInlineReturnTag(DetailNode inlineReturnTag) {
430 final String inlineReturn = getContentOfInlineCustomTag(inlineReturnTag);
431 final String returnVisible = getVisibleContent(inlineReturn);
432 if (returnVisible.isEmpty()) {
433 log(inlineReturnTag.getLineNumber(), MSG_SUMMARY_JAVADOC_MISSING);
434 }
435 else if (containsForbiddenFragment(inlineReturn)) {
436 log(inlineReturnTag.getLineNumber(), MSG_SUMMARY_JAVADOC);
437 }
438 }
439
440 /**
441 * Gets the content of inline custom tag.
442 *
443 * @param inlineTag inline tag node.
444 * @return String consisting of the content of inline custom tag.
445 */
446 public static String getContentOfInlineCustomTag(DetailNode inlineTag) {
447 final DetailNode[] childrenOfInlineTag = inlineTag.getChildren();
448 final StringBuilder customTagContent = new StringBuilder(256);
449 final int indexOfContentOfSummaryTag = 3;
450 if (childrenOfInlineTag.length != indexOfContentOfSummaryTag) {
451 DetailNode currentNode = childrenOfInlineTag[indexOfContentOfSummaryTag];
452 while (currentNode.getType() != JavadocTokenTypes.JAVADOC_INLINE_TAG_END) {
453 extractInlineTagContent(currentNode, customTagContent);
454 currentNode = JavadocUtil.getNextSibling(currentNode);
455 }
456 }
457 return customTagContent.toString();
458 }
459
460 /**
461 * Extracts the content of inline custom tag recursively.
462 *
463 * @param node DetailNode
464 * @param customTagContent content of custom tag
465 */
466 private static void extractInlineTagContent(DetailNode node,
467 StringBuilder customTagContent) {
468 final DetailNode[] children = node.getChildren();
469 if (children.length == 0) {
470 customTagContent.append(node.getText());
471 }
472 else {
473 for (DetailNode child : children) {
474 if (child.getType() != JavadocTokenTypes.LEADING_ASTERISK) {
475 extractInlineTagContent(child, customTagContent);
476 }
477 }
478 }
479 }
480
481 /**
482 * Gets the string that is visible to user in javadoc.
483 *
484 * @param summary entire content of summary javadoc.
485 * @return string that is visible to user in javadoc.
486 */
487 private static String getVisibleContent(String summary) {
488 final String visibleSummary = HTML_ELEMENTS.matcher(summary).replaceAll("");
489 return visibleSummary.trim();
490 }
491
492 /**
493 * Tests if first sentence contains forbidden summary fragment.
494 *
495 * @param firstSentence string with first sentence.
496 * @return {@code true} if first sentence contains forbidden summary fragment.
497 */
498 private boolean containsForbiddenFragment(String firstSentence) {
499 final String javadocText = JAVADOC_MULTILINE_TO_SINGLELINE_PATTERN
500 .matcher(firstSentence).replaceAll(" ");
501 return forbiddenSummaryFragments.matcher(trimExcessWhitespaces(javadocText)).find();
502 }
503
504 /**
505 * Trims the given {@code text} of duplicate whitespaces.
506 *
507 * @param text the text to transform.
508 * @return the finalized form of the text.
509 */
510 private static String trimExcessWhitespaces(String text) {
511 final StringBuilder result = new StringBuilder(256);
512 boolean previousWhitespace = true;
513
514 for (char letter : text.toCharArray()) {
515 final char print;
516 if (Character.isWhitespace(letter)) {
517 if (previousWhitespace) {
518 continue;
519 }
520
521 previousWhitespace = true;
522 print = ' ';
523 }
524 else {
525 previousWhitespace = false;
526 print = letter;
527 }
528
529 result.append(print);
530 }
531
532 return result.toString();
533 }
534
535 /**
536 * Checks if the node starts with an {@inheritDoc}.
537 *
538 * @param root the root node to examine.
539 * @return {@code true} if the javadoc starts with an {@inheritDoc}.
540 */
541 private static boolean startsWithInheritDoc(DetailNode root) {
542 boolean found = false;
543
544 for (DetailNode child : root.getChildren()) {
545 if (child.getType() == JavadocTokenTypes.JAVADOC_INLINE_TAG
546 && child.getChildren()[1].getType() == JavadocTokenTypes.INHERIT_DOC_LITERAL) {
547 found = true;
548 }
549 if ((child.getType() == JavadocTokenTypes.TEXT
550 || child.getType() == JavadocTokenTypes.HTML_ELEMENT)
551 && !CommonUtil.isBlank(child.getText())) {
552 break;
553 }
554 }
555
556 return found;
557 }
558
559 /**
560 * Finds and returns summary sentence.
561 *
562 * @param ast javadoc root node.
563 * @return violation string.
564 */
565 private static String getSummarySentence(DetailNode ast) {
566 final StringBuilder result = new StringBuilder(256);
567 for (DetailNode child : ast.getChildren()) {
568 if (child.getType() != JavadocTokenTypes.EOF
569 && ALLOWED_TYPES.get(child.getType())) {
570 result.append(child.getText());
571 }
572 else {
573 final String summary = result.toString();
574 if (child.getType() == JavadocTokenTypes.HTML_ELEMENT
575 && CommonUtil.isBlank(summary)) {
576 result.append(getStringInsideTag(summary,
577 child.getChildren()[0].getChildren()[0]));
578 }
579 }
580 }
581 return result.toString().trim();
582 }
583
584 /**
585 * Get concatenated string within text of html tags.
586 *
587 * @param result javadoc string
588 * @param detailNode javadoc tag node
589 * @return java doc tag content appended in result
590 */
591 private static String getStringInsideTag(String result, DetailNode detailNode) {
592 final StringBuilder contents = new StringBuilder(result);
593 DetailNode tempNode = detailNode;
594 while (tempNode != null) {
595 if (tempNode.getType() == JavadocTokenTypes.TEXT) {
596 contents.append(tempNode.getText());
597 }
598 tempNode = JavadocUtil.getNextSibling(tempNode);
599 }
600 return contents.toString();
601 }
602
603 /**
604 * Finds the first sentence.
605 *
606 * @param ast The Javadoc root node.
607 * @param period The configured period symbol.
608 * @return An Optional containing the first sentence
609 * up to and excluding the period, or an empty
610 * Optional if no ending was found.
611 */
612 private static Optional<String> getFirstSentence(DetailNode ast, String period) {
613 final List<String> sentenceParts = new ArrayList<>();
614 Optional<String> result = Optional.empty();
615 for (String text : (Iterable<String>) streamTextParts(ast)::iterator) {
616 final Optional<String> sentenceEnding = findSentenceEnding(text, period);
617
618 if (sentenceEnding.isPresent()) {
619 sentenceParts.add(sentenceEnding.get());
620 result = Optional.of(String.join("", sentenceParts));
621 break;
622 }
623 else {
624 sentenceParts.add(text);
625 }
626 }
627 return result;
628 }
629
630 /**
631 * Streams through all the text under the given node.
632 *
633 * @param node The Javadoc node to examine.
634 * @return All the text in all nodes that have no child nodes.
635 */
636 private static Stream<String> streamTextParts(DetailNode node) {
637 final Stream<String> stream;
638 if (node.getChildren().length == 0) {
639 stream = Stream.of(node.getText());
640 }
641 else {
642 stream = Stream.of(node.getChildren())
643 .flatMap(SummaryJavadocCheck::streamTextParts);
644 }
645 return stream;
646 }
647
648 /**
649 * Finds the end of a sentence. The end of sentence detection here could be replaced in the
650 * future by Java's built-in BreakIterator class.
651 *
652 * @param text The string to search.
653 * @param period The period character to find.
654 * @return An Optional containing the string up to and excluding the period,
655 * or empty Optional if no ending was found.
656 */
657 private static Optional<String> findSentenceEnding(String text, String period) {
658 int periodIndex = text.indexOf(period);
659 Optional<String> result = Optional.empty();
660 while (periodIndex >= 0) {
661 final int afterPeriodIndex = periodIndex + period.length();
662
663 // Handle western period separately as it is only the end of a sentence if followed
664 // by whitespace. Other period characters often include whitespace in the character.
665 if (!DEFAULT_PERIOD.equals(period)
666 || afterPeriodIndex >= text.length()
667 || Character.isWhitespace(text.charAt(afterPeriodIndex))) {
668 final String resultStr = text.substring(0, periodIndex);
669 result = Optional.of(resultStr);
670 break;
671 }
672 else {
673 periodIndex = text.indexOf(period, afterPeriodIndex);
674 }
675 }
676 return result;
677 }
678 }