org.crazyyak.dev.common.StringUtils Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2012 Jacob D Parr
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.crazyyak.dev.common;

import java.io.UnsupportedEncodingException;
import java.net.*;
import java.util.*;
import org.crazyyak.dev.common.exceptions.ExceptionUtils;
import org.joda.time.LocalDate;

import static java.lang.String.format;

public class StringUtils {
  
  public static String UTF_8 = "UTF-8";
  public static Map htmlMap = htmlMap();
  
  private StringUtils() {
  }

  public static int countOccurrencesOf(String str, String sub) {
    if (str == null || sub == null || str.length() == 0 || sub.length() == 0) {
      return 0;
    }
    int count = 0;
    int pos = 0;
    int idx;
    while ((idx = str.indexOf(sub, pos)) != -1) {
      ++count;
      pos = idx + sub.length();
    }
    return count;
  }

  /** Helper method to determine if a string is null or zero-length */
  public static boolean isBlank(Object value) {
    return (value == null || value.toString().isEmpty());
  }
  
  /** Helper method to determine if any one of the specified values is null or zero-length */
  public static boolean isNotBlank(Object...values) {
    if (values == null) {
      return false;
    }
    for (Object value : values) {
      boolean blank = (value == null || value.toString().isEmpty());
      if (blank) return false;
    }
    return true;
  }
  
  /** Helper method to help determine if a string is null contains only whitespace. */
  public static boolean isWhitespace(Object value) {
    return (value == null || value.toString().trim().isEmpty());
  }

  public static String escapeHtml(String data) {
    if (data == null) {
      return null;
    }

    // A list of characters that do not need to be escaped.
    List acceptable = new ArrayList();
    for (char c = 'a'; c <= 'z'; c++) acceptable.add(c);
    for (char c = 'A'; c <= 'Z'; c++) acceptable.add(c);
    for (char c = '0'; c <= '9'; c++) acceptable.add(c);
    acceptable.addAll(Arrays.asList('-', '.', ',', '_'));

    StringBuilder builder = new StringBuilder();
    for ( int i = 0; i < data.length(); i++ ) {
      char c = data.charAt( i );
      if (acceptable.contains(c)) {
        builder.append(c);
      } else {
        builder.append("&#");
        builder.append(Integer.valueOf(c));
        builder.append(";");
      }
    }
    return builder.toString();
  }

  public static List tokenize(String data, char delimiter) {
    List retVal = new ArrayList();
    StringTokenizer tokenizer = new StringTokenizer(data, delimiter+"");
    while (tokenizer.hasMoreTokens()) {
      retVal.add(tokenizer.nextToken());
    }
    return retVal;
  }

  public static String concat(String delim, String...segments) {
    ExceptionUtils.assertNotNull(segments, "segments");
    return concat(delim, Arrays.asList(segments));
  }
  
  public static String concat(String delimiter, List segments) {
    ExceptionUtils.assertNotNull(delimiter, "delimiter");
    ExceptionUtils.assertNotNull(segments, "segments");
    
    StringBuilder builder = new StringBuilder();
    for (Object segment : segments) {
      if (builder.length() > 0) {
        builder.append(delimiter);
      }
      builder.append(segment);
    }
    
    return builder.toString();
  }

  public static String decodeUrl(String url) {
    if (url == null) {
      return null;
    }
    try {
      return URLDecoder.decode(url, UTF_8);
    } catch (UnsupportedEncodingException e) {
      throw new RuntimeException(e);
    }
  }

  public static String encodeUrl(String url) {
    if (url == null) {
      return null;
    }
    try {
      return URLEncoder.encode(url, UTF_8);
    } catch (UnsupportedEncodingException e) {
      throw new RuntimeException(e);
    }
  }

  public static LocalDate parseDate(final String date) {
    String test = date;
    if (test == null) return null;
    
    try { return new LocalDate(test);
    } catch (IllegalArgumentException ignored){}
    
    test = test.replace('/', '-');
    try { return new LocalDate(test);
    } catch (IllegalArgumentException ignored){}
   
    String[] parts = test.split("-");
    if (parts.length == 3 && parts[2].length() == 4) {
      String year = parts[2];
      
      String month = parts[0];
      if (month.length() < 2) month = "0"+month;
      
      String day = parts[1];
      if (day.length() < 2) day = "0"+day;
      
      try { return new LocalDate(format("%s-%s-%s", year, month, day));
      } catch (IllegalArgumentException ignored){}
    }
    
    String msg = format("Unable to parse the value \"%s\" into a valid %s.", date, LocalDate.class.getName());
    throw new IllegalArgumentException(msg);
  }

  public static String getNth(int sequence) {
    if (sequence >= 4 && sequence <= 20) {
      return sequence+"th";
    } else {
      String sv = String.valueOf(sequence);
      char last = sv.charAt(sv.length()-1);
      if (last == '1') {
        return sequence+"st";
      } else if (last == '2') {
        return sequence+"nd";
      } else if (last == '3') {
        return sequence+"rd";
      } else {
        return sequence+"th";
      }
    }
  }


  public static String toDelineatedString(String delineator, Object...values) {
    return toDelineatedString(delineator, delineator, Arrays.asList(values));
  }

  public static String toDelineatedString(String delineator, Collection objects) {
    return toDelineatedString(delineator, delineator, objects);
  }

  public static String toDelineatedString(String delineator, String lastDelineator, Object... objectsArray) {
    return toDelineatedString(delineator, lastDelineator, Arrays.asList(objectsArray));
  }

  public static String toDelineatedString(String delineator, String lastDelineator, Collection objectsCollections) {
    List objects = new ArrayList