001    /**
002     * Copyright (c) 2000-2012 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 {@link #formatStorageSize(double, Locale)}
152             */
153            public static String formatKB(double size, Locale locale) {
154                    NumberFormat numberFormat = NumberFormat.getInstance(locale);
155    
156                    numberFormat.setMaximumFractionDigits(1);
157                    numberFormat.setMinimumFractionDigits(1);
158    
159                    return numberFormat.format(size / _STORAGE_SIZE_DENOMINATOR);
160            }
161    
162            /**
163             * @deprecated {@link #formatStorageSize(int, Locale)}
164             */
165            public static String formatKB(int size, Locale locale) {
166                    return formatKB((double)size, locale);
167            }
168    
169            public static String formatName(String name) {
170                    if (Validator.isNull(name)) {
171                            return name;
172                    }
173    
174                    char[] chars = name.toLowerCase().trim().toCharArray();
175    
176                    if (chars.length > 0) {
177                            chars[0] = Character.toUpperCase(chars[0]);
178                    }
179    
180                    for (int i = 0; i < chars.length; i++) {
181                            if (chars[i] == ' ') {
182                                    chars[i + 1] = Character.toUpperCase(chars[i + 1]);
183                            }
184                    }
185    
186                    return new String(chars);
187            }
188    
189            public static String formatPlural(String s) {
190                    if (Validator.isNull(s)) {
191                            return s;
192                    }
193    
194                    if (s.endsWith("s")) {
195                            s = s.substring(0, s.length() -1) + "ses";
196                    }
197                    else if (s.endsWith("y")) {
198                            s = s.substring(0, s.length() -1) + "ies";
199                    }
200                    else {
201                            s = s + "s";
202                    }
203    
204                    return s;
205            }
206    
207            public static String formatStorageSize(double size, Locale locale) {
208                    String suffix = _STORAGE_SIZE_SUFFIX_KB;
209    
210                    size = size / _STORAGE_SIZE_DENOMINATOR;
211    
212                    if (size > _STORAGE_SIZE_DENOMINATOR) {
213                            suffix = _STORAGE_SIZE_SUFFIX_MB;
214    
215                            size = size / _STORAGE_SIZE_DENOMINATOR;
216                    }
217    
218                    if (size > _STORAGE_SIZE_DENOMINATOR) {
219                            suffix = _STORAGE_SIZE_SUFFIX_GB;
220    
221                            size = size / _STORAGE_SIZE_DENOMINATOR;
222                    }
223    
224                    NumberFormat numberFormat = NumberFormat.getInstance(locale);
225    
226                    if (suffix.equals(_STORAGE_SIZE_SUFFIX_KB)) {
227                            numberFormat.setMaximumFractionDigits(0);
228                    }
229                    else {
230                            numberFormat.setMaximumFractionDigits(1);
231                    }
232    
233                    numberFormat.setMinimumFractionDigits(0);
234    
235                    return numberFormat.format(size) + suffix;
236            }
237    
238            public static String formatStorageSize(int size, Locale locale) {
239                    return formatStorageSize((double)size, locale);
240            }
241    
242            private static String _formatA(String s) {
243                    return StringUtil.replace(
244                            s.toUpperCase(), CharPool.SPACE, CharPool.UNDERLINE);
245            }
246    
247            private static String _formatB(String s) {
248                    return StringUtil.strip(s.toLowerCase(), CharPool.SPACE);
249            }
250    
251            private static String _formatC(String s) {
252                    return StringUtil.replace(
253                            s.toLowerCase(), CharPool.SPACE, CharPool.UNDERLINE);
254            }
255    
256            private static String _formatD(String s) {
257                    return StringUtil.strip(s, CharPool.SPACE);
258            }
259    
260            private static String _formatE(String s) {
261                    return s.toLowerCase();
262            }
263    
264            private static String _formatF(String s) {
265                    s = StringUtil.strip(s, CharPool.SPACE);
266    
267                    if (Character.isUpperCase(s.charAt(0))) {
268                            s = s.substring(0, 1).toLowerCase().concat(s.substring(1));
269                    }
270    
271                    return s;
272            }
273    
274            private static String _formatG(String s) {
275                    if (Character.isLowerCase(s.charAt(0))) {
276                            s = s.substring(0, 1).toUpperCase().concat(s.substring(1));
277                    }
278    
279                    return s;
280            }
281    
282            private static String _formatH(String s) {
283                    StringBuilder sb = new StringBuilder(s.length() * 2);
284    
285                    for (int i = 0; i < s.length(); i++) {
286                            char c = s.charAt(i);
287    
288                            if (Character.isUpperCase(c)) {
289                                    sb.append(CharPool.SPACE);
290                                    sb.append(Character.toLowerCase(c));
291                            }
292                            else {
293                                    sb.append(c);
294                            }
295                    }
296    
297                    return sb.toString().trim();
298            }
299    
300            private static String _formatI(String s) {
301                    if (s.length() == 1) {
302                            return s.toLowerCase();
303                    }
304    
305                    if (Character.isLowerCase(s.charAt(0))) {
306                            return s;
307                    }
308    
309                    if (Character.isUpperCase(s.charAt(0)) &&
310                            Character.isLowerCase(s.charAt(1))) {
311    
312                            return s = s.substring(0, 1).toLowerCase().concat(s.substring(1));
313                    }
314    
315                    StringBuilder sb = new StringBuilder(s);
316    
317                    for (int i = 0; i < s.length(); i++) {
318                            if (((i + 1) != s.length()) &&
319                                    (Character.isLowerCase(s.charAt(i + 1)))) {
320    
321                                    break;
322                            }
323                            else {
324                                    char c = Character.toLowerCase(s.charAt(i));
325    
326                                    sb.setCharAt(i, c);
327                            }
328                    }
329    
330                    return sb.toString();
331            }
332    
333            private static String _formatJ(String s) {
334                    s = StringUtil.replace(s, CharPool.DASH, CharPool.SPACE);
335                    s = StringUtil.replace(s, CharPool.UNDERLINE, CharPool.SPACE);
336    
337                    StringBuilder sb = new StringBuilder(s.toLowerCase());
338    
339                    for (int i = 0; i < s.length(); i++) {
340                            if ((i == 0) || (s.charAt(i - 1) == ' ')) {
341                                    sb.setCharAt(i, Character.toUpperCase(s.charAt(i)));
342                            }
343                    }
344    
345                    return sb.toString();
346            }
347    
348            private static String _formatK(String s) {
349                    s = _formatH(s);
350                    s = StringUtil.replace(s, CharPool.SPACE, CharPool.DASH);
351    
352                    return s;
353            }
354    
355            private static String _formatL(String s) {
356                    if (s.length() == 1) {
357                            return s.toLowerCase();
358                    }
359                    else if (Character.isLowerCase(s.charAt(0)) ||
360                                     (Character.isUpperCase(s.charAt(0)) &&
361                                      Character.isUpperCase(s.charAt(1)))) {
362    
363                            return s;
364                    }
365                    else {
366                            return s = s.substring(0, 1).toLowerCase().concat(s.substring(1));
367                    }
368            }
369    
370            private static String _formatM(String s) {
371                    StringBuilder sb = new StringBuilder(s.length());
372    
373                    for (int i = 0; i < s.length(); i++) {
374                            char c = s.charAt(i);
375    
376                            if (c == '-') {
377                            }
378                            else if ((i > 0) && (s.charAt(i - 1) == '-')) {
379                                    sb.append(Character.toUpperCase(c));
380                            }
381                            else {
382                                    sb.append(c);
383                            }
384                    }
385    
386                    return sb.toString();
387            }
388    
389            private static String _formatN(String s) {
390                    return StringUtil.replace(s, CharPool.DASH, CharPool.UNDERLINE);
391            }
392    
393            private static String _formatO(String s) {
394                    return StringUtil.replace(s, CharPool.UNDERLINE, CharPool.DASH);
395            }
396    
397            private static String _formatP(String s) {
398                    StringBuilder sb = new StringBuilder(s.toLowerCase());
399    
400                    for (int i = 0; i < s.length(); i++) {
401                            char c = s.charAt(i);
402    
403                            if (Character.isUpperCase(c) && (i > 0) && ((i + 1) < s.length())) {
404                                    int delta = sb.length() - s.length();
405    
406                                    if (Character.isLowerCase(s.charAt(i + 1))) {
407                                            sb.insert(i + delta, CharPool.DASH);
408                                    }
409                                    else if (Character.isLowerCase(s.charAt(i - 1))) {
410                                            sb.insert(i + delta, CharPool.DASH);
411                                    }
412                            }
413                    }
414    
415                    return sb.toString();
416            }
417    
418            private static final double _STORAGE_SIZE_DENOMINATOR = 1024.0;
419    
420            private static final String _STORAGE_SIZE_SUFFIX_GB = "GB";
421    
422            private static final String _STORAGE_SIZE_SUFFIX_KB = "k";
423    
424            private static final String _STORAGE_SIZE_SUFFIX_MB = "MB";
425    
426    }