001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.util;
016    
017    import java.text.NumberFormat;
018    
019    import java.util.Locale;
020    
021    /**
022     * @author Brian Wing Shun Chan
023     */
024    public class TextFormatter {
025    
026            // Web Search --> WEB_SEARCH
027    
028            public static final int A = 0;
029    
030            // Web Search --> websearch
031    
032            public static final int B = 1;
033    
034            // Web Search --> web_search
035    
036            public static final int C = 2;
037    
038            // Web Search --> WebSearch
039    
040            public static final int D = 3;
041    
042            // Web Search --> web search
043    
044            public static final int E = 4;
045    
046            // Web Search --> webSearch
047    
048            public static final int F = 5;
049    
050            // formatId --> FormatId
051    
052            public static final int G = 6;
053    
054            // formatId --> format id
055    
056            public static final int H = 7;
057    
058            // FormatId --> formatId
059    
060            public static final int I = 8;
061    
062            // format-id --> Format Id
063    
064            public static final int J = 9;
065    
066            // formatId --> format-id
067    
068            public static final int K = 10;
069    
070            // FormatId --> formatId, FOrmatId --> FOrmatId
071    
072            public static final int L = 11;
073    
074            // format-id --> formatId
075    
076            public static final int M = 12;
077    
078            // format-id --> format_id
079    
080            public static final int N = 13;
081    
082            // format_id --> format-id
083    
084            public static final int O = 14;
085    
086            // formatID --> format-id
087    
088            public static final int P = 15;
089    
090            public static String format(String s, int style) {
091                    if (Validator.isNull(s)) {
092                            return null;
093                    }
094    
095                    s = s.trim();
096    
097                    if (style == A) {
098                            return _formatA(s);
099                    }
100                    else if (style == B) {
101                            return _formatB(s);
102                    }
103                    else if (style == C) {
104                            return _formatC(s);
105                    }
106                    else if (style == D) {
107                            return _formatD(s);
108                    }
109                    else if (style == E) {
110                            return _formatE(s);
111                    }
112                    else if (style == F) {
113                            return _formatF(s);
114                    }
115                    else if (style == G) {
116                            return _formatG(s);
117                    }
118                    else if (style == H) {
119                            return _formatH(s);
120                    }
121                    else if (style == I) {
122                            return _formatI(s);
123                    }
124                    else if (style == J) {
125                            return _formatJ(s);
126                    }
127                    else if (style == K) {
128                            return _formatK(s);
129                    }
130                    else if (style == L) {
131                            return _formatL(s);
132                    }
133                    else if (style == M) {
134                            return _formatM(s);
135                    }
136                    else if (style == N) {
137                            return _formatN(s);
138                    }
139                    else if (style == O) {
140                            return _formatO(s);
141                    }
142                    else if (style == P) {
143                            return _formatP(s);
144                    }
145                    else {
146                            return s;
147                    }
148            }
149    
150            /**
151             * @deprecated As of 6.2.0, replaced by {@link #formatStorageSize(double,
152             *             Locale)}
153             */
154            public static String formatKB(double size, Locale locale) {
155                    NumberFormat numberFormat = NumberFormat.getInstance(locale);
156    
157                    numberFormat.setMaximumFractionDigits(1);
158                    numberFormat.setMinimumFractionDigits(1);
159    
160                    return numberFormat.format(size / _STORAGE_SIZE_DENOMINATOR);
161            }
162    
163            /**
164             * @deprecated As of 6.2.0, replaced by {@link #formatStorageSize(int,
165             *             Locale)}
166             */
167            public static String formatKB(int size, Locale locale) {
168                    return formatKB((double)size, locale);
169            }
170    
171            public static String formatName(String name) {
172                    if (Validator.isNull(name)) {
173                            return name;
174                    }
175    
176                    char[] chars = name.toLowerCase().trim().toCharArray();
177    
178                    if (chars.length > 0) {
179                            chars[0] = Character.toUpperCase(chars[0]);
180                    }
181    
182                    for (int i = 0; i < chars.length; i++) {
183                            if (chars[i] == ' ') {
184                                    chars[i + 1] = Character.toUpperCase(chars[i + 1]);
185                            }
186                    }
187    
188                    return new String(chars);
189            }
190    
191            public static String formatPlural(String s) {
192                    if (Validator.isNull(s)) {
193                            return s;
194                    }
195    
196                    if (s.endsWith("s")) {
197                            s = s.substring(0, s.length() -1) + "ses";
198                    }
199                    else if (s.endsWith("y")) {
200                            s = s.substring(0, s.length() -1) + "ies";
201                    }
202                    else {
203                            s = s + "s";
204                    }
205    
206                    return s;
207            }
208    
209            public static String formatStorageSize(double size, Locale locale) {
210                    String suffix = _STORAGE_SIZE_SUFFIX_KB;
211    
212                    size = size / _STORAGE_SIZE_DENOMINATOR;
213    
214                    if (size > _STORAGE_SIZE_DENOMINATOR) {
215                            suffix = _STORAGE_SIZE_SUFFIX_MB;
216    
217                            size = size / _STORAGE_SIZE_DENOMINATOR;
218                    }
219    
220                    if (size > _STORAGE_SIZE_DENOMINATOR) {
221                            suffix = _STORAGE_SIZE_SUFFIX_GB;
222    
223                            size = size / _STORAGE_SIZE_DENOMINATOR;
224                    }
225    
226                    NumberFormat numberFormat = NumberFormat.getInstance(locale);
227    
228                    if (suffix.equals(_STORAGE_SIZE_SUFFIX_KB)) {
229                            numberFormat.setMaximumFractionDigits(0);
230                    }
231                    else {
232                            numberFormat.setMaximumFractionDigits(1);
233                    }
234    
235                    numberFormat.setMinimumFractionDigits(0);
236    
237                    return numberFormat.format(size) + suffix;
238            }
239    
240            public static String formatStorageSize(int size, Locale locale) {
241                    return formatStorageSize((double)size, locale);
242            }
243    
244            private static String _formatA(String s) {
245                    return StringUtil.replace(
246                            s.toUpperCase(), CharPool.SPACE, CharPool.UNDERLINE);
247            }
248    
249            private static String _formatB(String s) {
250                    return StringUtil.strip(s.toLowerCase(), CharPool.SPACE);
251            }
252    
253            private static String _formatC(String s) {
254                    return StringUtil.replace(
255                            s.toLowerCase(), CharPool.SPACE, CharPool.UNDERLINE);
256            }
257    
258            private static String _formatD(String s) {
259                    return StringUtil.strip(s, CharPool.SPACE);
260            }
261    
262            private static String _formatE(String s) {
263                    return s.toLowerCase();
264            }
265    
266            private static String _formatF(String s) {
267                    s = StringUtil.strip(s, CharPool.SPACE);
268    
269                    if (Character.isUpperCase(s.charAt(0))) {
270                            s = s.substring(0, 1).toLowerCase().concat(s.substring(1));
271                    }
272    
273                    return s;
274            }
275    
276            private static String _formatG(String s) {
277                    if (Character.isLowerCase(s.charAt(0))) {
278                            s = s.substring(0, 1).toUpperCase().concat(s.substring(1));
279                    }
280    
281                    return s;
282            }
283    
284            private static String _formatH(String s) {
285                    StringBuilder sb = new StringBuilder(s.length() * 2);
286    
287                    for (int i = 0; i < s.length(); i++) {
288                            char c = s.charAt(i);
289    
290                            if (Character.isUpperCase(c)) {
291                                    sb.append(CharPool.SPACE);
292                                    sb.append(Character.toLowerCase(c));
293                            }
294                            else {
295                                    sb.append(c);
296                            }
297                    }
298    
299                    return sb.toString().trim();
300            }
301    
302            private static String _formatI(String s) {
303                    if (s.length() == 1) {
304                            return s.toLowerCase();
305                    }
306    
307                    if (Character.isLowerCase(s.charAt(0))) {
308                            return s;
309                    }
310    
311                    if (Character.isUpperCase(s.charAt(0)) &&
312                            Character.isLowerCase(s.charAt(1))) {
313    
314                            return s = s.substring(0, 1).toLowerCase().concat(s.substring(1));
315                    }
316    
317                    StringBuilder sb = new StringBuilder(s);
318    
319                    for (int i = 0; i < s.length(); i++) {
320                            if (((i + 1) != s.length()) &&
321                                    Character.isLowerCase(s.charAt(i + 1))) {
322    
323                                    break;
324                            }
325                            else {
326                                    char c = Character.toLowerCase(s.charAt(i));
327    
328                                    sb.setCharAt(i, c);
329                            }
330                    }
331    
332                    return sb.toString();
333            }
334    
335            private static String _formatJ(String s) {
336                    s = StringUtil.replace(s, CharPool.DASH, CharPool.SPACE);
337                    s = StringUtil.replace(s, CharPool.UNDERLINE, CharPool.SPACE);
338    
339                    StringBuilder sb = new StringBuilder(s.toLowerCase());
340    
341                    for (int i = 0; i < s.length(); i++) {
342                            if ((i == 0) || (s.charAt(i - 1) == ' ')) {
343                                    sb.setCharAt(i, Character.toUpperCase(s.charAt(i)));
344                            }
345                    }
346    
347                    return sb.toString();
348            }
349    
350            private static String _formatK(String s) {
351                    s = _formatH(s);
352                    s = StringUtil.replace(s, CharPool.SPACE, CharPool.DASH);
353    
354                    return s;
355            }
356    
357            private static String _formatL(String s) {
358                    if (s.length() == 1) {
359                            return s.toLowerCase();
360                    }
361                    else if (Character.isLowerCase(s.charAt(0)) ||
362                                     (Character.isUpperCase(s.charAt(0)) &&
363                                      Character.isUpperCase(s.charAt(1)))) {
364    
365                            return s;
366                    }
367                    else {
368                            return s = s.substring(0, 1).toLowerCase().concat(s.substring(1));
369                    }
370            }
371    
372            private static String _formatM(String s) {
373                    StringBuilder sb = new StringBuilder(s.length());
374    
375                    for (int i = 0; i < s.length(); i++) {
376                            char c = s.charAt(i);
377    
378                            if (c == '-') {
379                            }
380                            else if ((i > 0) && (s.charAt(i - 1) == '-')) {
381                                    sb.append(Character.toUpperCase(c));
382                            }
383                            else {
384                                    sb.append(c);
385                            }
386                    }
387    
388                    return sb.toString();
389            }
390    
391            private static String _formatN(String s) {
392                    return StringUtil.replace(s, CharPool.DASH, CharPool.UNDERLINE);
393            }
394    
395            private static String _formatO(String s) {
396                    return StringUtil.replace(s, CharPool.UNDERLINE, CharPool.DASH);
397            }
398    
399            private static String _formatP(String s) {
400                    StringBuilder sb = new StringBuilder(s.toLowerCase());
401    
402                    for (int i = 0; i < s.length(); i++) {
403                            char c = s.charAt(i);
404    
405                            if (Character.isUpperCase(c) && (i > 0) && ((i + 1) < s.length())) {
406                                    int delta = sb.length() - s.length();
407    
408                                    if (Character.isLowerCase(s.charAt(i + 1))) {
409                                            sb.insert(i + delta, CharPool.DASH);
410                                    }
411                                    else if (Character.isLowerCase(s.charAt(i - 1))) {
412                                            sb.insert(i + delta, CharPool.DASH);
413                                    }
414                            }
415                    }
416    
417                    return sb.toString();
418            }
419    
420            private static final double _STORAGE_SIZE_DENOMINATOR = 1024.0;
421    
422            private static final String _STORAGE_SIZE_SUFFIX_GB = "GB";
423    
424            private static final String _STORAGE_SIZE_SUFFIX_KB = "k";
425    
426            private static final String _STORAGE_SIZE_SUFFIX_MB = "MB";
427    
428    }