| OLD | NEW |
| (Empty) |
| 1 // Copyright 2006-2011 the V8 project authors. All rights reserved. | |
| 2 // Redistribution and use in source and binary forms, with or without | |
| 3 // modification, are permitted provided that the following conditions are | |
| 4 // met: | |
| 5 // | |
| 6 // * Redistributions of source code must retain the above copyright | |
| 7 // notice, this list of conditions and the following disclaimer. | |
| 8 // * Redistributions in binary form must reproduce the above | |
| 9 // copyright notice, this list of conditions and the following | |
| 10 // disclaimer in the documentation and/or other materials provided | |
| 11 // with the distribution. | |
| 12 // * Neither the name of Google Inc. nor the names of its | |
| 13 // contributors may be used to endorse or promote products derived | |
| 14 // from this software without specific prior written permission. | |
| 15 // | |
| 16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| 17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| 18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| 19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| 20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| 22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 27 | |
| 28 // TODO(cira): Rename v8Locale into LocaleInfo once we have stable API. | |
| 29 /** | |
| 30 * LocaleInfo class is an aggregate class of all i18n API calls. | |
| 31 * @param {Object} settings - localeID and regionID to create LocaleInfo from. | |
| 32 * {Array.<string>|string} settings.localeID - | |
| 33 * Unicode identifier of the locale. | |
| 34 * See http://unicode.org/reports/tr35/#BCP_47_Conformance | |
| 35 * {string} settings.regionID - ISO3166 region ID with addition of | |
| 36 * invalid, undefined and reserved region codes. | |
| 37 * @constructor | |
| 38 */ | |
| 39 v8Locale = function(settings) { | |
| 40 native function NativeJSLocale(); | |
| 41 | |
| 42 // Assume user wanted to do v8Locale("sr"); | |
| 43 if (typeof(settings) === "string") { | |
| 44 settings = {'localeID': settings}; | |
| 45 } | |
| 46 | |
| 47 var properties = NativeJSLocale( | |
| 48 v8Locale.__createSettingsOrDefault(settings, {'localeID': 'root'})); | |
| 49 | |
| 50 // Keep the resolved ICU locale ID around to avoid resolving localeID to | |
| 51 // ICU locale ID every time BreakIterator, Collator and so forth are called. | |
| 52 this.__icuLocaleID = properties.icuLocaleID; | |
| 53 this.options = {'localeID': properties.localeID, | |
| 54 'regionID': properties.regionID}; | |
| 55 }; | |
| 56 | |
| 57 /** | |
| 58 * Clones existing locale with possible overrides for some of the options. | |
| 59 * @param {!Object} settings - overrides for current locale settings. | |
| 60 * @returns {Object} - new LocaleInfo object. | |
| 61 */ | |
| 62 v8Locale.prototype.derive = function(settings) { | |
| 63 return new v8Locale( | |
| 64 v8Locale.__createSettingsOrDefault(settings, this.options)); | |
| 65 }; | |
| 66 | |
| 67 /** | |
| 68 * v8BreakIterator class implements locale aware segmenatation. | |
| 69 * It is not part of EcmaScript proposal. | |
| 70 * @param {Object} locale - locale object to pass to break | |
| 71 * iterator implementation. | |
| 72 * @param {string} type - type of segmenatation: | |
| 73 * - character | |
| 74 * - word | |
| 75 * - sentence | |
| 76 * - line | |
| 77 * @private | |
| 78 * @constructor | |
| 79 */ | |
| 80 v8Locale.v8BreakIterator = function(locale, type) { | |
| 81 native function NativeJSBreakIterator(); | |
| 82 | |
| 83 locale = v8Locale.__createLocaleOrDefault(locale); | |
| 84 // BCP47 ID would work in this case, but we use ICU locale for consistency. | |
| 85 var iterator = NativeJSBreakIterator(locale.__icuLocaleID, type); | |
| 86 iterator.type = type; | |
| 87 return iterator; | |
| 88 }; | |
| 89 | |
| 90 /** | |
| 91 * Type of the break we encountered during previous iteration. | |
| 92 * @type{Enum} | |
| 93 */ | |
| 94 v8Locale.v8BreakIterator.BreakType = { | |
| 95 'unknown': -1, | |
| 96 'none': 0, | |
| 97 'number': 100, | |
| 98 'word': 200, | |
| 99 'kana': 300, | |
| 100 'ideo': 400 | |
| 101 }; | |
| 102 | |
| 103 /** | |
| 104 * Creates new v8BreakIterator based on current locale. | |
| 105 * @param {string} - type of segmentation. See constructor. | |
| 106 * @returns {Object} - new v8BreakIterator object. | |
| 107 */ | |
| 108 v8Locale.prototype.v8CreateBreakIterator = function(type) { | |
| 109 return new v8Locale.v8BreakIterator(this, type); | |
| 110 }; | |
| 111 | |
| 112 // TODO(jungshik): Set |collator.options| to actually recognized / resolved | |
| 113 // values. | |
| 114 /** | |
| 115 * Collator class implements locale-aware sort. | |
| 116 * @param {Object} locale - locale object to pass to collator implementation. | |
| 117 * @param {Object} settings - collation flags: | |
| 118 * - ignoreCase | |
| 119 * - ignoreAccents | |
| 120 * - numeric | |
| 121 * @private | |
| 122 * @constructor | |
| 123 */ | |
| 124 v8Locale.Collator = function(locale, settings) { | |
| 125 native function NativeJSCollator(); | |
| 126 | |
| 127 locale = v8Locale.__createLocaleOrDefault(locale); | |
| 128 var collator = NativeJSCollator( | |
| 129 locale.__icuLocaleID, v8Locale.__createSettingsOrDefault(settings, {})); | |
| 130 return collator; | |
| 131 }; | |
| 132 | |
| 133 /** | |
| 134 * Creates new Collator based on current locale. | |
| 135 * @param {Object} - collation flags. See constructor. | |
| 136 * @returns {Object} - new Collator object. | |
| 137 */ | |
| 138 v8Locale.prototype.createCollator = function(settings) { | |
| 139 return new v8Locale.Collator(this, settings); | |
| 140 }; | |
| 141 | |
| 142 /** | |
| 143 * DateTimeFormat class implements locale-aware date and time formatting. | |
| 144 * Constructor is not part of public API. | |
| 145 * @param {Object} locale - locale object to pass to formatter. | |
| 146 * @param {Object} settings - formatting flags: | |
| 147 * - skeleton | |
| 148 * - dateType | |
| 149 * - timeType | |
| 150 * - calendar | |
| 151 * @private | |
| 152 * @constructor | |
| 153 */ | |
| 154 v8Locale.__DateTimeFormat = function(locale, settings) { | |
| 155 native function NativeJSDateTimeFormat(); | |
| 156 | |
| 157 settings = v8Locale.__createSettingsOrDefault(settings, {}); | |
| 158 | |
| 159 var cleanSettings = {}; | |
| 160 if (settings.hasOwnProperty('skeleton')) { | |
| 161 cleanSettings['skeleton'] = settings['skeleton']; | |
| 162 } else { | |
| 163 cleanSettings = {}; | |
| 164 if (settings.hasOwnProperty('dateType')) { | |
| 165 var dt = settings['dateType']; | |
| 166 if (!/^short|medium|long|full$/.test(dt)) dt = 'short'; | |
| 167 cleanSettings['dateType'] = dt; | |
| 168 } | |
| 169 | |
| 170 if (settings.hasOwnProperty('timeType')) { | |
| 171 var tt = settings['timeType']; | |
| 172 if (!/^short|medium|long|full$/.test(tt)) tt = 'short'; | |
| 173 cleanSettings['timeType'] = tt; | |
| 174 } | |
| 175 } | |
| 176 | |
| 177 // Default is to show short date and time. | |
| 178 if (!cleanSettings.hasOwnProperty('skeleton') && | |
| 179 !cleanSettings.hasOwnProperty('dateType') && | |
| 180 !cleanSettings.hasOwnProperty('timeType')) { | |
| 181 cleanSettings = {'dateType': 'short', | |
| 182 'timeType': 'short'}; | |
| 183 } | |
| 184 | |
| 185 locale = v8Locale.__createLocaleOrDefault(locale); | |
| 186 var formatter = NativeJSDateTimeFormat(locale.__icuLocaleID, cleanSettings); | |
| 187 | |
| 188 // NativeJSDateTimeFormat creates formatter.options for us, we just need | |
| 189 // to append actual settings to it. | |
| 190 for (key in cleanSettings) { | |
| 191 formatter.options[key] = cleanSettings[key]; | |
| 192 } | |
| 193 | |
| 194 /** | |
| 195 * Clones existing date time format with possible overrides for some | |
| 196 * of the options. | |
| 197 * @param {!Object} overrideSettings - overrides for current format settings. | |
| 198 * @returns {Object} - new DateTimeFormat object. | |
| 199 * @public | |
| 200 */ | |
| 201 formatter.derive = function(overrideSettings) { | |
| 202 // To remove a setting user can specify undefined as its value. We'll remove | |
| 203 // it from the map in that case. | |
| 204 for (var prop in overrideSettings) { | |
| 205 if (settings.hasOwnProperty(prop) && !overrideSettings[prop]) { | |
| 206 delete settings[prop]; | |
| 207 } | |
| 208 } | |
| 209 return new v8Locale.__DateTimeFormat( | |
| 210 locale, v8Locale.__createSettingsOrDefault(overrideSettings, settings)); | |
| 211 }; | |
| 212 | |
| 213 return formatter; | |
| 214 }; | |
| 215 | |
| 216 /** | |
| 217 * Creates new DateTimeFormat based on current locale. | |
| 218 * @param {Object} - formatting flags. See constructor. | |
| 219 * @returns {Object} - new DateTimeFormat object. | |
| 220 */ | |
| 221 v8Locale.prototype.createDateTimeFormat = function(settings) { | |
| 222 return new v8Locale.__DateTimeFormat(this, settings); | |
| 223 }; | |
| 224 | |
| 225 /** | |
| 226 * Merges user settings and defaults. | |
| 227 * Settings that are not of object type are rejected. | |
| 228 * Actual property values are not validated, but whitespace is trimmed if they | |
| 229 * are strings. | |
| 230 * @param {!Object} settings - user provided settings. | |
| 231 * @param {!Object} defaults - default values for this type of settings. | |
| 232 * @returns {Object} - valid settings object. | |
| 233 * @private | |
| 234 */ | |
| 235 v8Locale.__createSettingsOrDefault = function(settings, defaults) { | |
| 236 if (!settings || typeof(settings) !== 'object' ) { | |
| 237 return defaults; | |
| 238 } | |
| 239 for (var key in defaults) { | |
| 240 if (!settings.hasOwnProperty(key)) { | |
| 241 settings[key] = defaults[key]; | |
| 242 } | |
| 243 } | |
| 244 // Clean up settings. | |
| 245 for (var key in settings) { | |
| 246 // Trim whitespace. | |
| 247 if (typeof(settings[key]) === "string") { | |
| 248 settings[key] = settings[key].trim(); | |
| 249 } | |
| 250 // Remove all properties that are set to undefined/null. This allows | |
| 251 // derive method to remove a setting we don't need anymore. | |
| 252 if (!settings[key]) { | |
| 253 delete settings[key]; | |
| 254 } | |
| 255 } | |
| 256 | |
| 257 return settings; | |
| 258 }; | |
| 259 | |
| 260 /** | |
| 261 * If locale is valid (defined and of v8Locale type) we return it. If not | |
| 262 * we create default locale and return it. | |
| 263 * @param {!Object} locale - user provided locale. | |
| 264 * @returns {Object} - v8Locale object. | |
| 265 * @private | |
| 266 */ | |
| 267 v8Locale.__createLocaleOrDefault = function(locale) { | |
| 268 if (!locale || !(locale instanceof v8Locale)) { | |
| 269 return new v8Locale(); | |
| 270 } else { | |
| 271 return locale; | |
| 272 } | |
| 273 }; | |
| OLD | NEW |