001//////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code for adherence to a set of rules. 003// Copyright (C) 2001-2017 the original author or authors. 004// 005// This library is free software; you can redistribute it and/or 006// modify it under the terms of the GNU Lesser General Public 007// License as published by the Free Software Foundation; either 008// version 2.1 of the License, or (at your option) any later version. 009// 010// This library is distributed in the hope that it will be useful, 011// but WITHOUT ANY WARRANTY; without even the implied warranty of 012// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 013// Lesser General Public License for more details. 014// 015// You should have received a copy of the GNU Lesser General Public 016// License along with this library; if not, write to the Free Software 017// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 018//////////////////////////////////////////////////////////////////////////////// 019 020package com.puppycrawl.tools.checkstyle.checks.regexp; 021 022import java.util.Optional; 023import java.util.regex.Pattern; 024 025import com.puppycrawl.tools.checkstyle.api.AbstractViolationReporter; 026 027/** 028 * Options for a detector. 029 * @author Oliver Burn 030 */ 031public final class DetectorOptions { 032 /** 033 * Flags to compile a regular expression with. 034 * See {@link Pattern#flags()}. 035 */ 036 private int compileFlags; 037 /** Used for reporting violations. */ 038 private AbstractViolationReporter reporter; 039 /** 040 * Format of the regular expression to check for. 041 */ 042 private String format; 043 /** The message to report on detection. If blank, then use the format. */ 044 private String message = ""; 045 /** Minimum number of times regular expression should occur in a file. */ 046 private int minimum; 047 /** Maximum number of times regular expression should occur in a file. */ 048 private int maximum; 049 /** Whether to ignore case when matching. */ 050 private boolean ignoreCase; 051 /** Used to determine whether to suppress a detected match. */ 052 private MatchSuppressor suppressor; 053 /** Pattern created from format. Lazily initialized. */ 054 private Pattern pattern; 055 056 /** Default constructor.*/ 057 private DetectorOptions() { } 058 059 /** 060 * Returns new Builder object. 061 * @return Builder object. 062 */ 063 public static Builder newBuilder() { 064 return new DetectorOptions().new Builder(); 065 } 066 067 /** 068 * Format of the regular expression. 069 * @return format of the regular expression. 070 */ 071 public String getFormat() { 072 return format; 073 } 074 075 /** 076 * The violation reporter to use. 077 * @return the violation reporter to use. 078 */ 079 public AbstractViolationReporter getReporter() { 080 return reporter; 081 } 082 083 /** 084 * The message to report errors with. 085 * @return the message to report errors with. 086 */ 087 public String getMessage() { 088 return message; 089 } 090 091 /** 092 * The minimum number of allowed detections. 093 * @return the minimum number of allowed detections. 094 */ 095 public int getMinimum() { 096 return minimum; 097 } 098 099 /** 100 * The maximum number of allowed detections. 101 * @return the maximum number of allowed detections. 102 */ 103 public int getMaximum() { 104 return maximum; 105 } 106 107 /** 108 * The suppressor to use. 109 * @return the suppressor to use. 110 */ 111 public MatchSuppressor getSuppressor() { 112 return suppressor; 113 } 114 115 /** 116 * The pattern to use when matching. 117 * @return the pattern to use when matching. 118 */ 119 public Pattern getPattern() { 120 if (pattern != null) { 121 return pattern; 122 } 123 int options = compileFlags; 124 125 if (ignoreCase) { 126 options |= Pattern.CASE_INSENSITIVE; 127 } 128 pattern = Pattern.compile(format, options); 129 return pattern; 130 } 131 132 /** Class which implements Builder pattern to build DetectorOptions instance. */ 133 public final class Builder { 134 135 /** 136 * Specifies the violation reporter and returns Builder object. 137 * @param val for reporting violations. 138 * @return Builder object. 139 * @noinspection ReturnOfInnerClass 140 */ 141 public Builder reporter(AbstractViolationReporter val) { 142 reporter = val; 143 return this; 144 } 145 146 /** 147 * Specifies the compile flags to compile a regular expression with 148 * and returns Builder object. 149 * @param val the format to use when matching lines. 150 * @return Builder object. 151 * @noinspection ReturnOfInnerClass 152 */ 153 public Builder compileFlags(int val) { 154 compileFlags = val; 155 return this; 156 } 157 158 /** 159 * Specifies the format to use when matching lines and returns Builder object. 160 * @param val the format to use when matching lines. 161 * @return Builder object. 162 * @noinspection ReturnOfInnerClass 163 */ 164 public Builder format(String val) { 165 format = val; 166 return this; 167 } 168 169 /** 170 * Specifies message to use when reporting a match and returns Builder object. 171 * @param val message to use when reporting a match. 172 * @return Builder object. 173 * @noinspection ReturnOfInnerClass 174 */ 175 public Builder message(String val) { 176 message = val; 177 return this; 178 } 179 180 /** 181 * Specifies the minimum allowed number of detections and returns Builder object. 182 * @param val the minimum allowed number of detections. 183 * @return Builder object. 184 * @noinspection ReturnOfInnerClass 185 */ 186 public Builder minimum(int val) { 187 minimum = val; 188 return this; 189 } 190 191 /** 192 * Specifies the maximum allowed number of detections and returns Builder object. 193 * @param val the maximum allowed number of detections. 194 * @return Builder object. 195 * @noinspection ReturnOfInnerClass 196 */ 197 public Builder maximum(int val) { 198 maximum = val; 199 return this; 200 } 201 202 /** 203 * Specifies whether to ignore case when matching and returns Builder object. 204 * @param val whether to ignore case when matching. 205 * @return Builder object. 206 * @noinspection ReturnOfInnerClass 207 */ 208 public Builder ignoreCase(boolean val) { 209 ignoreCase = val; 210 return this; 211 } 212 213 /** 214 * Specifies the suppressor to use and returns Builder object. 215 * @param val the suppressor to use. 216 * @return current instance 217 * @noinspection ReturnOfInnerClass 218 */ 219 public Builder suppressor(MatchSuppressor val) { 220 suppressor = val; 221 return this; 222 } 223 224 /** 225 * Returns new DetectorOptions instance. 226 * @return DetectorOptions instance. 227 */ 228 public DetectorOptions build() { 229 message = Optional.ofNullable(message).orElse(""); 230 suppressor = Optional.ofNullable(suppressor).orElse(NeverSuppress.INSTANCE); 231 return DetectorOptions.this; 232 } 233 } 234}