W3C home > Mailing lists > Public > www-validator-cvs@w3.org > March 2010

2006/unicorn/src/org/w3c/unicorn/util Language.java,1.18,1.19

From: Thomas Gambet via cvs-syncmail <cvsmail@w3.org>
Date: Sat, 20 Mar 2010 16:56:52 +0000
To: www-validator-cvs@w3.org
Message-Id: <E1Nt1ym-0007ec-La@lionel-hutz.w3.org>
Update of /sources/public/2006/unicorn/src/org/w3c/unicorn/util
In directory hutz:/tmp/cvs-serv29408/src/org/w3c/unicorn/util

Modified Files:
	Language.java 
Log Message:
new way to get the best locale for a lang parameter using  LocaleMatcher objects (icu4j) through the new functions getLocale, getAvailableLocale, and getUILocale. 
+ added members "ArrayList<ULocale> uiLocales" and "ArrayList<ULocale> availableLocales" which are sorted list of ULocale objects using ULocale.getDisplayName function

Index: Language.java
===================================================================
RCS file: /sources/public/2006/unicorn/src/org/w3c/unicorn/util/Language.java,v
retrieving revision 1.18
retrieving revision 1.19
diff -u -d -r1.18 -r1.19
--- Language.java	5 Mar 2010 15:11:08 -0000	1.18
+++ Language.java	20 Mar 2010 16:56:50 -0000	1.19
@@ -7,72 +7,114 @@
 import java.io.InputStreamReader;
 import java.io.UnsupportedEncodingException;
 import java.util.ArrayList;
-import java.util.Enumeration;
-import java.util.Locale;
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.Properties;
 import java.util.TreeMap;
 
-import org.apache.commons.lang.StringUtils;
 import org.apache.velocity.VelocityContext;
 import org.w3c.unicorn.Framework;
 
