com.greenpepper.util.NameUtils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of greenpepper-core Show documentation
There is a newer version: 4.2.4
/*
 * Copyright (c) 2006 Pyxis Technologies inc.
 *
 * This is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA,
 * or see the FSF site: http://www.fsf.org.
 */
package com.greenpepper.util;

import java.beans.Introspector;

import static com.greenpepper.util.StringUtil.isBlank;
import static com.greenpepper.util.StringUtil.removeDiacritics;

/**
 * NameUtils class.
 *
 * @author oaouattara
 * @version $Id: $Id
 */
public final class NameUtils
{
    /**
     * No instance of this class is allowed.
     */
    private NameUtils()
    {
    }

    /**
     * Tries to convert string to a Java class name by following
     * a few simple steps:
     * 
     * 

     * 

     * First of all, string gets camel cased, the
     * usual Java class naming convention.
     * 
Secondly, any whitespace, by virtue of
     * Character.isWhitespace() is removed from the camel cased
     * string.
     * 
Third, all accented characters (diacritis) are replaced by their
     * non-accented equivalent (ex: \u00e9 -> e)
     * Fourth, all non java identifier characters are removed
     * 
     * 
     * The only exception to executing these two steps is when
     * string represents a fully-qualified class name. To check
     * if string represents a fully-qualified class name, a
     * simple validation of the existence of the '.' character is made on
     * string.
     *
     * @param s The String that may represent a Java class name
     * @return The input string converted by following the documented steps
     */
    public static String toClassName( String s )
    {
        if (StringUtil.isEmpty( s ) || s.contains( "." )) return s;
        return removeNonJavaIdentifierCharacters( removeDiacritics( toUpperCamelCase( s ) ) );
    }

    /**
     * 
toUpperCamelCase.
     *
     * @param s a {@link java.lang.String} object.
     * @return a {@link java.lang.String} object.
     */
    public static String toUpperCamelCase( String s )
    {
        return capitalizeFirst( toLowerCamelCase( s ) );
    }

    /**
     * toLowerCamelCase.
     *
     * @param s a {@link java.lang.String} object.
     * @return a {@link java.lang.String} object.
     */
    public static String toLowerCamelCase( String s )
    {
        if (StringUtil.isBlank( s )) return s.trim();

        StringBuilder sb = new StringBuilder();
        String[] parts = s.trim().split( "\\s+" );

        sb.append( parts[0].toLowerCase() );
        for (int i = 1; i < parts.length; ++i)
        {
            sb.append( capitalize( parts[i] ) );
        }

        return sb.toString();
    }

    /**
     * humanize.
     *
     * @param s a {@link java.lang.String} object.
     * @return a {@link java.lang.String} object.
     */
    public static String humanize( String s )
    {

        StringBuilder literal = new StringBuilder();
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++)
        {
            char c = chars[i];
            if (Character.isUpperCase( c ) && i > 0)
            {
                literal.append( " " );
                literal.append( Character.toLowerCase( c ) );
            }
            else
            {
                literal.append( c );
            }
        }
        return literal.toString();
    }

    /**
     * decapitalize.
     *
     * @param s a {@link java.lang.String} object.
     * @return a {@link java.lang.String} object.
     */
    public static String decapitalize( String s )
    {
        StringBuilder sb = new StringBuilder();
        String[] parts = s.trim().split( "\\s+" );

        sb.append( Introspector.decapitalize( parts[0] ) );
        for (int i = 1; i < parts.length; ++i)
        {
            sb.append( capitalizeFirst( Introspector.decapitalize( parts[i] ) ) );
        }
        return sb.toString();
    }

    /**
     * capitalizeFirst.
     *
     * @param s a {@link java.lang.String} object.
     * @return a {@link java.lang.String} object.
     */
    public static String capitalizeFirst( String s )
    {
        if (StringUtil.isEmpty( s )) return s;

        StringBuilder sb = new StringBuilder();
        sb.append( s.substring( 0, 1 ).toUpperCase() );
        sb.append( s.substring( 1 ) );
        return sb.toString();
    }

    /**
     * capitalize.
     *
     * @param s a {@link java.lang.String} object.
     * @return a {@link java.lang.String} object.
     */
    public static String capitalize( String s )
    {
        return capitalizeFirst( s.toLowerCase() );
    }

    /**
     * isJavaIdentifier.
     *
     * @param s a {@link java.lang.String} object.
     * @return a boolean.
     */
    public static boolean isJavaIdentifier( String s )
    {
        if (!Character.isJavaIdentifierStart( s.codePointAt( 0 ) )) return false;

        for (int i = 1; i < s.length(); i++)
        {
            if (!Character.isJavaIdentifierPart( s.codePointAt( i ) )) return false;
        }
        return true;
    }

    /**
     * toJavaIdentifierForm.
     *
     * @param name a {@link java.lang.String} object.
     * @return a {@link java.lang.String} object.
     */
    public static String toJavaIdentifierForm( String name )
    {
        if (isBlank(name)) {
            throw new IllegalArgumentException("The specification mapping can't be null or empty");
        }
        return removeNonJavaIdentifierCharacters( removeDiacritics( toLowerCamelCase( name ) ) );
    }
    
    /**
     * removeNonJavaIdentifierCharacters.
     *
     * @param name a {@link java.lang.String} object.
     * @return a {@link java.lang.String} object.
     */
    public static String removeNonJavaIdentifierCharacters( String name )
    {
        StringBuilder javaIdentifier = new StringBuilder();
        
        for (int index = 0; index < name.length(); index++)
        {
        	if (Character.isJavaIdentifierPart(name.codePointAt( index ))) {
        		javaIdentifier.append(name.charAt(index));
        	}
        }

        return javaIdentifier.toString();
    }
}