commit | author | age
|
f13c4c
|
1 |
/*
|
JM |
2 |
* Copyright 2011 gitblit.com.
|
|
3 |
*
|
|
4 |
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
5 |
* you may not use this file except in compliance with the License.
|
|
6 |
* You may obtain a copy of the License at
|
|
7 |
*
|
|
8 |
* http://www.apache.org/licenses/LICENSE-2.0
|
|
9 |
*
|
|
10 |
* Unless required by applicable law or agreed to in writing, software
|
|
11 |
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
12 |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
13 |
* See the License for the specific language governing permissions and
|
|
14 |
* limitations under the License.
|
|
15 |
*/
|
87cc1e
|
16 |
package com.gitblit.utils;
|
JM |
17 |
|
b34048
|
18 |
import java.io.ByteArrayOutputStream;
|
87cc1e
|
19 |
import java.io.UnsupportedEncodingException;
|
ae9e15
|
20 |
import java.nio.ByteBuffer;
|
JM |
21 |
import java.nio.CharBuffer;
|
|
22 |
import java.nio.charset.CharacterCodingException;
|
|
23 |
import java.nio.charset.Charset;
|
|
24 |
import java.nio.charset.CharsetDecoder;
|
|
25 |
import java.nio.charset.IllegalCharsetNameException;
|
|
26 |
import java.nio.charset.UnsupportedCharsetException;
|
87cc1e
|
27 |
import java.security.MessageDigest;
|
JM |
28 |
import java.security.NoSuchAlgorithmException;
|
f339f5
|
29 |
import java.util.ArrayList;
|
ae9e15
|
30 |
import java.util.Arrays;
|
0b9119
|
31 |
import java.util.Collection;
|
94750e
|
32 |
import java.util.Collections;
|
JM |
33 |
import java.util.Comparator;
|
ae9e15
|
34 |
import java.util.LinkedHashSet;
|
87cc1e
|
35 |
import java.util.List;
|
ae9e15
|
36 |
import java.util.Set;
|
eb870f
|
37 |
import java.util.regex.Matcher;
|
JM |
38 |
import java.util.regex.Pattern;
|
f339f5
|
39 |
import java.util.regex.PatternSyntaxException;
|
8c9a20
|
40 |
|
d9f687
|
41 |
/**
|
JM |
42 |
* Utility class of string functions.
|
699e71
|
43 |
*
|
d9f687
|
44 |
* @author James Moger
|
699e71
|
45 |
*
|
d9f687
|
46 |
*/
|
87cc1e
|
47 |
public class StringUtils {
|
8c9a20
|
48 |
|
JM |
49 |
public static final String MD5_TYPE = "MD5:";
|
309c55
|
50 |
|
d5623a
|
51 |
public static final String COMBINED_MD5_TYPE = "CMD5:";
|
3e087a
|
52 |
|
d9f687
|
53 |
/**
|
JM |
54 |
* Returns true if the string is null or empty.
|
699e71
|
55 |
*
|
d9f687
|
56 |
* @param value
|
JM |
57 |
* @return true if string is null or empty
|
|
58 |
*/
|
87cc1e
|
59 |
public static boolean isEmpty(String value) {
|
JM |
60 |
return value == null || value.trim().length() == 0;
|
|
61 |
}
|
|
62 |
|
d9f687
|
63 |
/**
|
JM |
64 |
* Replaces carriage returns and line feeds with html line breaks.
|
699e71
|
65 |
*
|
d9f687
|
66 |
* @param string
|
JM |
67 |
* @return plain text with html line breaks
|
|
68 |
*/
|
87cc1e
|
69 |
public static String breakLinesForHtml(String string) {
|
JM |
70 |
return string.replace("\r\n", "<br/>").replace("\r", "<br/>").replace("\n", "<br/>");
|
|
71 |
}
|
|
72 |
|
d9f687
|
73 |
/**
|
JM |
74 |
* Prepare text for html presentation. Replace sensitive characters with
|
|
75 |
* html entities.
|
699e71
|
76 |
*
|
d9f687
|
77 |
* @param inStr
|
JM |
78 |
* @param changeSpace
|
|
79 |
* @return plain text escaped for html
|
|
80 |
*/
|
87cc1e
|
81 |
public static String escapeForHtml(String inStr, boolean changeSpace) {
|
8a53c0
|
82 |
StringBuilder retStr = new StringBuilder();
|
87cc1e
|
83 |
int i = 0;
|
JM |
84 |
while (i < inStr.length()) {
|
|
85 |
if (inStr.charAt(i) == '&') {
|
|
86 |
retStr.append("&");
|
|
87 |
} else if (inStr.charAt(i) == '<') {
|
|
88 |
retStr.append("<");
|
|
89 |
} else if (inStr.charAt(i) == '>') {
|
|
90 |
retStr.append(">");
|
|
91 |
} else if (inStr.charAt(i) == '\"') {
|
|
92 |
retStr.append(""");
|
|
93 |
} else if (changeSpace && inStr.charAt(i) == ' ') {
|
|
94 |
retStr.append(" ");
|
|
95 |
} else if (changeSpace && inStr.charAt(i) == '\t') {
|
|
96 |
retStr.append(" ");
|
8c9a20
|
97 |
} else {
|
JM |
98 |
retStr.append(inStr.charAt(i));
|
|
99 |
}
|
|
100 |
i++;
|
|
101 |
}
|
|
102 |
return retStr.toString();
|
|
103 |
}
|
|
104 |
|
d9f687
|
105 |
/**
|
JM |
106 |
* Decode html entities back into plain text characters.
|
699e71
|
107 |
*
|
d9f687
|
108 |
* @param inStr
|
JM |
109 |
* @return returns plain text from html
|
|
110 |
*/
|
85c2e6
|
111 |
public static String decodeFromHtml(String inStr) {
|
JM |
112 |
return inStr.replace("&", "&").replace("<", "<").replace(">", ">")
|
|
113 |
.replace(""", "\"").replace(" ", " ");
|
|
114 |
}
|
|
115 |
|
d9f687
|
116 |
/**
|
JM |
117 |
* Encodes a url parameter by escaping troublesome characters.
|
699e71
|
118 |
*
|
d9f687
|
119 |
* @param inStr
|
JM |
120 |
* @return properly escaped url
|
|
121 |
*/
|
8c9a20
|
122 |
public static String encodeURL(String inStr) {
|
8a53c0
|
123 |
StringBuilder retStr = new StringBuilder();
|
8c9a20
|
124 |
int i = 0;
|
JM |
125 |
while (i < inStr.length()) {
|
|
126 |
if (inStr.charAt(i) == '/') {
|
|
127 |
retStr.append("%2F");
|
|
128 |
} else if (inStr.charAt(i) == ' ') {
|
|
129 |
retStr.append("%20");
|
16aa5a
|
130 |
} else if (inStr.charAt(i) == '&') {
|
JM |
131 |
retStr.append("%26");
|
46bfcc
|
132 |
} else if (inStr.charAt(i) == '+') {
|
JM |
133 |
retStr.append("%2B");
|
2a7306
|
134 |
} else {
|
87cc1e
|
135 |
retStr.append(inStr.charAt(i));
|
2a7306
|
136 |
}
|
87cc1e
|
137 |
i++;
|
JM |
138 |
}
|
|
139 |
return retStr.toString();
|
|
140 |
}
|
|
141 |
|
d9f687
|
142 |
/**
|
4bdd39
|
143 |
* Flatten the list of strings into a single string with the specified
|
JM |
144 |
* separator.
|
|
145 |
*
|
|
146 |
* @param values
|
|
147 |
* @param separator
|
|
148 |
* @return flattened list
|
|
149 |
*/
|
|
150 |
public static String flattenStrings(String[] values, String separator) {
|
|
151 |
return flattenStrings(Arrays.asList(values), separator);
|
|
152 |
}
|
|
153 |
|
|
154 |
/**
|
d9f687
|
155 |
* Flatten the list of strings into a single string with a space separator.
|
699e71
|
156 |
*
|
d9f687
|
157 |
* @param values
|
JM |
158 |
* @return flattened list
|
|
159 |
*/
|
0b9119
|
160 |
public static String flattenStrings(Collection<String> values) {
|
8a2e9c
|
161 |
return flattenStrings(values, " ");
|
JM |
162 |
}
|
|
163 |
|
d9f687
|
164 |
/**
|
JM |
165 |
* Flatten the list of strings into a single string with the specified
|
|
166 |
* separator.
|
699e71
|
167 |
*
|
d9f687
|
168 |
* @param values
|
JM |
169 |
* @param separator
|
|
170 |
* @return flattened list
|
|
171 |
*/
|
0b9119
|
172 |
public static String flattenStrings(Collection<String> values, String separator) {
|
87cc1e
|
173 |
StringBuilder sb = new StringBuilder();
|
JM |
174 |
for (String value : values) {
|
8a2e9c
|
175 |
sb.append(value).append(separator);
|
87cc1e
|
176 |
}
|
6e666f
|
177 |
if (sb.length() > 0) {
|
JM |
178 |
// truncate trailing separator
|
|
179 |
sb.setLength(sb.length() - separator.length());
|
|
180 |
}
|
87cc1e
|
181 |
return sb.toString().trim();
|
JM |
182 |
}
|
|
183 |
|
d9f687
|
184 |
/**
|
JM |
185 |
* Returns a string trimmed to a maximum length with trailing ellipses. If
|
|
186 |
* the string length is shorter than the max, the original string is
|
|
187 |
* returned.
|
699e71
|
188 |
*
|
d9f687
|
189 |
* @param value
|
JM |
190 |
* @param max
|
|
191 |
* @return trimmed string
|
|
192 |
*/
|
87cc1e
|
193 |
public static String trimString(String value, int max) {
|
JM |
194 |
if (value.length() <= max) {
|
|
195 |
return value;
|
|
196 |
}
|
|
197 |
return value.substring(0, max - 3) + "...";
|
|
198 |
}
|
|
199 |
|
d9f687
|
200 |
/**
|
JM |
201 |
* Left pad a string with the specified character, if the string length is
|
|
202 |
* less than the specified length.
|
699e71
|
203 |
*
|
d9f687
|
204 |
* @param input
|
JM |
205 |
* @param length
|
|
206 |
* @param pad
|
|
207 |
* @return left-padded string
|
|
208 |
*/
|
87cc1e
|
209 |
public static String leftPad(String input, int length, char pad) {
|
JM |
210 |
if (input.length() < length) {
|
|
211 |
StringBuilder sb = new StringBuilder();
|
|
212 |
for (int i = 0, len = length - input.length(); i < len; i++) {
|
|
213 |
sb.append(pad);
|
|
214 |
}
|
|
215 |
sb.append(input);
|
|
216 |
return sb.toString();
|
|
217 |
}
|
|
218 |
return input;
|
|
219 |
}
|
|
220 |
|
d9f687
|
221 |
/**
|
JM |
222 |
* Right pad a string with the specified character, if the string length is
|
|
223 |
* less then the specified length.
|
699e71
|
224 |
*
|
d9f687
|
225 |
* @param input
|
JM |
226 |
* @param length
|
|
227 |
* @param pad
|
|
228 |
* @return right-padded string
|
|
229 |
*/
|
87cc1e
|
230 |
public static String rightPad(String input, int length, char pad) {
|
JM |
231 |
if (input.length() < length) {
|
|
232 |
StringBuilder sb = new StringBuilder();
|
|
233 |
sb.append(input);
|
|
234 |
for (int i = 0, len = length - input.length(); i < len; i++) {
|
|
235 |
sb.append(pad);
|
|
236 |
}
|
|
237 |
return sb.toString();
|
|
238 |
}
|
|
239 |
return input;
|
|
240 |
}
|
|
241 |
|
d9f687
|
242 |
/**
|
JM |
243 |
* Calculates the SHA1 of the string.
|
699e71
|
244 |
*
|
d9f687
|
245 |
* @param text
|
JM |
246 |
* @return sha1 of the string
|
|
247 |
*/
|
87cc1e
|
248 |
public static String getSHA1(String text) {
|
JM |
249 |
try {
|
|
250 |
byte[] bytes = text.getBytes("iso-8859-1");
|
|
251 |
return getSHA1(bytes);
|
|
252 |
} catch (UnsupportedEncodingException u) {
|
|
253 |
throw new RuntimeException(u);
|
|
254 |
}
|
|
255 |
}
|
|
256 |
|
d9f687
|
257 |
/**
|
JM |
258 |
* Calculates the SHA1 of the byte array.
|
699e71
|
259 |
*
|
d9f687
|
260 |
* @param bytes
|
JM |
261 |
* @return sha1 of the byte array
|
|
262 |
*/
|
87cc1e
|
263 |
public static String getSHA1(byte[] bytes) {
|
JM |
264 |
try {
|
|
265 |
MessageDigest md = MessageDigest.getInstance("SHA-1");
|
|
266 |
md.update(bytes, 0, bytes.length);
|
8c9a20
|
267 |
byte[] digest = md.digest();
|
JM |
268 |
return toHex(digest);
|
87cc1e
|
269 |
} catch (NoSuchAlgorithmException t) {
|
JM |
270 |
throw new RuntimeException(t);
|
f97bf0
|
271 |
}
|
8c9a20
|
272 |
}
|
JM |
273 |
|
d9f687
|
274 |
/**
|
JM |
275 |
* Calculates the MD5 of the string.
|
699e71
|
276 |
*
|
d9f687
|
277 |
* @param string
|
JM |
278 |
* @return md5 of the string
|
|
279 |
*/
|
8c9a20
|
280 |
public static String getMD5(String string) {
|
JM |
281 |
try {
|
4ad1eb
|
282 |
return getMD5(string.getBytes("iso-8859-1"));
|
5450d0
|
283 |
} catch (UnsupportedEncodingException u) {
|
JM |
284 |
throw new RuntimeException(u);
|
4ad1eb
|
285 |
}
|
JM |
286 |
}
|
699e71
|
287 |
|
4ad1eb
|
288 |
/**
|
JM |
289 |
* Calculates the MD5 of the string.
|
699e71
|
290 |
*
|
4ad1eb
|
291 |
* @param string
|
JM |
292 |
* @return md5 of the string
|
|
293 |
*/
|
|
294 |
public static String getMD5(byte [] bytes) {
|
|
295 |
try {
|
|
296 |
MessageDigest md = MessageDigest.getInstance("MD5");
|
|
297 |
md.reset();
|
|
298 |
md.update(bytes);
|
|
299 |
byte[] digest = md.digest();
|
|
300 |
return toHex(digest);
|
5450d0
|
301 |
} catch (NoSuchAlgorithmException t) {
|
JM |
302 |
throw new RuntimeException(t);
|
8c9a20
|
303 |
}
|
JM |
304 |
}
|
|
305 |
|
d9f687
|
306 |
/**
|
JM |
307 |
* Returns the hex representation of the byte array.
|
699e71
|
308 |
*
|
d9f687
|
309 |
* @param bytes
|
JM |
310 |
* @return byte array as hex string
|
|
311 |
*/
|
b2fec2
|
312 |
public static String toHex(byte[] bytes) {
|
8c9a20
|
313 |
StringBuilder sb = new StringBuilder(bytes.length * 2);
|
JM |
314 |
for (int i = 0; i < bytes.length; i++) {
|
699e71
|
315 |
if ((bytes[i] & 0xff) < 0x10) {
|
8c9a20
|
316 |
sb.append('0');
|
JM |
317 |
}
|
699e71
|
318 |
sb.append(Long.toString(bytes[i] & 0xff, 16));
|
8c9a20
|
319 |
}
|
JM |
320 |
return sb.toString();
|
|
321 |
}
|
85c2e6
|
322 |
|
d9f687
|
323 |
/**
|
JM |
324 |
* Returns the root path of the specified path. Returns a blank string if
|
|
325 |
* there is no root path.
|
699e71
|
326 |
*
|
d9f687
|
327 |
* @param path
|
JM |
328 |
* @return root path or blank
|
|
329 |
*/
|
00afd7
|
330 |
public static String getRootPath(String path) {
|
JM |
331 |
if (path.indexOf('/') > -1) {
|
ec97f7
|
332 |
return path.substring(0, path.lastIndexOf('/'));
|
00afd7
|
333 |
}
|
JM |
334 |
return "";
|
|
335 |
}
|
008322
|
336 |
|
d9f687
|
337 |
/**
|
JM |
338 |
* Returns the path remainder after subtracting the basePath from the
|
|
339 |
* fullPath.
|
699e71
|
340 |
*
|
d9f687
|
341 |
* @param basePath
|
JM |
342 |
* @param fullPath
|
|
343 |
* @return the relative path
|
|
344 |
*/
|
008322
|
345 |
public static String getRelativePath(String basePath, String fullPath) {
|
ffbd6e
|
346 |
String bp = basePath.replace('\\', '/').toLowerCase();
|
JM |
347 |
String fp = fullPath.replace('\\', '/').toLowerCase();
|
|
348 |
if (fp.startsWith(bp)) {
|
|
349 |
String relativePath = fullPath.substring(basePath.length()).replace('\\', '/');
|
daaf89
|
350 |
if (relativePath.length() > 0 && relativePath.charAt(0) == '/') {
|
ffbd6e
|
351 |
relativePath = relativePath.substring(1);
|
JM |
352 |
}
|
|
353 |
return relativePath;
|
a125cf
|
354 |
}
|
ffbd6e
|
355 |
return fullPath;
|
a125cf
|
356 |
}
|
8c9a20
|
357 |
|
d9f687
|
358 |
/**
|
JM |
359 |
* Splits the space-separated string into a list of strings.
|
699e71
|
360 |
*
|
d9f687
|
361 |
* @param value
|
JM |
362 |
* @return list of strings
|
|
363 |
*/
|
f339f5
|
364 |
public static List<String> getStringsFromValue(String value) {
|
JM |
365 |
return getStringsFromValue(value, " ");
|
|
366 |
}
|
8c9a20
|
367 |
|
d9f687
|
368 |
/**
|
JM |
369 |
* Splits the string into a list of string by the specified separator.
|
699e71
|
370 |
*
|
d9f687
|
371 |
* @param value
|
JM |
372 |
* @param separator
|
|
373 |
* @return list of strings
|
|
374 |
*/
|
f339f5
|
375 |
public static List<String> getStringsFromValue(String value, String separator) {
|
3d699c
|
376 |
List<String> strings = new ArrayList<String>();
|
U |
377 |
try {
|
699e71
|
378 |
String[] chunks = value.split(separator + "(?=([^\"]*\"[^\"]*\")*[^\"]*$)");
|
3d699c
|
379 |
for (String chunk : chunks) {
|
U |
380 |
chunk = chunk.trim();
|
|
381 |
if (chunk.length() > 0) {
|
|
382 |
if (chunk.charAt(0) == '"' && chunk.charAt(chunk.length() - 1) == '"') {
|
|
383 |
// strip double quotes
|
|
384 |
chunk = chunk.substring(1, chunk.length() - 1).trim();
|
|
385 |
}
|
|
386 |
strings.add(chunk);
|
|
387 |
}
|
|
388 |
}
|
|
389 |
} catch (PatternSyntaxException e) {
|
|
390 |
throw new RuntimeException(e);
|
|
391 |
}
|
|
392 |
return strings;
|
|
393 |
}
|
831469
|
394 |
|
JM |
395 |
/**
|
|
396 |
* Validates that a name is composed of letters, digits, or limited other
|
|
397 |
* characters.
|
699e71
|
398 |
*
|
831469
|
399 |
* @param name
|
JM |
400 |
* @return the first invalid character found or null if string is acceptable
|
|
401 |
*/
|
|
402 |
public static Character findInvalidCharacter(String name) {
|
46bfcc
|
403 |
char[] validChars = { '/', '.', '_', '-', '~', '+' };
|
831469
|
404 |
for (char c : name.toCharArray()) {
|
JM |
405 |
if (!Character.isLetterOrDigit(c)) {
|
|
406 |
boolean ok = false;
|
|
407 |
for (char vc : validChars) {
|
|
408 |
ok |= c == vc;
|
|
409 |
}
|
|
410 |
if (!ok) {
|
|
411 |
return c;
|
|
412 |
}
|
|
413 |
}
|
|
414 |
}
|
|
415 |
return null;
|
|
416 |
}
|
|
417 |
|
|
418 |
/**
|
|
419 |
* Simple fuzzy string comparison. This is a case-insensitive check. A
|
|
420 |
* single wildcard * value is supported.
|
699e71
|
421 |
*
|
831469
|
422 |
* @param value
|
JM |
423 |
* @param pattern
|
|
424 |
* @return true if the value matches the pattern
|
|
425 |
*/
|
|
426 |
public static boolean fuzzyMatch(String value, String pattern) {
|
|
427 |
if (value.equalsIgnoreCase(pattern)) {
|
|
428 |
return true;
|
|
429 |
}
|
|
430 |
if (pattern.contains("*")) {
|
|
431 |
boolean prefixMatches = false;
|
|
432 |
boolean suffixMatches = false;
|
|
433 |
|
|
434 |
int wildcard = pattern.indexOf('*');
|
|
435 |
String prefix = pattern.substring(0, wildcard).toLowerCase();
|
|
436 |
prefixMatches = value.toLowerCase().startsWith(prefix);
|
|
437 |
|
|
438 |
if (pattern.length() > (wildcard + 1)) {
|
|
439 |
String suffix = pattern.substring(wildcard + 1).toLowerCase();
|
|
440 |
suffixMatches = value.toLowerCase().endsWith(suffix);
|
|
441 |
return prefixMatches && suffixMatches;
|
|
442 |
}
|
|
443 |
return prefixMatches || suffixMatches;
|
|
444 |
}
|
|
445 |
return false;
|
|
446 |
}
|
94750e
|
447 |
|
JM |
448 |
/**
|
|
449 |
* Compare two repository names for proper group sorting.
|
699e71
|
450 |
*
|
94750e
|
451 |
* @param r1
|
JM |
452 |
* @param r2
|
|
453 |
* @return
|
|
454 |
*/
|
|
455 |
public static int compareRepositoryNames(String r1, String r2) {
|
|
456 |
// sort root repositories first, alphabetically
|
|
457 |
// then sort grouped repositories, alphabetically
|
62f435
|
458 |
r1 = r1.toLowerCase();
|
JM |
459 |
r2 = r2.toLowerCase();
|
94750e
|
460 |
int s1 = r1.indexOf('/');
|
JM |
461 |
int s2 = r2.indexOf('/');
|
|
462 |
if (s1 == -1 && s2 == -1) {
|
|
463 |
// neither grouped
|
|
464 |
return r1.compareTo(r2);
|
|
465 |
} else if (s1 > -1 && s2 > -1) {
|
|
466 |
// both grouped
|
|
467 |
return r1.compareTo(r2);
|
|
468 |
} else if (s1 == -1) {
|
|
469 |
return -1;
|
|
470 |
} else if (s2 == -1) {
|
|
471 |
return 1;
|
|
472 |
}
|
|
473 |
return 0;
|
|
474 |
}
|
|
475 |
|
|
476 |
/**
|
|
477 |
* Sort grouped repository names.
|
699e71
|
478 |
*
|
94750e
|
479 |
* @param list
|
JM |
480 |
*/
|
|
481 |
public static void sortRepositorynames(List<String> list) {
|
|
482 |
Collections.sort(list, new Comparator<String>() {
|
|
483 |
@Override
|
|
484 |
public int compare(String o1, String o2) {
|
|
485 |
return compareRepositoryNames(o1, o2);
|
|
486 |
}
|
|
487 |
});
|
|
488 |
}
|
309c55
|
489 |
|
JM |
490 |
public static String getColor(String value) {
|
|
491 |
int cs = 0;
|
|
492 |
for (char c : getMD5(value.toLowerCase()).toCharArray()) {
|
|
493 |
cs += c;
|
|
494 |
}
|
699e71
|
495 |
int n = (cs % 360);
|
309c55
|
496 |
float hue = ((float) n) / 360;
|
JM |
497 |
return hsvToRgb(hue, 0.90f, 0.65f);
|
|
498 |
}
|
|
499 |
|
|
500 |
public static String hsvToRgb(float hue, float saturation, float value) {
|
|
501 |
int h = (int) (hue * 6);
|
|
502 |
float f = hue * 6 - h;
|
|
503 |
float p = value * (1 - saturation);
|
|
504 |
float q = value * (1 - f * saturation);
|
|
505 |
float t = value * (1 - (1 - f) * saturation);
|
|
506 |
|
|
507 |
switch (h) {
|
|
508 |
case 0:
|
|
509 |
return rgbToString(value, t, p);
|
|
510 |
case 1:
|
|
511 |
return rgbToString(q, value, p);
|
|
512 |
case 2:
|
|
513 |
return rgbToString(p, value, t);
|
|
514 |
case 3:
|
|
515 |
return rgbToString(p, q, value);
|
|
516 |
case 4:
|
|
517 |
return rgbToString(t, p, value);
|
|
518 |
case 5:
|
|
519 |
return rgbToString(value, p, q);
|
|
520 |
default:
|
|
521 |
throw new RuntimeException(
|
|
522 |
"Something went wrong when converting from HSV to RGB. Input was " + hue + ", "
|
|
523 |
+ saturation + ", " + value);
|
|
524 |
}
|
|
525 |
}
|
|
526 |
|
|
527 |
public static String rgbToString(float r, float g, float b) {
|
|
528 |
String rs = Integer.toHexString((int) (r * 256));
|
|
529 |
String gs = Integer.toHexString((int) (g * 256));
|
|
530 |
String bs = Integer.toHexString((int) (b * 256));
|
|
531 |
return "#" + rs + gs + bs;
|
|
532 |
}
|
699e71
|
533 |
|
12c31e
|
534 |
/**
|
JM |
535 |
* Strips a trailing ".git" from the value.
|
699e71
|
536 |
*
|
12c31e
|
537 |
* @param value
|
JM |
538 |
* @return a stripped value or the original value if .git is not found
|
|
539 |
*/
|
6c6fbf
|
540 |
public static String stripDotGit(String value) {
|
JM |
541 |
if (value.toLowerCase().endsWith(".git")) {
|
|
542 |
return value.substring(0, value.length() - 4);
|
|
543 |
}
|
|
544 |
return value;
|
|
545 |
}
|
699e71
|
546 |
|
12c31e
|
547 |
/**
|
JM |
548 |
* Count the number of lines in a string.
|
699e71
|
549 |
*
|
12c31e
|
550 |
* @param value
|
JM |
551 |
* @return the line count
|
|
552 |
*/
|
672296
|
553 |
public static int countLines(String value) {
|
JM |
554 |
if (isEmpty(value)) {
|
|
555 |
return 0;
|
|
556 |
}
|
|
557 |
return value.split("\n").length;
|
|
558 |
}
|
699e71
|
559 |
|
12c31e
|
560 |
/**
|
JM |
561 |
* Returns the file extension of a path.
|
699e71
|
562 |
*
|
12c31e
|
563 |
* @param path
|
JM |
564 |
* @return a blank string or a file extension
|
|
565 |
*/
|
|
566 |
public static String getFileExtension(String path) {
|
|
567 |
int lastDot = path.lastIndexOf('.');
|
|
568 |
if (lastDot > -1) {
|
|
569 |
return path.substring(lastDot + 1);
|
|
570 |
}
|
|
571 |
return "";
|
|
572 |
}
|
699e71
|
573 |
|
f3b625
|
574 |
/**
|
dc7c2f
|
575 |
* Returns the file extension of a path.
|
JM |
576 |
*
|
|
577 |
* @param path
|
|
578 |
* @return a blank string or a file extension
|
|
579 |
*/
|
|
580 |
public static String stripFileExtension(String path) {
|
|
581 |
int lastDot = path.lastIndexOf('.');
|
|
582 |
if (lastDot > -1) {
|
|
583 |
return path.substring(0, lastDot);
|
|
584 |
}
|
|
585 |
return path;
|
|
586 |
}
|
|
587 |
|
|
588 |
/**
|
f3b625
|
589 |
* Replace all occurences of a substring within a string with
|
JC |
590 |
* another string.
|
699e71
|
591 |
*
|
f3b625
|
592 |
* From Spring StringUtils.
|
699e71
|
593 |
*
|
f3b625
|
594 |
* @param inString String to examine
|
JC |
595 |
* @param oldPattern String to replace
|
|
596 |
* @param newPattern String to insert
|
|
597 |
* @return a String with the replacements
|
|
598 |
*/
|
|
599 |
public static String replace(String inString, String oldPattern, String newPattern) {
|
|
600 |
StringBuilder sb = new StringBuilder();
|
|
601 |
int pos = 0; // our position in the old string
|
|
602 |
int index = inString.indexOf(oldPattern);
|
|
603 |
// the index of an occurrence we've found, or -1
|
|
604 |
int patLen = oldPattern.length();
|
|
605 |
while (index >= 0) {
|
|
606 |
sb.append(inString.substring(pos, index));
|
|
607 |
sb.append(newPattern);
|
|
608 |
pos = index + patLen;
|
|
609 |
index = inString.indexOf(oldPattern, pos);
|
|
610 |
}
|
|
611 |
sb.append(inString.substring(pos));
|
|
612 |
// remember to append any characters to the right of a match
|
|
613 |
return sb.toString();
|
|
614 |
}
|
699e71
|
615 |
|
ae9e15
|
616 |
/**
|
JM |
617 |
* Decodes a string by trying several charsets until one does not throw a
|
|
618 |
* coding exception. Last resort is to interpret as UTF-8 with illegal
|
|
619 |
* character substitution.
|
699e71
|
620 |
*
|
ae9e15
|
621 |
* @param content
|
JM |
622 |
* @param charsets optional
|
|
623 |
* @return a string
|
|
624 |
*/
|
|
625 |
public static String decodeString(byte [] content, String... charsets) {
|
|
626 |
Set<String> sets = new LinkedHashSet<String>();
|
|
627 |
if (!ArrayUtils.isEmpty(charsets)) {
|
|
628 |
sets.addAll(Arrays.asList(charsets));
|
|
629 |
}
|
086c04
|
630 |
String value = null;
|
ae9e15
|
631 |
sets.addAll(Arrays.asList("UTF-8", "ISO-8859-1", Charset.defaultCharset().name()));
|
JM |
632 |
for (String charset : sets) {
|
|
633 |
try {
|
|
634 |
Charset cs = Charset.forName(charset);
|
|
635 |
CharsetDecoder decoder = cs.newDecoder();
|
|
636 |
CharBuffer buffer = decoder.decode(ByteBuffer.wrap(content));
|
086c04
|
637 |
value = buffer.toString();
|
JM |
638 |
break;
|
ae9e15
|
639 |
} catch (CharacterCodingException e) {
|
JM |
640 |
// ignore and advance to the next charset
|
|
641 |
} catch (IllegalCharsetNameException e) {
|
|
642 |
// ignore illegal charset names
|
|
643 |
} catch (UnsupportedCharsetException e) {
|
|
644 |
// ignore unsupported charsets
|
|
645 |
}
|
|
646 |
}
|
872462
|
647 |
if (value != null && value.startsWith("\uFEFF")) {
|
086c04
|
648 |
// strip UTF-8 BOM
|
JM |
649 |
return value.substring(1);
|
|
650 |
}
|
|
651 |
return value;
|
ae9e15
|
652 |
}
|
699e71
|
653 |
|
eb870f
|
654 |
/**
|
JM |
655 |
* Attempt to extract a repository name from a given url using regular
|
|
656 |
* expressions. If no match is made, then return whatever trails after
|
|
657 |
* the final / character.
|
699e71
|
658 |
*
|
eb870f
|
659 |
* @param regexUrls
|
JM |
660 |
* @return a repository path
|
|
661 |
*/
|
|
662 |
public static String extractRepositoryPath(String url, String... urlpatterns) {
|
|
663 |
for (String urlPattern : urlpatterns) {
|
|
664 |
Pattern p = Pattern.compile(urlPattern);
|
|
665 |
Matcher m = p.matcher(url);
|
|
666 |
while (m.find()) {
|
|
667 |
String repositoryPath = m.group(1);
|
|
668 |
return repositoryPath;
|
|
669 |
}
|
|
670 |
}
|
|
671 |
// last resort
|
|
672 |
if (url.lastIndexOf('/') > -1) {
|
|
673 |
return url.substring(url.lastIndexOf('/') + 1);
|
|
674 |
}
|
|
675 |
return url;
|
|
676 |
}
|
699e71
|
677 |
|
b34048
|
678 |
/**
|
JM |
679 |
* Converts a string with \nnn sequences into a UTF-8 encoded string.
|
|
680 |
* @param input
|
|
681 |
* @return
|
|
682 |
*/
|
|
683 |
public static String convertOctal(String input) {
|
|
684 |
try {
|
|
685 |
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
|
|
686 |
Pattern p = Pattern.compile("(\\\\\\d{3})");
|
|
687 |
Matcher m = p.matcher(input);
|
|
688 |
int i = 0;
|
|
689 |
while (m.find()) {
|
|
690 |
bytes.write(input.substring(i, m.start()).getBytes("UTF-8"));
|
|
691 |
// replace octal encoded value
|
|
692 |
// strip leading \ character
|
|
693 |
String oct = m.group().substring(1);
|
|
694 |
bytes.write(Integer.parseInt(oct, 8));
|
699e71
|
695 |
i = m.end();
|
b34048
|
696 |
}
|
JM |
697 |
if (bytes.size() == 0) {
|
|
698 |
// no octal matches
|
|
699 |
return input;
|
|
700 |
} else {
|
|
701 |
if (i < input.length()) {
|
|
702 |
// add remainder of string
|
|
703 |
bytes.write(input.substring(i).getBytes("UTF-8"));
|
|
704 |
}
|
|
705 |
}
|
|
706 |
return bytes.toString("UTF-8");
|
|
707 |
} catch (Exception e) {
|
|
708 |
e.printStackTrace();
|
|
709 |
}
|
|
710 |
return input;
|
|
711 |
}
|
699e71
|
712 |
|
1e1b85
|
713 |
/**
|
JM |
714 |
* Returns the first path element of a path string. If no path separator is
|
699e71
|
715 |
* found in the path, an empty string is returned.
|
JM |
716 |
*
|
1e1b85
|
717 |
* @param path
|
JM |
718 |
* @return the first element in the path
|
|
719 |
*/
|
|
720 |
public static String getFirstPathElement(String path) {
|
|
721 |
if (path.indexOf('/') > -1) {
|
|
722 |
return path.substring(0, path.indexOf('/')).trim();
|
|
723 |
}
|
|
724 |
return "";
|
|
725 |
}
|
699e71
|
726 |
|
1e1b85
|
727 |
/**
|
JM |
728 |
* Returns the last path element of a path string
|
699e71
|
729 |
*
|
1e1b85
|
730 |
* @param path
|
JM |
731 |
* @return the last element in the path
|
|
732 |
*/
|
|
733 |
public static String getLastPathElement(String path) {
|
|
734 |
if (path.indexOf('/') > -1) {
|
|
735 |
return path.substring(path.lastIndexOf('/') + 1);
|
|
736 |
}
|
|
737 |
return path;
|
|
738 |
}
|
699e71
|
739 |
|
e5aaa5
|
740 |
/**
|
JM |
741 |
* Variation of String.matches() which disregards case issues.
|
699e71
|
742 |
*
|
e5aaa5
|
743 |
* @param regex
|
JM |
744 |
* @param input
|
|
745 |
* @return true if the pattern matches
|
|
746 |
*/
|
|
747 |
public static boolean matchesIgnoreCase(String input, String regex) {
|
|
748 |
Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
|
|
749 |
Matcher m = p.matcher(input);
|
|
750 |
return m.matches();
|
|
751 |
}
|
699e71
|
752 |
|
ac7e9a
|
753 |
/**
|
JM |
754 |
* Removes new line and carriage return chars from a string.
|
|
755 |
* If input value is null an empty string is returned.
|
699e71
|
756 |
*
|
ac7e9a
|
757 |
* @param input
|
JM |
758 |
* @return a sanitized or empty string
|
|
759 |
*/
|
|
760 |
public static String removeNewlines(String input) {
|
|
761 |
if (input == null) {
|
|
762 |
return "";
|
|
763 |
}
|
|
764 |
return input.replace('\n',' ').replace('\r', ' ').trim();
|
|
765 |
}
|
8f1c9f
|
766 |
|
JM |
767 |
|
|
768 |
/**
|
|
769 |
* Encode the username for user in an url.
|
|
770 |
*
|
|
771 |
* @param name
|
|
772 |
* @return the encoded name
|
|
773 |
*/
|
|
774 |
public static String encodeUsername(String name) {
|
|
775 |
return name.replace("@", "%40").replace(" ", "%20").replace("\\", "%5C");
|
|
776 |
}
|
|
777 |
|
|
778 |
/**
|
|
779 |
* Decode a username from an encoded url.
|
|
780 |
*
|
|
781 |
* @param name
|
|
782 |
* @return the decoded name
|
|
783 |
*/
|
|
784 |
public static String decodeUsername(String name) {
|
|
785 |
return name.replace("%40", "@").replace("%20", " ").replace("%5C", "\\");
|
|
786 |
}
|
309c55
|
787 |
} |