Coverage Report

 /**
  * Distribution License:
  * JSword is free software; you can redistribute it and/or modify it under
  * the terms of the GNU Lesser General Public License, version 2.1 or later
  * as published by the Free Software Foundation. This program 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 Lesser General Public License for more details.
  *
  * The License is available on the internet at:
  *      http://www.gnu.org/copyleft/lgpl.html
  * or by writing to:
  *      Free Software Foundation, Inc.
  *      59 Temple Place - Suite 330
  *      Boston, MA 02111-1307, USA
  *
  * © CrossWire Bible Society, 2005 - 2016
  *
  */
 package org.crosswire.jsword.book;
 
 import org.crosswire.jsword.internationalisation.LocaleProviderManager;
 
 /**
  * Types of Sentence Case.
  * 
  * @see gnu.lgpl.License The GNU Lesser General Public License for details.
  * @author Joe Walker
  * @author DM Smith
  */
 public enum CaseType {
     LOWER  {
         @Override
         public String setCase(String word) {
             return word.toLowerCase(LocaleProviderManager.getLocale());
         }
     },
 
     SENTENCE {
         @Override
         public String setCase(String word) {
             int index = word.indexOf('-');
             if (index == -1) {
                 return toSentenceCase(word);
             }
 
             // So there is a "-", however first some exceptions
             if ("maher-shalal-hash-baz".equalsIgnoreCase(word)) {
                 return "Maher-Shalal-Hash-Baz";
             }
 
             if ("no-one".equalsIgnoreCase(word)) {
                 return "No-one";
             }
 
             if ("god-".equalsIgnoreCase(word.substring(0, 4))) {
                 return toSentenceCase(word);
             }
 
             // So cut by the -
             return toSentenceCase(word.substring(0, index)) + "-" + toSentenceCase(word.substring(index + 1));
         }
     },
 
     UPPER {
         @Override
         public String setCase(String word) {
             return word.toUpperCase(LocaleProviderManager.getLocale());
         }
     };
 
     /**
      * Adjust the case of the string as defined by the type.
      * 
      * @param word the string to transform
      * @return the transformed string
      */
     public abstract String setCase(String word);
 
     /**
      * Change to sentence case - that is first character in caps, the rest in lower.
      * 
      * @param word
      *            The word to be manipulated
      * @return The altered word
      */
     public static String toSentenceCase(String word) {
         assert word != null;
 
         if (word.length() == 0) {
             return "";
         }
 
         return Character.toUpperCase(word.charAt(0)) + word.substring(1).toLowerCase(LocaleProviderManager.getLocale());
     }
 
     /**
      * What case is the specified word?. A blank word is LOWER, a word with a
      * single upper case letter is SENTENCE and not UPPER - Simply because this
      * is more likely, however TO BE SURE I WOULD NEED TO THE CONTEXT. I could
      * not tell otherwise.
      * <p>
      * The issue here is that getCase("FreD") is undefined. Telling if this is
      * SENTENCE (Tubal-Cain) or MIXED (really the case) is complex and would
      * slow things down for a case that I don't believe happens with Bible text.
      * </p>
      * 
      * @param word
      *            The word to be tested
      * @return LOWER, SENTENCE, UPPER or MIXED
      * @exception IllegalArgumentException
      *                is the word is null
      */
     public static CaseType getCase(String word) {
         assert word != null;
 
         // Blank word
         if (word.length() == 0) {
             return LOWER;
         }
 
         // Lower case?
         if (word.equals(word.toLowerCase(LocaleProviderManager.getLocale()))) {
             return LOWER;
         }
 
         // Upper case?
         // A string length of 1 is no good ('I' or 'A' is sentence case)
         if (word.equals(word.toUpperCase(LocaleProviderManager.getLocale())) && word.length() != 1) {
             return UPPER;
         }
 
         // So ...
         return SENTENCE;
     }
 
     /**
      * Get an integer representation for this CaseType
      * 
      * @return the ordinal value of this CaseType
      */
     public int toInteger() {
         return ordinal();
     }
 
     /**
      * Lookup method to convert from a String
      * 
      * @param name the name of the CaseType
      * @return the CaseType that matches
      */
     public static CaseType fromString(String name) {
         for (CaseType v : values()) {
             if (v.name().equalsIgnoreCase(name)) {
                 return v;
             }
         }
 
         // cannot get here
         assert false;
         return null;
     }
 
     /**
      * Lookup method to convert from an integer
      * 
      * @param i the ordinal value of the CaseType
      * @return the matching CaseType
      */
     public static CaseType fromInteger(int i) {
         for (CaseType v : values()) {
             if (v.ordinal() == i) {
                 return v;
             }
         }
 
         // cannot get here
         assert false;
         return null;
     }
 
 }

