Coverage Report

##### Coverage Report - org.webmacro.servlet.TextTool

Classes in this File | Line Coverage | Branch Coverage | Complexity
TextTool |
2% | 3/111
0% | 0/78
| 3.3846153846153846;3.385

1 |  |
     /*
2 |  |
      * Copyright (C) 1998-2000 Semiotek Inc.  All Rights Reserved.
3 |  |
      *
4 |  |
      * Redistribution and use in source and binary forms, with or without
5 |  |
      * modification, are permitted under the terms of either of the following
6 |  |
      * Open Source licenses:
7 |  |
      *
8 |  |
      * The GNU General Public License, version 2, or any later version, as
9 |  |
      * published by the Free Software Foundation
10 |  |
      * (http://www.fsf.org/copyleft/gpl.html);
11 |  |
      *
12 |  |
      *  or
13 |  |
      *
14 |  |
      * The Semiotek Public License (http://webmacro.org/LICENSE.)
15 |  |
      *
16 |  |
      * This software is provided "as is", with NO WARRANTY, not even the
17 |  |
      * implied warranties of fitness to purpose, or merchantability. You
18 |  |
      * assume all risks and liabilities associated with its use.
19 |  |
      *
20 |  |
      * See www.webmacro.org for more information on the WebMacro project.
21 |  |
      */
22 |  |
23 |  |
     package org.webmacro.servlet;
24 |  |
25 |  |
     import org.webmacro.Context;
26 |  |
     import org.webmacro.ContextTool;
27 |  |
     import org.webmacro.PropertyException;
28 |  |
     import org.webmacro.WebMacroRuntimeException;
29 |  |
30 |  |
     import java.io.IOException;
31 |  |
     import java.io.InputStream;
32 |  |
     import java.io.UnsupportedEncodingException;
33 |  |
     import java.text.SimpleDateFormat;
34 |  |
     import java.util.ArrayList;
35 |  |
     import java.util.Arrays;
36 |  |
     import java.util.Date;
37 |  |
     import java.util.List;
38 |  |
39 |  |
     /**
40 |  |
      * A ContextTool for String manipulation.
41 |  |
      *
42 |  |
      * @author Eric B. Ridge (mailto:ebr@tcdi.com)
43 |  |
      */
44 |  |
45 |  |
     public class TextTool extends ContextTool