+import com.ibm.icu.util.LocaleMatcher;
+import com.ibm.icu.util.LocalePriorityList;
+import com.ibm.icu.util.ULocale;
+
 public class Language {
 	
-	public static boolean isISOLanguageCode(String languageCode) {
-		String[] isoCodes = Locale.getISOLanguages();
-		for (String code : isoCodes) {
-			if (code.equals(languageCode))
-				return true;
-		}
-		return false;
-	}
+	private static ULocale defaultLocale;
+	private static ArrayList<ULocale> uiLocales;
+	private static ArrayList<ULocale> availableLocales;
+	private static LocaleMatcher uiLocaleMatcher;
+	private static LocaleMatcher availableLocaleMatcher;
+	private static LocaleMatcher installedLocaleMatcher;
 	
-	public static Locale getLocale(String languageCode) {
-		Locale[] locales= Locale.getAvailableLocales();
-		for (Locale locale : locales) {
-			if (locale.getLanguage().equals(languageCode))
-				return locale;
-		}
-		if (isISOLanguageCode(languageCode))
-			Framework.logger.warn("Missing locale: " + languageCode + ". This locale should be installed on the system in order to translate Unicorn in this language.");
-		return null;
+	public static void reset() {
+		defaultLocale = null;
+		uiLocales = null;
+		availableLocales = null;
+		uiLocaleMatcher = null;
+		availableLocaleMatcher = null;
+		installedLocaleMatcher = null;
 	}
 	
-	public static String negociate(Enumeration<?> locales) {
-		while (locales.hasMoreElements()) {
-			Locale loc = (Locale) locales.nextElement();
-			if (Framework.getLanguageProperties().containsKey(loc.getLanguage())) {
-				return loc.getLanguage();
+	public static void initLocaleMatcher(ULocale defaultLocale) {
+		Language.defaultLocale = defaultLocale;
+		availableLocales = new ArrayList<ULocale>();
+		
+		LocalePriorityList.Builder builder = LocalePriorityList.add(defaultLocale);
+		for (ULocale locale : ULocale.getAvailableLocales())
+			if (locale != defaultLocale)
+				builder = builder.add(locale);
+		LocalePriorityList installedLocalesPriorityList = builder.build();
+		installedLocaleMatcher = new LocaleMatcher(installedLocalesPriorityList);
+		
+		TreeMap<String, ULocale> availableLocalesTree = new TreeMap<String, ULocale>();
+		for (ULocale locale : ULocale.getAvailableLocales()) {
+			if (!availableLocalesTree.containsKey(locale.getLanguage())) {
+				availableLocalesTree.put(locale.getLanguage(), locale);
+				continue;
+			} else {
+				String localeName = locale.getLanguage() + "_" + locale.getScript();
+				if (!availableLocalesTree.get(locale.getLanguage()).getScript().equals(locale.getScript()) && !availableLocalesTree.containsKey(localeName))
+					availableLocalesTree.put(localeName, locale);
 			}
 		}
-		return Property.get("DEFAULT_LANGUAGE");
+		LocalePriorityList.Builder builder2 = LocalePriorityList.add(defaultLocale);
+		for (String key : availableLocalesTree.keySet()) {
+			availableLocales.add(availableLocalesTree.get(key));
+			if (availableLocalesTree.get(key) != defaultLocale)
+				builder2 = builder2.add(availableLocalesTree.get(key));
+		}
+		LocalePriorityList availableLocalesPriorityList = builder2.build();
+		availableLocaleMatcher = new LocaleMatcher(availableLocalesPriorityList);
+		sortByDisplayName(availableLocales);
 	}
 	
-	public static VelocityContext getContext(String langParameter) {
-		if (langParameter != null && Framework.getLanguageContexts().containsKey(langParameter))
-			return Framework.getLanguageContexts().get(langParameter);
+	public static void initUILocaleMatcher() {
+		LocalePriorityList.Builder builder = null;
+		builder = LocalePriorityList.add(defaultLocale);
+		for (ULocale locale : uiLocales)
+			if (locale != defaultLocale)
+				builder = builder.add(locale);
+		LocalePriorityList uiLocalesPriorityList = builder.build();
+		uiLocaleMatcher = new LocaleMatcher(uiLocalesPriorityList);
+		sortByDisplayName(uiLocales);
+	}
+	
+	public static ULocale getLocale(String languageCode) {
+		return installedLocaleMatcher.getBestMatch(languageCode);
+	}
+	
+	public static ULocale getUILocale(String languageCode) {
+		return uiLocaleMatcher.getBestMatch(languageCode);
+	}
+	
+	public static ULocale getAvailableLocale(String languageCode) {
+		return availableLocaleMatcher.getBestMatch(languageCode);
+	}
+	
+	public static VelocityContext getContext(ULocale localeParam) {
+		if (localeParam != null && Framework.getLanguageContexts().containsKey(localeParam))
+			return Framework.getLanguageContexts().get(localeParam);
 		else
-			return Framework.getLanguageContexts().get(Property.get("DEFAULT_LANGUAGE"));
+			return Framework.getLanguageContexts().get(defaultLocale);
 	}
 
-	public static void complete(Properties props, Properties defaultProps) {
-		//props.put("complete", "true");
+	public static void complete(Properties props, Properties defaultProps, String fileName) {
 		for (Object key : defaultProps.keySet()) {
 			if (!props.containsKey(key) && key != "complete") {
-				//props.put("complete", "false");
-				//props.put(key, "<span dir=\"" + defaultProps.get("direction") + "\" xml:lang=\"" + defaultProps.get("lang") + "\">" + defaultProps.get(key) + "</span>");
 				props.put(key, defaultProps.get(key));
-				Framework.logger.warn(">> Missing property in " + props.getProperty("lang") + ".properties for key: \"" + (String) key + "\". Added default property for this key: \"" + defaultProps.get(key) + "\""); 
+				Framework.logger.info(">> Missing property in " + fileName + " for key: \"" + (String) key + "\". Added default property for this key: \"" + defaultProps.get(key) + "\""); 
 			}
 		}
 	}
 	
-	public static void clean(UCNProperties props, UCNProperties defaultProps) {
+	public static void clean(UCNProperties props, UCNProperties defaultProps, String fileName) {
 		ArrayList<String> keys = new ArrayList<String>();
 		for (Object key : props.keySet()) {
 			if (!defaultProps.containsKey(key)) {
 				keys.add((String) key);
-				Framework.logger.error(">> Unexisting property in " + props.getProperty("lang") + ".properties for key: \"" + (String) key + "\". This property should be removed manually from the language file."); 
+				Framework.logger.warn(">> Inexistent property in " + fileName + " for key: \"" + (String) key + "\". This property should be removed manually from the language file."); 
 			}
 		}
 		for (String key : keys)
@@ -80,21 +122,12 @@
 	}
 	
 	public static UCNProperties load(File langFile) throws IllegalArgumentException, FileNotFoundException, IOException {
-
-		String localeString = langFile.getName().split("\\.")[0];
-		if (!Language.isISOLanguageCode(localeString))
-			throw new IllegalArgumentException("Invalid language file: " + langFile + ". " + localeString + " is not a valid ISO language code. This file will not be loaded.");
-
-		Locale locale = Language.getLocale(localeString);
-		
 		FileInputStream fis = new FileInputStream(langFile);
 		InputStreamReader isr;
 		try {
 			isr = new InputStreamReader(fis, "UTF-8");
 			UCNProperties props = new UCNProperties();
 			props.load(isr);
-			props.put("lang", localeString);
-			props.put("language", StringUtils.capitalize(locale.getDisplayLanguage(locale)));
 			return props;
 		} catch (UnsupportedEncodingException e) {
 			// This should not happen
@@ -102,19 +135,33 @@
 			return null;
 		}
 	}
-
-	public static boolean isComplete(String langParameter) {
-		Properties testedProps = Framework.getLanguageProperties().get(langParameter);
-		Properties testedMetadataProps = Framework.getMetadataProperties().get(langParameter);
+	
+	public static ULocale getLocaleFromFileName(String fileName) throws IllegalArgumentException{
+		String localeString = fileName.split("\\.")[0];
+		ULocale locale = Language.getLocale(localeString);
+		if (locale == null) {
+			throw new IllegalArgumentException("Locale not found for file name: " + fileName);
+		} else if (!availableLocales.contains(locale)) {
+			throw new IllegalArgumentException("Locale for file name: " + fileName + " is not a Unicorn available locale.");
+		}
+		return locale;
+	}
+	
+	public static boolean isComplete(ULocale localeParam) {
+		Properties testedProps = Framework.getLanguageProperties().get(localeParam);
+		Properties testedMetadataProps = Framework.getMetadataProperties().get(localeParam);
+		
+		if (testedProps == null)
+			return false;
 		
 		if (testedProps.get("complete") == null) {
-			for (Object key : Framework.getLanguageProperties().get(Property.get("DEFAULT_LANGUAGE")).keySet()) {
+			for (Object key : Framework.getLanguageProperties().get(defaultLocale).keySet()) {
 				if (!testedProps.containsKey(key) && key != "complete") {
 					testedProps.put("complete", "false");
 					return false;
 				}
 			}
-			for (Object key : Framework.getMetadataProperties().get(Property.get("DEFAULT_LANGUAGE")).keySet()) {
+			for (Object key : Framework.getMetadataProperties().get(defaultLocale).keySet()) {
 				if (!testedMetadataProps.containsKey(key)) {
 					testedProps.put("complete", "false");
 					return false;
@@ -155,15 +202,41 @@
 		}
 		return result;
 	}
+	
+	public static String getLocaleDirection(ULocale locale) {
+		if (locale.getLineOrientation().equals("left-to-right"))
+			return "ltr";
+		if (locale.getLineOrientation().equals("right-to-left"))
+			return "rtl";
+		return "ltr";
+	}
+	
+	private static void sortByDisplayName(ArrayList<ULocale> localeArray) {
+		Collections.sort(localeArray, new Comparator<ULocale>() {
+			public int compare(ULocale l1, ULocale l2) {
+				String loc1 = l1.getDisplayName(l1);
+				String loc2 = l2.getDisplayName(l2);
+				return loc1.compareToIgnoreCase(loc2);
+			}
+		});
+	}
+	
+	public static ULocale getDefaultLocale() {
+		return defaultLocale;
+	}
 
-	public static TreeMap<String, String> getAvailablesLocales() {
-		Locale[] locales= Locale.getAvailableLocales();
-		TreeMap<String, String> result = new TreeMap<String, String>();
-		for (Locale loc : locales) {
-			if (!loc.getLanguage().equals(Property.get("DEFAULT_LANGUAGE")))
-				result.put(loc.getLanguage(), StringUtils.capitalize(loc.getDisplayLanguage(loc)));
-		}
-		return result;
+	public static void addUiLocale(ULocale locale) {
+		if (uiLocales == null)
+			uiLocales = new ArrayList<ULocale>();
+		uiLocales.add(locale);
+	}
+
+	public static ArrayList<ULocale> getUiLocales() {
+		return uiLocales;
+	}
+
+	public static ArrayList<ULocale> getAvailableLocales() {
+		return availableLocales;
 	}
 	
 }
Received on Saturday, 20 March 2010 16:56:54 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Thursday, 26 April 2012 12:55:19 GMT