1		/**
2		* Distribution License:
3		* JSword is free software; you can redistribute it and/or modify it under
4		* the terms of the GNU Lesser General Public License, version 2.1 or later
5		* as published by the Free Software Foundation. This program is distributed
6		* in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
7		* the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
8		* See the GNU Lesser General Public License for more details.
9		*
10		* The License is available on the internet at:
11		* http://www.gnu.org/copyleft/lgpl.html
12		* or by writing to:
13		* Free Software Foundation, Inc.
14		* 59 Temple Place - Suite 330
15		* Boston, MA 02111-1307, USA
16		*
17		* © CrossWire Bible Society, 2005 - 2016
18		*
19		*/
20		package org.crosswire.jsword.book;
21
22		import org.crosswire.jsword.internationalisation.LocaleProviderManager;
23
24		/**
25		* Types of Sentence Case.
26		*
27		* @see gnu.lgpl.License The GNU Lesser General Public License for details.
28		* @author Joe Walker
29		* @author DM Smith
30		*/
31	0	public enum CaseType {
32	0	LOWER {
33		@Override
34		public String setCase(String word) {
35	0	return word.toLowerCase(LocaleProviderManager.getLocale());
36		}
37		},
38
39	0	SENTENCE {
40		@Override
41		public String setCase(String word) {
42	0	int index = word.indexOf('-');
43	0	if (index == -1) {
44	0	return toSentenceCase(word);
45		}
46
47		// So there is a "-", however first some exceptions
48	0	if ("maher-shalal-hash-baz".equalsIgnoreCase(word)) {
49	0	return "Maher-Shalal-Hash-Baz";
50		}
51
52	0	if ("no-one".equalsIgnoreCase(word)) {
53	0	return "No-one";
54		}
55
56	0	if ("god-".equalsIgnoreCase(word.substring(0, 4))) {
57	0	return toSentenceCase(word);
58		}
59
60		// So cut by the -
61	0	return toSentenceCase(word.substring(0, index)) + "-" + toSentenceCase(word.substring(index + 1));
62		}
63		},
64
65	0	UPPER {
66		@Override
67		public String setCase(String word) {
68	0	return word.toUpperCase(LocaleProviderManager.getLocale());
69		}
70		};
71
72		/**
73		* Adjust the case of the string as defined by the type.
74		*
75		* @param word the string to transform
76		* @return the transformed string
77		*/
78		public abstract String setCase(String word);
79
80		/**
81		* Change to sentence case - that is first character in caps, the rest in lower.
82		*
83		* @param word
84		* The word to be manipulated
85		* @return The altered word
86		*/
87		public static String toSentenceCase(String word) {
88	0	assert word != null;
89
90	0	if (word.length() == 0) {
91	0	return "";
92		}
93
94	0	return Character.toUpperCase(word.charAt(0)) + word.substring(1).toLowerCase(LocaleProviderManager.getLocale());
95		}
96
97		/**
98		* What case is the specified word?. A blank word is LOWER, a word with a
99		* single upper case letter is SENTENCE and not UPPER - Simply because this
100		* is more likely, however TO BE SURE I WOULD NEED TO THE CONTEXT. I could
101		* not tell otherwise.
102		* <p>
103		* The issue here is that getCase("FreD") is undefined. Telling if this is
104		* SENTENCE (Tubal-Cain) or MIXED (really the case) is complex and would
105		* slow things down for a case that I don't believe happens with Bible text.
106		* </p>
107		*
108		* @param word
109		* The word to be tested
110		* @return LOWER, SENTENCE, UPPER or MIXED
111		* @exception IllegalArgumentException
112		* is the word is null
113		*/
114		public static CaseType getCase(String word) {
115	0	assert word != null;
116
117		// Blank word
118	0	if (word.length() == 0) {
119	0	return LOWER;
120		}
121
122		// Lower case?
123	0	if (word.equals(word.toLowerCase(LocaleProviderManager.getLocale()))) {
124	0	return LOWER;
125		}
126
127		// Upper case?
128		// A string length of 1 is no good ('I' or 'A' is sentence case)
129	0	if (word.equals(word.toUpperCase(LocaleProviderManager.getLocale())) && word.length() != 1) {
130	0	return UPPER;
131		}
132
133		// So ...
134	0	return SENTENCE;
135		}
136
137		/**
138		* Get an integer representation for this CaseType
139		*
140		* @return the ordinal value of this CaseType
141		*/
142		public int toInteger() {
143	0	return ordinal();
144		}
145
146		/**
147		* Lookup method to convert from a String
148		*
149		* @param name the name of the CaseType
150		* @return the CaseType that matches
151		*/
152		public static CaseType fromString(String name) {
153	0	for (CaseType v : values()) {
154	0	if (v.name().equalsIgnoreCase(name)) {
155	0	return v;
156		}
157		}
158
159		// cannot get here
160	0	assert false;
161	0	return null;
162		}
163
164		/**
165		* Lookup method to convert from an integer
166		*
167		* @param i the ordinal value of the CaseType
168		* @return the matching CaseType
169		*/
170		public static CaseType fromInteger(int i) {
171	0	for (CaseType v : values()) {
172	0	if (v.ordinal() == i) {
173	0	return v;
174		}
175		}
176
177		// cannot get here
178	0	assert false;
179	0	return null;
180		}
181
182		}