46 |  |
     {
47 |  |
48 |  |
         /** our lonely singleton */
49 | 2 |
         private static final TextTool _instance = new TextTool();
50 |  |
51 |  |
52 |  |
         /**
53 |  |
          * @return the static instance of the TextTool
54 |  |
          */
55 |  |
         public static TextTool getInstance ()
56 |  |
         {
57 | 0 |
             return _instance;
58 |  |
         }
59 |  |
60 |  |
61 |  |
         //
62 |  |
         // static TextTool methods
63 |  |
         //
64 |  |
65 |  |
         /**
66 |  |
          * Split the <code>input</code> String into a String[] at each
67 |  |
          * instance of <code>delimiter</code>.  The delimiter string is <b>not</b>
68 |  |
          * included in the returned array.<p>
69 |  |
          *
70 |  |
          * If either parameter is <code>null</code>, <code>split()</code> returns
71 |  |
          * a String[] of zero elements.
72 |  |
          */
73 |  |
         public static String[] split (String input, String delimiter)
74 |  |
         {
75 | 0 |
             if (input == null || delimiter == null)
76 | 0 |
                 return new String[0];
77 |  |
78 | 0 |
             List l = new ArrayList();
79 | 0 |
             int delimlen = delimiter.length();
80 | 0 |
             int idx, lastidx = 0;
81 |  |
82 | 0 |
             while ((idx = input.indexOf(delimiter, lastidx)) > -1)
83 |  |
             {
84 | 0 |
                 l.add(input.substring(lastidx, idx));
85 | 0 |
                 lastidx = idx + delimlen;
86 |  |
             }
87 | 0 |
             if (lastidx < input.length()) l.add(input.substring(lastidx));
88 |  |
89 | 0 |
             return (String[]) l.toArray(new String[0]);
90 |  |
         }
91 |  |
92 |  |
         /**
93 |  |
          * Join the <code>input</code> String[] into a single String, using
94 |  |
          * the specified <code>delimiter</code> between each value of the array.<p>
95 |  |
          *
96 |  |
          * If either parameter is <code>null</code>, <code>join()</code> returns
97 |  |
          * <code>null</code>.
98 |  |
          */
99 |  |
         public static String join (String[] input, String delimiter)
100 |  |
         {
101 | 0 |
             if (input == null || delimiter == null)
102 | 0 |
                 return null;
103 |  |
104 | 0 |
             StringBuffer sb = new StringBuffer();
105 | 0 |
             for (int x = 0; x < input.length; x++)
106 |  |
             {
107 | 0 |
                 if (x > 0)
108 | 0 |
                     sb.append(delimiter);
109 | 0 |
                 sb.append(input[x]);
110 |  |
             }
111 |  |
112 | 0 |
             return sb.toString();
113 |  |
         }
114 |  |
115 |  |
         /**
116 |  |
          * Replace all occurrences of <code>from</code> to <code>to</code>
117 |  |
          * in <code>src</code>.
118 |  |
          * <P>
119 |  |
          * If any parameter is <code>null</code>, <code>replace()</code> returns
120 |  |
          * the value of <code>src</code>.<p>
121 |  |
          *
122 |  |
          * @return String with all occurrences of <code>from</code> replaced with
123 |  |
          *          <code>to</code> in <code>src</code> or <code>src</code> if
124 |  |
          *          <code>from</code> not found
125 |  |
          */
126 |  |
         public static String replace (String src, String from, String to)
127 |  |
         {
128 | 0 |
             if (src == null || from == null || to == null)
129 | 0 |
                 return src;
130 |  |
131 | 0 |
             int fromlen = from.length();
132 | 0 |
             int idx, lastidx = 0;
133 |  |
134 | 0 |
             StringBuffer newstr = new StringBuffer();
135 |  |
136 | 0 |
             while ((idx = src.indexOf(from, lastidx)) > -1)
137 |  |
             {
138 | 0 |
                 newstr.append(src.substring(lastidx, idx));
139 | 0 |
                 newstr.append(to);
140 | 0 |
                 lastidx = idx + fromlen;
141 |  |
             }
142 | 0 |
             if (lastidx == 0)
143 | 0 |
                 return src;
144 |  |
             else
145 | 0 |
                 newstr.append(src.substring(lastidx));
146 |  |
147 | 0 |
             return newstr.toString();
148 |  |
         }
149 |  |
150 |  |
         /**
151 |  |
          * URLEncode the specified <code>input</code> String.<p>
152 |  |
          *
153 |  |
          * If <code>input</code> is <code>null</code>, <code>URLEncode()</code>
154 |  |
          * will return <code>null</code>.
155 |  |
          *
156 |  |
          * @see java.net.URLEncoder
157 |  |
          */
158 |  |
         public static String URLEncode (String input)
159 |  |
         {
160 | 0 |
             if (input == null)
161 | 0 |
                 return null;
162 |  |
             try {
163 | 0 |
                 return java.net.URLEncoder.encode(input, System.getProperty( "file.encoding" ));
164 | 0 |
             } catch (UnsupportedEncodingException e) {
165 | 0 |
                 throw new WebMacroRuntimeException( "WebMacro bug System.file.encoding not supported", e );
166 |  |
             }
167 |  |
         }
168 |  |
169 |  |
         /**
170 |  |
          * Decode a URLEncoded <code>input</code> String.
171 |  |
          * Assumes that the URL was encoded with URLEncode above.
172 |  |
          *
173 |  |
          * <p>
174 |  |
          *
175 |  |
          * If <code>input</code> is <code>null</code>, <code>URLEncode()</code>
176 |  |
          * will return <code>null</code>.
177 |  |
          *
178 |  |
          * @see java.net.URLDecoder
179 |  |
          */
180 |  |
         public static String URLDecode (String input)
181 |  |
         {
182 | 0 |
             if (input == null)
183 | 0 |
                 return  null;
184 |  |
             try {
185 | 0 |
                 return java.net.URLDecoder.decode(input, System.getProperty( "file.encoding" ));
186 | 0 |
             } catch (UnsupportedEncodingException e) {
187 | 0 |
                 throw new WebMacroRuntimeException( "WebMacro bug System.file.encoding not supported", e );
188 |  |
             }
189 |  |
         }
190 |  |
191 |  |
         /**
192 |  |
          * HTMLEncode will encode the specified <code>input</code> String
193 |  |
          * per the magic of <code>org.webmacro.util.HTMLEscaper</code>.<p>
194 |  |
          *
195 |  |
          * If the <code>input</code> is <code>null</code>, <code>HTMLEncode()</code>
196 |  |
          * will return <b><code>an empty string</code></b>.
197 |  |
          *
198 |  |
          * @see org.webmacro.util.HTMLEscaper
199 |  |
          */
200 |  |
         public static String HTMLEncode (String input)
201 |  |
         {
202 | 0 |
             return input == null ? "" : org.webmacro.util.HTMLEscaper.escape(input);
203 |  |
         }
204 |  |
205 |  |
         /**
206 |  |
          * Format a <code>java.util.Date</code> object using the specified date
207 |  |
          * format string.
208 |  |
          *
209 |  |
          * @see java.util.Date
210 |  |
          * @see java.text.SimpleDateFormat
211 |  |
          */
212 |  |
         public static String formatDate (Date date, String format)
213 |  |
         {
214 | 0 |
             SimpleDateFormat formatter = new SimpleDateFormat(format);
215 | 0 |
             return formatter.format(date);
216 |  |
         }
217 |  |
218 |  |
         /**
219 |  |
          * Write the bytes of the specified InputStream into a String using
220 |  |
          * the default character encoding of your platform.  Upon completion, (or in
221 |  |
          * the event of an Exception) this method will close the input stream.<p>
222 |  |
          *
223 |  |
          * @throws java.io.IOException if the stream cannot be read
224 |  |
          */
225 |  |
         public static String streamToString (InputStream in) throws IOException
226 |  |
         {
227 | 0 |
             return streamToString(in, null);
228 |  |
         }
229 |  |
230 |  |
         /**
231 |  |
          * Write the bytes of the specified InputStream into a String using
232 |  |
          * the specified character encoding.  Upon completion (or in the event of
233 |  |
          * an Exception), this method will close the input stream.<p>
234 |  |
          *
235 |  |
          * @throws java.io.IOException if the stream cannot be read
236 |  |
          */
237 |  |
         public static String streamToString (InputStream in, final String encoding) throws IOException
238 |  |
         {
239 | 0 |
             if (in == null)
240 | 0 |
                 return null;
241 | 0 |
             StringBuffer sb = new StringBuffer();
242 |  |
             try
243 |  |
             {
244 |  |
                 int cnt;
245 | 0 |
                 byte[] buff = new byte[4096];
246 | 0 |
                 while ((cnt = in.read(buff)) > -1)
247 |  |
                 {
248 | 0 |
                     if (encoding != null)
249 | 0 |
                         sb.append(new String(buff, 0, cnt, encoding));
250 |  |
                     else
251 | 0 |
                         sb.append(new String(buff, 0, cnt));
252 |  |
                 }
253 |  |
             }
254 |  |
             finally
255 |  |
             {
256 | 0 |
                 in.close();
257 | 0 |
             }
258 |  |
259 | 0 |
             return sb.toString();
260 |  |
         }
261 |  |
262 |  |
         /**
263 |  |
          * convert a <code>byte[]</code> to a String using the system-default
264 |  |
          * encoding
265 |  |
          */
266 |  |
         public static String bytesToString (byte[] bytes)
267 |  |
         {
268 | 0 |
             return new String(bytes);
269 |  |
         }
270 |  |
271 |  |
         /**
272 |  |
          * convert a <code>byte[]</code> to a String using the specified
273 |  |
          * encoding
274 |  |
          */
275 |  |
         public static String bytesToString (byte[] bytes, String encoding) throws UnsupportedEncodingException
276 |  |
         {
277 | 0 |
             return new String(bytes, encoding);
278 |  |
         }
279 |  |
280 |  |
281 |  |
         /** remove any leading and trailing whitespace from a string */
282 |  |
         public static String trim (String s)
283 |  |
         {
284 | 0 |
             return s.trim();
285 |  |
         }
286 |  |
287 |  |
         /** remove any leading whitespace from a string */
288 |  |
         public static String ltrim (String s)
289 |  |
         {
290 | 0 |
             if (s == null) return null;
291 | 0 |
             for (int i = 0; i < s.length(); i++)
292 |  |
             {
293 | 0 |
                 if (!Character.isWhitespace(s.charAt(i))) return s.substring(i);
294 |  |
             }
295 |  |
             // if all WS return empty string
296 | 0 |
             return "";
297 |  |
         }
298 |  |
299 |  |
         /** remove the trailing whitespace from a string */
300 |  |
         public static String rtrim (String s)
301 |  |
         {
302 | 0 |
             if (s == null) return null;
303 | 0 |
             for (int i = s.length() - 1; i > -1; i--)
304 |  |
             {
305 | 0 |
                 if (!Character.isWhitespace(s.charAt(i))) return s.substring(0, i + 1);
306 |  |
             }
307 |  |
             // if all WS return empty string
308 | 0 |
             return "";
309 |  |
         }
310 |  |
311 |  |
         /** converts a block of text into an array of strings
312 |  |
          * by tokenizing using \r\n as the delimiter
313 |  |
          * If no \r\n, it will look for \n or \r and use them instead.
314 |  |
          */
315 |  |
         public static String[] getLines (String block)
316 |  |
         {
317 | 0 |
             if (block == null) return null;
318 | 0 |
             String delim = "\r\n";
319 | 0 |
             if (block.indexOf("\r\n") == -1)
320 |  |
             {
321 | 0 |
                 if (block.indexOf('\n') > -1)
322 | 0 |
                     delim = "\n";
323 |  |
                 else
324 | 0 |
                     delim = "\r";
325 |  |
             }
326 | 0 |
             return TextTool.split(block, delim);
327 |  |
         }
328 |  |
329 |  |
         /** convert an array of strings into a block of text delimited by \r\n */
330 |  |
         public static String makeBlock (String[] lines)
331 |  |
         {
332 | 0 |
             if (lines == null || lines.length == 0) return null;
333 | 0 |
             if (lines.length == 1) return lines[0];
334 | 0 |
             StringBuffer sb = new StringBuffer(lines[0]);
335 | 0 |
             for (int i = 1; i < lines.length; i++)
336 |  |
             {
337 | 0 |
                 sb.append('\r').append('\n').append(lines[i]);
338 |  |
             }
339 | 0 |
             return sb.toString();
340 |  |
         }
341 |  |
342 |  |
343 |  |
         /** remove the leading and trailing whitespace from each line in a block of text */
344 |  |
         public static String trimBlock (String block)
345 |  |
         {
346 | 0 |
             if (block == null) return null;
347 | 0 |
             String[] lines = getLines(block);
348 | 0 |
             for (int i = 0; i < lines.length; i++) lines[i] = trim(lines[i]);
349 | 0 |
             return makeBlock(lines);
350 |  |
         }
351 |  |
352 |  |
         /** remove the leading whitespace from each line in a block of text */
353 |  |
         public static String ltrimBlock (String block)
354 |  |
         {
355 | 0 |
             if (block == null) return null;
356 | 0 |
             String[] lines = getLines(block);
357 | 0 |
             for (int i = 0; i < lines.length; i++) lines[i] = ltrim(lines[i]);
358 | 0 |
             return makeBlock(lines);
359 |  |
         }
360 |  |
361 |  |
         /** remove the trailing whitespace from each line in a block of text */
362 |  |
         public static String rtrimBlock (String block)
363 |  |
         {
364 | 0 |
             if (block == null) return null;
365 | 0 |
             String[] lines = getLines(block);
366 | 0 |
             for (int i = 0; i < lines.length; i++) lines[i] = rtrim(lines[i]);
367 | 0 |
             return makeBlock(lines);
368 |  |
         }
369 |  |
370 |  |
         /** Returns a new  string which is in upper case. */
371 |  |
         public static String toUpperCase (String s)
372 |  |
         {
373 | 0 |
             return s.toUpperCase();
374 |  |
         }
375 |  |
376 |  |
         /** Returns a new  string which is in lower case. */
377 |  |
         public static String toLowerCase (String s)
378 |  |
         {
379 | 0 |
             return s.toLowerCase();
380 |  |
         }
381 |  |
382 |  |
383 |  |
384 |  |
         //
385 |  |
         // ContextTool implementation methods
386 |  |
         //
387 |  |
388 |  |
         /** default contsructor.  Does nothing */
389 |  |
         public TextTool ()
390 | 8 |
         {
391 | 8 |
         }
392 |  |
393 |  |
         /**
394 |  |
          * public constructor.  Does nothing.  The TextTool doesn't
395 |  |
          * interact with the Context, so it is ignored
396 |  |
          */
397 |  |
         public TextTool (Context context)
398 | 0 |
         {
399 | 0 |
         }
400 |  |
401 |  |
         /**
402 |  |
          * Tool initialization method.  The TextTool doesn't
403 |  |
          * interact with the context, so the <code>context</code>
404 |  |
          * parameter is ignored.
405 |  |
          */
406 |  |
         public Object init (Context context) throws PropertyException
407 |  |
         {
408 | 0 |
             return TextTool.getInstance();
409 |  |
         }
410 |  |
411 |  |
412 |  |
         //
413 |  |
         //
414 |  |
415 |  |
         public static void main (String[] args) throws Exception
416 |  |
         {
417 | 0 |
             String input1 = "This is a test";
418 | 0 |
             String input2 = "This is a test";
419 | 0 |
             String[] split = TextTool.split(input2, " ");
420 |  |
421 | 0 |
             System.err.println(TextTool.replace(input1, "is", "isn't"));
422 |  |
423 | 0 |
             for (int x = 0; x < split.length; x++)
424 | 0 |
                 System.err.println("/" + split[x] + "/");
425 |  |
426 | 0 |
             String s1 = "alpha\r\nbeta\r\ndelta\r\ngamma";
427 | 0 |
             String[] split2 = TextTool.split(s1, "\r\n");
428 | 0 |
             System.err.println("split2=" + Arrays.asList(split2));
429 | 0 |
         }
430 |  |
     }