org.modeshape.common.text
Class Inflector

java.lang.Object
  extended by org.modeshape.common.text.Inflector

@ThreadSafe
public class Inflector
extends Object

Transforms words to singular, plural, humanized (human readable), underscore, camel case, or ordinal form. This is inspired by the Inflector class in Ruby on Rails, which is distributed under the Rails license.


Constructor Summary
Inflector()
           
 
Method Summary
 void addIrregular(String singular, String plural)
           
 void addPluralize(String rule, String replacement)
           
 void addSingularize(String rule, String replacement)
           
 void addUncountable(String... words)
           
 String camelCase(String lowerCaseAndUnderscoredWord, boolean uppercaseFirstLetter, char... delimiterChars)
          By default, this method converts strings to UpperCamelCase.
 String capitalize(String words)
          Returns a copy of the input with the first character converted to uppercase and the remainder to lowercase.
 void clear()
          Completely remove all rules within this inflector.
 Inflector clone()
           
static Inflector getInstance()
           
 Set<String> getUncountables()
          Get the set of words that are not processed by the Inflector.
 String humanize(String lowerCaseAndUnderscoredWords, String... removableTokens)
          Capitalizes the first word and turns underscores into spaces and strips trailing "_id" and any supplied removable tokens.
 boolean isUncountable(String word)
          Determine whether the supplied word is considered uncountable by the pluralize and singularize methods.
 String lowerCamelCase(String lowerCaseAndUnderscoredWord, char... delimiterChars)
          Converts strings to lowerCamelCase.
 String ordinalize(int number)
          Turns a non-negative number into an ordinal string used to denote the position in an ordered sequence, such as 1st, 2nd, 3rd, 4th.
 String pluralize(Object word)
          Returns the plural form of the word in the string.
 String pluralize(Object word, int count)
           
 String singularize(Object word)
          Returns the singular form of the word in the string.
 String titleCase(String words, String... removableTokens)
          Capitalizes all the words and replaces some characters in the string to create a nicer looking title.
 String underscore(String camelCaseWord, char... delimiterChars)
          Makes an underscored form from the expression in the string (the reverse of the camelCase method.
 String upperCamelCase(String lowerCaseAndUnderscoredWord, char... delimiterChars)
          Converts strings to UpperCamelCase.
 
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

Inflector

public Inflector()
Method Detail

getInstance

public static final Inflector getInstance()

clone

public Inflector clone()
Overrides:
clone in class Object

pluralize

public String pluralize(Object word)
Returns the plural form of the word in the string.

Examples:

   inflector.pluralize("post")               #=> "posts"
   inflector.pluralize("octopus")            #=> "octopi"
   inflector.pluralize("sheep")              #=> "sheep"
   inflector.pluralize("words")              #=> "words"
   inflector.pluralize("the blue mailman")   #=> "the blue mailmen"
   inflector.pluralize("CamelOctopus")       #=> "CamelOctopi"
 

Note that if the Object.toString() is called on the supplied object, so this method works for non-strings, too.

Parameters:
word - the word that is to be pluralized.
Returns:
the pluralized form of the word, or the word itself if it could not be pluralized
See Also:
singularize(Object)

pluralize

public String pluralize(Object word,
                        int count)

singularize

public String singularize(Object word)
Returns the singular form of the word in the string.

Examples:

   inflector.singularize("posts")             #=> "post"
   inflector.singularize("octopi")            #=> "octopus"
   inflector.singularize("sheep")             #=> "sheep"
   inflector.singularize("words")             #=> "word"
   inflector.singularize("the blue mailmen")  #=> "the blue mailman"
   inflector.singularize("CamelOctopi")       #=> "CamelOctopus"
 

Note that if the Object.toString() is called on the supplied object, so this method works for non-strings, too.

Parameters:
word - the word that is to be pluralized.
Returns:
the pluralized form of the word, or the word itself if it could not be pluralized
See Also:
pluralize(Object)

lowerCamelCase

public String lowerCamelCase(String lowerCaseAndUnderscoredWord,
                             char... delimiterChars)
Converts strings to lowerCamelCase. This method will also use any extra delimiter characters to identify word boundaries.

Examples:

   inflector.lowerCamelCase("active_record")       #=> "activeRecord"
   inflector.lowerCamelCase("first_name")          #=> "firstName"
   inflector.lowerCamelCase("name")                #=> "name"
   inflector.lowerCamelCase("the-first_name",'-')  #=> "theFirstName"
 

Parameters:
lowerCaseAndUnderscoredWord - the word that is to be converted to camel case
delimiterChars - optional characters that are used to delimit word boundaries
Returns:
the lower camel case version of the word
See Also:
underscore(String, char[]), camelCase(String, boolean, char[]), upperCamelCase(String, char[])

upperCamelCase

public String upperCamelCase(String lowerCaseAndUnderscoredWord,
                             char... delimiterChars)
Converts strings to UpperCamelCase. This method will also use any extra delimiter characters to identify word boundaries.

Examples:

   inflector.upperCamelCase("active_record")       #=> "SctiveRecord"
   inflector.upperCamelCase("first_name")          #=> "FirstName"
   inflector.upperCamelCase("name")                #=> "Name"
   inflector.lowerCamelCase("the-first_name",'-')  #=> "TheFirstName"
 

Parameters:
lowerCaseAndUnderscoredWord - the word that is to be converted to camel case
delimiterChars - optional characters that are used to delimit word boundaries
Returns:
the upper camel case version of the word
See Also:
underscore(String, char[]), camelCase(String, boolean, char[]), lowerCamelCase(String, char[])

camelCase

public String camelCase(String lowerCaseAndUnderscoredWord,
                        boolean uppercaseFirstLetter,
                        char... delimiterChars)
By default, this method converts strings to UpperCamelCase. If the uppercaseFirstLetter argument to false, then this method produces lowerCamelCase. This method will also use any extra delimiter characters to identify word boundaries.

Examples:

   inflector.camelCase("active_record",false)    #=> "activeRecord"
   inflector.camelCase("active_record",true)     #=> "ActiveRecord"
   inflector.camelCase("first_name",false)       #=> "firstName"
   inflector.camelCase("first_name",true)        #=> "FirstName"
   inflector.camelCase("name",false)             #=> "name"
   inflector.camelCase("name",true)              #=> "Name"
 

Parameters:
lowerCaseAndUnderscoredWord - the word that is to be converted to camel case
uppercaseFirstLetter - true if the first character is to be uppercased, or false if the first character is to be lowercased
delimiterChars - optional characters that are used to delimit word boundaries
Returns:
the camel case version of the word
See Also:
underscore(String, char[]), upperCamelCase(String, char[]), lowerCamelCase(String, char[])

underscore

public String underscore(String camelCaseWord,
                         char... delimiterChars)
Makes an underscored form from the expression in the string (the reverse of the camelCase method. Also changes any characters that match the supplied delimiters into underscore.

Examples:

   inflector.underscore("activeRecord")     #=> "active_record"
   inflector.underscore("ActiveRecord")     #=> "active_record"
   inflector.underscore("firstName")        #=> "first_name"
   inflector.underscore("FirstName")        #=> "first_name"
   inflector.underscore("name")             #=> "name"
   inflector.underscore("The.firstName")    #=> "the_first_name"
 

Parameters:
camelCaseWord - the camel-cased word that is to be converted;
delimiterChars - optional characters that are used to delimit word boundaries (beyond capitalization)
Returns:
a lower-cased version of the input, with separate words delimited by the underscore character.

capitalize

public String capitalize(String words)
Returns a copy of the input with the first character converted to uppercase and the remainder to lowercase.

Parameters:
words - the word to be capitalized
Returns:
the string with the first character capitalized and the remaining characters lowercased

humanize

public String humanize(String lowerCaseAndUnderscoredWords,
                       String... removableTokens)
Capitalizes the first word and turns underscores into spaces and strips trailing "_id" and any supplied removable tokens. Like titleCase(String, String[]), this is meant for creating pretty output.

Examples:

   inflector.humanize("employee_salary")       #=> "Employee salary"
   inflector.humanize("author_id")             #=> "Author"
 

Parameters:
lowerCaseAndUnderscoredWords - the input to be humanized
removableTokens - optional array of tokens that are to be removed
Returns:
the humanized string
See Also:
titleCase(String, String[])

titleCase

public String titleCase(String words,
                        String... removableTokens)
Capitalizes all the words and replaces some characters in the string to create a nicer looking title. Underscores are changed to spaces, a trailing "_id" is removed, and any of the supplied tokens are removed. Like humanize(String, String[]), this is meant for creating pretty output.

Examples:

   inflector.titleCase("man from the boondocks")       #=> "Man From The Boondocks"
   inflector.titleCase("x-men: the last stand")        #=> "X Men: The Last Stand"
 

Parameters:
words - the input to be turned into title case
removableTokens - optional array of tokens that are to be removed
Returns:
the title-case version of the supplied words

ordinalize

public String ordinalize(int number)
Turns a non-negative number into an ordinal string used to denote the position in an ordered sequence, such as 1st, 2nd, 3rd, 4th.

Parameters:
number - the non-negative number
Returns:
the string with the number and ordinal suffix

isUncountable

public boolean isUncountable(String word)
Determine whether the supplied word is considered uncountable by the pluralize and singularize methods.

Parameters:
word - the word
Returns:
true if the plural and singular forms of the word are the same

getUncountables

public Set<String> getUncountables()
Get the set of words that are not processed by the Inflector. The resulting map is directly modifiable.

Returns:
the set of uncountable words

addPluralize

public void addPluralize(String rule,
                         String replacement)

addSingularize

public void addSingularize(String rule,
                           String replacement)

addIrregular

public void addIrregular(String singular,
                         String plural)

addUncountable

public void addUncountable(String... words)

clear

public void clear()
Completely remove all rules within this inflector.



Copyright © 2008-2010 JBoss, a division of Red Hat. All Rights Reserved.