AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Experimental i18n extension breaks shared library build. Revert recent

Browse Source 
changes to unblock V8 release.

Revert "Adding DateTimeFormat class to i18n API with following methods:"

Revert "Some internal methods are requested when v8 is built as DLL (V8_SHARED), and"

R=sgjesse@chromium.org

Review URL: http://codereview.chromium.org/7060005

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@7981 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
ager@chromium.org 2011-05-23 08:35:46 +00:00
parent f19fb45510
commit 5765e8a9c0
7 changed files with 11 additions and 615 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

381
src/extensions/experimental/datetime-format.cc
View File

@ -1,381 +0,0 @@
// Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "datetime-format.h"
#include "i18n-utils.h"
#include "unicode/dtfmtsym.h"
#include "unicode/dtptngen.h"
#include "unicode/locid.h"
#include "unicode/smpdtfmt.h"
namespace v8 {
namespace internal {
v8::Persistent<v8::FunctionTemplate> DateTimeFormat::datetime_format_template_;
static icu::DateFormat* CreateDateTimeFormat(v8::Handle<v8::String>,
v8::Handle<v8::Object>);
static v8::Handle<v8::Value> GetSymbols(
const v8::Arguments&,
const icu::UnicodeString*, int32_t,
const icu::UnicodeString*, int32_t,
const icu::UnicodeString*, int32_t);
static v8::Handle<v8::Value> ThrowUnexpectedObjectError();
static icu::DateFormat::EStyle GetDateTimeStyle(const icu::UnicodeString&);
icu::SimpleDateFormat* DateTimeFormat::UnpackDateTimeFormat(
v8::Handle<v8::Object> obj) {
if (datetime_format_template_->HasInstance(obj)) {
return static_cast<icu::SimpleDateFormat*>(
obj->GetPointerFromInternalField(0));
}
return NULL;
}
void DateTimeFormat::DeleteDateTimeFormat(v8::Persistent<v8::Value> object,
void* param) {
v8::Persistent<v8::Object> persistent_object =
v8::Persistent<v8::Object>::Cast(object);
// First delete the hidden C++ object.
// Unpacking should never return NULL here. That would only happen if
// this method is used as the weak callback for persistent handles not
// pointing to a date time formatter.
delete UnpackDateTimeFormat(persistent_object);
// Then dispose of the persistent handle to JS object.
persistent_object.Dispose();
}
v8::Handle<v8::Value> DateTimeFormat::Format(const v8::Arguments& args) {
v8::HandleScope handle_scope;
double millis = 0.0;
if (args.Length() != 1 || !args[0]->IsDate()) {
// Create a new date.
v8::TryCatch try_catch;
v8::Local<v8::Script> date_script =
v8::Script::Compile(v8::String::New("eval('new Date()')"));
millis = date_script->Run()->NumberValue();
if (try_catch.HasCaught()) {
return try_catch.ReThrow();
}
} else {
millis = v8::Date::Cast(*args[0])->NumberValue();
}
icu::SimpleDateFormat* date_format = UnpackDateTimeFormat(args.Holder());
if (!date_format) {
return ThrowUnexpectedObjectError();
}
icu::UnicodeString result;
date_format->format(millis, result);
return v8::String::New(
reinterpret_cast<const uint16_t*>(result.getBuffer()), result.length());
}
v8::Handle<v8::Value> DateTimeFormat::GetMonths(const v8::Arguments& args) {
icu::SimpleDateFormat* date_format = UnpackDateTimeFormat(args.Holder());
if (!date_format) {
return ThrowUnexpectedObjectError();
}
const icu::DateFormatSymbols* symbols = date_format->getDateFormatSymbols();
int32_t narrow_count;
const icu::UnicodeString* narrow = symbols->getMonths(
narrow_count,
icu::DateFormatSymbols::STANDALONE,
icu::DateFormatSymbols::NARROW);
int32_t abbrev_count;
const icu::UnicodeString* abbrev = symbols->getMonths(
abbrev_count,
icu::DateFormatSymbols::STANDALONE,
icu::DateFormatSymbols::ABBREVIATED);
int32_t wide_count;
const icu::UnicodeString* wide = symbols->getMonths(
wide_count,
icu::DateFormatSymbols::STANDALONE,
icu::DateFormatSymbols::WIDE);
return GetSymbols(
args, narrow, narrow_count, abbrev, abbrev_count, wide, wide_count);
}
v8::Handle<v8::Value> DateTimeFormat::GetWeekdays(const v8::Arguments& args) {
icu::SimpleDateFormat* date_format = UnpackDateTimeFormat(args.Holder());
if (!date_format) {
ThrowUnexpectedObjectError();
}
const icu::DateFormatSymbols* symbols = date_format->getDateFormatSymbols();
int32_t narrow_count;
const icu::UnicodeString* narrow = symbols->getWeekdays(
narrow_count,
icu::DateFormatSymbols::STANDALONE,
icu::DateFormatSymbols::NARROW);
int32_t abbrev_count;
const icu::UnicodeString* abbrev = symbols->getWeekdays(
abbrev_count,
icu::DateFormatSymbols::STANDALONE,
icu::DateFormatSymbols::ABBREVIATED);
int32_t wide_count;
const icu::UnicodeString* wide = symbols->getWeekdays(
wide_count,
icu::DateFormatSymbols::STANDALONE,
icu::DateFormatSymbols::WIDE);
// getXXXWeekdays always returns 8 elements.
ASSERT_EQ(8, narrow_count);
ASSERT_EQ(8, abbrev_count);
ASSERT_EQ(8, wide_count);
// ICU documentation says we should ignore element 0 of the returned array.
return GetSymbols(args, narrow + 1, narrow_count - 1, abbrev + 1,
abbrev_count -1 , wide + 1, wide_count - 1);
}
v8::Handle<v8::Value> DateTimeFormat::GetEras(const v8::Arguments& args) {
icu::SimpleDateFormat* date_format = UnpackDateTimeFormat(args.Holder());
if (!date_format) {
return ThrowUnexpectedObjectError();
}
const icu::DateFormatSymbols* symbols = date_format->getDateFormatSymbols();
int32_t narrow_count;
const icu::UnicodeString* narrow = symbols->getNarrowEras(narrow_count);
int32_t abbrev_count;
const icu::UnicodeString* abbrev = symbols->getEras(abbrev_count);
int32_t wide_count;
const icu::UnicodeString* wide = symbols->getEraNames(wide_count);
return GetSymbols(
args, narrow, narrow_count, abbrev, abbrev_count, wide, wide_count);
}
v8::Handle<v8::Value> DateTimeFormat::GetAmPm(const v8::Arguments& args) {
icu::SimpleDateFormat* date_format = UnpackDateTimeFormat(args.Holder());
if (!date_format) {
return ThrowUnexpectedObjectError();
}
const icu::DateFormatSymbols* symbols = date_format->getDateFormatSymbols();
// In this case narrow == abbreviated == wide
int32_t count;
const icu::UnicodeString* wide = symbols->getAmPmStrings(count);
return GetSymbols(args, wide, count, wide, count, wide, count);
}
v8::Handle<v8::Value> DateTimeFormat::JSDateTimeFormat(
const v8::Arguments& args) {
v8::HandleScope handle_scope;
ASSERT_EQ(2, args.Length());
// LanguageID string.
ASSERT(args[0]->IsString());
// Settings object.
ASSERT(args[1]->IsObject());
icu::SimpleDateFormat* date_format = static_cast<icu::SimpleDateFormat*>(
CreateDateTimeFormat(args[0]->ToString(), args[1]->ToObject()));
if (datetime_format_template_.IsEmpty()) {
v8::Local<v8::FunctionTemplate> raw_template(v8::FunctionTemplate::New());
raw_template->SetClassName(v8::String::New("v8Locale.DateTimeFormat"));
// Define internal field count on instance template.
v8::Local<v8::ObjectTemplate> object_template =
raw_template->InstanceTemplate();
// Set aside internal field for icu date time formatter.
object_template->SetInternalFieldCount(1);
// Define all of the prototype methods on prototype template.
v8::Local<v8::ObjectTemplate> proto = raw_template->PrototypeTemplate();
proto->Set(v8::String::New("format"),
v8::FunctionTemplate::New(Format));
proto->Set(v8::String::New("getMonths"),
v8::FunctionTemplate::New(GetMonths));
proto->Set(v8::String::New("getWeekdays"),
v8::FunctionTemplate::New(GetWeekdays));
proto->Set(v8::String::New("getEras"),
v8::FunctionTemplate::New(GetEras));
proto->Set(v8::String::New("getAmPm"),
v8::FunctionTemplate::New(GetAmPm));
datetime_format_template_ =
v8::Persistent<v8::FunctionTemplate>::New(raw_template);
}
// Create an empty object wrapper.
v8::Local<v8::Object> local_object =
datetime_format_template_->GetFunction()->NewInstance();
v8::Persistent<v8::Object> wrapper =
v8::Persistent<v8::Object>::New(local_object);
// Set date time formatter as internal field of the resulting JS object.
wrapper->SetPointerInInternalField(0, date_format);
// Set resolved pattern in options.pattern.
icu::UnicodeString pattern;
date_format->toPattern(pattern);
v8::Local<v8::Object> options = v8::Object::New();
options->Set(v8::String::New("pattern"),
v8::String::New(reinterpret_cast<const uint16_t*>(
pattern.getBuffer()), pattern.length()));
wrapper->Set(v8::String::New("options"), options);
// Make object handle weak so we can delete iterator once GC kicks in.
wrapper.MakeWeak(NULL, DeleteDateTimeFormat);
return wrapper;
}
// Returns SimpleDateFormat.
static icu::DateFormat* CreateDateTimeFormat(
v8::Handle<v8::String> locale, v8::Handle<v8::Object> settings) {
v8::HandleScope handle_scope;
v8::String::AsciiValue ascii_locale(locale);
icu::Locale icu_locale(*ascii_locale);
// Make formatter from skeleton.
icu::SimpleDateFormat* date_format = NULL;
UErrorCode status = U_ZERO_ERROR;
icu::UnicodeString skeleton;
if (I18NUtils::ExtractStringSetting(settings, "skeleton", &skeleton)) {
v8::Local<icu::DateTimePatternGenerator> generator(
icu::DateTimePatternGenerator::createInstance(icu_locale, status));
icu::UnicodeString pattern =
generator->getBestPattern(skeleton, status);
date_format = new icu::SimpleDateFormat(pattern, icu_locale, status);
if (U_SUCCESS(status)) {
return date_format;
} else {
delete date_format;
}
}
// Extract date type and time type from settings.
icu::UnicodeString date_type;
icu::DateFormat::EStyle date_style = icu::DateFormat::kNone;
if (I18NUtils::ExtractStringSetting(settings, "dateType", &date_type)) {
date_style = GetDateTimeStyle(date_type);
}
icu::UnicodeString time_type;
icu::DateFormat::EStyle time_style = icu::DateFormat::kNone;
if (I18NUtils::ExtractStringSetting(settings, "timeType", &time_type)) {
time_style = GetDateTimeStyle(time_type);
}
// Try all combinations of date/time types.
if (date_style == icu::DateFormat::kNone &&
time_style == icu::DateFormat::kNone) {
// Return default short date, short
return icu::DateFormat::createDateTimeInstance(
icu::DateFormat::kShort, icu::DateFormat::kShort, icu_locale);
} else if (date_style != icu::DateFormat::kNone &&
time_style != icu::DateFormat::kNone) {
return icu::DateFormat::createDateTimeInstance(
date_style, time_style, icu_locale);
} else if (date_style != icu::DateFormat::kNone) {
return icu::DateFormat::createDateInstance(date_style, icu_locale);
} else {
// time_style != icu::DateFormat::kNone
return icu::DateFormat::createTimeInstance(time_style, icu_locale);
}
}
// Creates a v8::Array of narrow, abbrev or wide symbols.
static v8::Handle<v8::Value> GetSymbols(const v8::Arguments& args,
const icu::UnicodeString* narrow,
int32_t narrow_count,
const icu::UnicodeString* abbrev,
int32_t abbrev_count,
const icu::UnicodeString* wide,
int32_t wide_count) {
v8::HandleScope handle_scope;
// Make wide width default.
const icu::UnicodeString* result = wide;
int32_t count = wide_count;
if (args.Length() == 1 && args[0]->IsString()) {
v8::String::AsciiValue ascii_value(args[0]);
if (strcmp(*ascii_value, "abbreviated") == 0) {
result = abbrev;
count = abbrev_count;
} else if (strcmp(*ascii_value, "narrow") == 0) {
result = narrow;
count = narrow_count;
}
}
v8::Handle<v8::Array> symbols = v8::Array::New();
for (int32_t i = 0; i < count; ++i) {
symbols->Set(i, v8::String::New(
reinterpret_cast<const uint16_t*>(result[i].getBuffer()),
result[i].length()));
}
return handle_scope.Close(symbols);
}
// Throws a JavaScript exception.
static v8::Handle<v8::Value> ThrowUnexpectedObjectError() {
// Returns undefined, and schedules an exception to be thrown.
return v8::ThrowException(v8::Exception::Error(
v8::String::New("DateTimeFormat method called on an object "
"that is not a DateTimeFormat.")));
}
// Returns icu date/time style.
static icu::DateFormat::EStyle GetDateTimeStyle(
const icu::UnicodeString& type) {
if (type == UNICODE_STRING_SIMPLE("medium")) {
return icu::DateFormat::kMedium;
} else if (type == UNICODE_STRING_SIMPLE("long")) {
return icu::DateFormat::kLong;
} else if (type == UNICODE_STRING_SIMPLE("full")) {
return icu::DateFormat::kFull;
}
return icu::DateFormat::kShort;
}
} } // namespace v8::internal

83
src/extensions/experimental/datetime-format.h
View File

@ -1,83 +0,0 @@
// Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef V8_EXTENSIONS_EXPERIMENTAL_DATETIME_FORMAT_H_
#define V8_EXTENSIONS_EXPERIMENTAL_DATETIME_FORMAT_H_
#include <v8.h>
#include "unicode/uversion.h"
namespace U_ICU_NAMESPACE {
class SimpleDateFormat;
}
namespace v8 {
namespace internal {
class DateTimeFormat {
public:
static v8::Handle<v8::Value> JSDateTimeFormat(const v8::Arguments& args);
// Helper methods for various bindings.
// Unpacks date format object from corresponding JavaScript object.
static icu::SimpleDateFormat* UnpackDateTimeFormat(
v8::Handle<v8::Object> obj);
// Release memory we allocated for the DateFormat once the JS object that
// holds the pointer gets garbage collected.
static void DeleteDateTimeFormat(v8::Persistent<v8::Value> object,
void* param);
// Formats date and returns corresponding string.
static v8::Handle<v8::Value> Format(const v8::Arguments& args);
// All date time symbol methods below return stand-alone names in
// either narrow, abbreviated or wide width.
// Get list of months.
static v8::Handle<v8::Value> GetMonths(const v8::Arguments& args);
// Get list of weekdays.
static v8::Handle<v8::Value> GetWeekdays(const v8::Arguments& args);
// Get list of eras.
static v8::Handle<v8::Value> GetEras(const v8::Arguments& args);
// Get list of day periods.
static v8::Handle<v8::Value> GetAmPm(const v8::Arguments& args);
private:
DateTimeFormat();
static v8::Persistent<v8::FunctionTemplate> datetime_format_template_;
};
} } // namespace v8::internal
#endif // V8_EXTENSIONS_EXPERIMENTAL_DATETIME_FORMAT_H_

2
src/extensions/experimental/experimental.gyp
View File

@ -41,8 +41,6 @@
'break-iterator.h',
'collator.cc',
'collator.h',
'datetime-format.cc',
'datetime-format.h',
'i18n-extension.cc',
'i18n-extension.h',
'i18n-locale.cc',

12
src/extensions/experimental/i18n-extension.cc
View File

@ -29,7 +29,6 @@
#include "break-iterator.h"
#include "collator.h"
#include "datetime-format.h"
#include "i18n-locale.h"
#include "natives.h"
@ -60,8 +59,6 @@ v8::Handle<v8::FunctionTemplate> I18NExtension::GetNativeFunction(
return v8::FunctionTemplate::New(BreakIterator::JSBreakIterator);
} else if (name->Equals(v8::String::New("NativeJSCollator"))) {
return v8::FunctionTemplate::New(Collator::JSCollator);
} else if (name->Equals(v8::String::New("NativeJSDateTimeFormat"))) {
return v8::FunctionTemplate::New(DateTimeFormat::JSDateTimeFormat);
}
return v8::Handle<v8::FunctionTemplate>();
@ -78,13 +75,4 @@ void I18NExtension::Register() {
static v8::DeclareExtension i18n_extension_declaration(I18NExtension::get());
}
#ifdef V8_SHARED
// We end up dragging in a call to Malloc::FatalProcessOutOfMemory by including
// allocation.h, but that function isn't public V8 API so it's not available
// when v8 is build as DLL.
// Define it as a no-op here.
void Malloced::FatalProcessOutOfMemory() {
}
#endif
} } // namespace v8::internal

25
src/extensions/experimental/i18n-utils.cc
View File

@ -29,8 +29,6 @@
#include <string.h>
#include "unicode/unistr.h"
namespace v8 {
namespace internal {
@ -42,27 +40,4 @@ void I18NUtils::StrNCopy(char* dest, int length, const char* src) {
dest[length - 1] = '\0';
}
// static
bool I18NUtils::ExtractStringSetting(const v8::Handle<v8::Object>& settings,
const char* setting,
icu::UnicodeString* result) {
if (!setting || !result) return false;
v8::HandleScope handle_scope;
v8::TryCatch try_catch;
v8::Handle<v8::Value> value = settings->Get(v8::String::New(setting));
if (try_catch.HasCaught()) {
return false;
}
// No need to check if |value| is empty because it's taken care of
// by TryCatch above.
if (!value->IsUndefined() && !value->IsNull() && value->IsString()) {
v8::String::Utf8Value utf8_value(value);
if (*utf8_value == NULL) return false;
result->setTo(icu::UnicodeString::fromUTF8(*utf8_value));
return true;
}
return false;
}
} } // namespace v8::internal

14
src/extensions/experimental/i18n-utils.h
View File

@ -28,14 +28,6 @@
#ifndef V8_EXTENSIONS_EXPERIMENTAL_I18N_UTILS_H_
#define V8_EXTENSIONS_EXPERIMENTAL_I18N_UTILS_H_
#include <v8.h>
#include "unicode/uversion.h"
namespace U_ICU_NAMESPACE {
class UnicodeString;
}
namespace v8 {
namespace internal {
@ -48,12 +40,6 @@ class I18NUtils {
// TODO(cira): Find a way to use OS::SNPrintF instead.
static void StrNCopy(char* dest, int length, const char* src);
// Extract a string setting named in |settings| and set it to |result|.
// Return true if it's specified. Otherwise, return false.
static bool ExtractStringSetting(const v8::Handle<v8::Object>& settings,
const char* setting,
icu::UnicodeString* result);
private:
I18NUtils() {}
};

109
src/extensions/experimental/i18n.js
View File

@ -45,11 +45,11 @@ v8Locale = function(settings) {
}
var properties = NativeJSLocale(
v8Locale.__createSettingsOrDefault(settings, {'localeID': 'root'}));
v8Locale.createSettingsOrDefault_(settings, {'localeID': 'root'}));
// Keep the resolved ICU locale ID around to avoid resolving localeID to
// ICU locale ID every time BreakIterator, Collator and so forth are called.
this.__icuLocaleID = properties.icuLocaleID;
this.__icuLocaleID__ = properties.icuLocaleID;
this.options = {'localeID': properties.localeID,
'regionID': properties.regionID};
};
@ -61,7 +61,7 @@ v8Locale = function(settings) {
*/
v8Locale.prototype.derive = function(settings) {
return new v8Locale(
v8Locale.__createSettingsOrDefault(settings, this.options));
v8Locale.createSettingsOrDefault_(settings, this.options));
};
/**
@ -79,9 +79,9 @@ v8Locale.prototype.derive = function(settings) {
v8Locale.v8BreakIterator = function(locale, type) {
native function NativeJSBreakIterator();
locale = v8Locale.__createLocaleOrDefault(locale);
locale = v8Locale.createLocaleOrDefault_(locale);
// BCP47 ID would work in this case, but we use ICU locale for consistency.
var iterator = NativeJSBreakIterator(locale.__icuLocaleID, type);
var iterator = NativeJSBreakIterator(locale.__icuLocaleID__, type);
iterator.type = type;
return iterator;
};
@ -122,102 +122,21 @@ v8Locale.prototype.v8CreateBreakIterator = function(type) {
v8Locale.Collator = function(locale, settings) {
native function NativeJSCollator();
locale = v8Locale.__createLocaleOrDefault(locale);
locale = v8Locale.createLocaleOrDefault_(locale);
var collator = NativeJSCollator(
locale.__icuLocaleID, v8Locale.__createSettingsOrDefault(settings, {}));
locale.__icuLocaleID__, v8Locale.createSettingsOrDefault_(settings, {}));
return collator;
};
/**
* Creates new Collator based on current locale.
* @param {Object} - collation flags. See constructor.
* @returns {Object} - new Collator object.
* @returns {Object} - new v8BreakIterator object.
*/
v8Locale.prototype.createCollator = function(settings) {
return new v8Locale.Collator(this, settings);
};
/**
* DateTimeFormat class implements locale-aware date and time formatting.
* Constructor is not part of public API.
* @param {Object} locale - locale object to pass to formatter.
* @param {Object} settings - formatting flags:
* - skeleton
* - dateType
* - timeType
* - calendar
* @constructor
*/
v8Locale.__DateTimeFormat = function(locale, settings) {
native function NativeJSDateTimeFormat();
settings = v8Locale.__createSettingsOrDefault(settings, {});
var cleanSettings = {};
if (settings.hasOwnProperty('skeleton')) {
cleanSettings['skeleton'] = settings['skeleton'];
} else {
cleanSettings = {};
if (settings.hasOwnProperty('dateType')) {
var dt = settings['dateType'];
if (!/^short|medium|long|full$/.test(dt)) dt = 'short';
cleanSettings['dateType'] = dt;
}
if (settings.hasOwnProperty('timeType')) {
var tt = settings['timeType'];
if (!/^short|medium|long|full$/.test(tt)) tt = 'short';
cleanSettings['timeType'] = tt;
}
}
// Default is to show short date and time.
if (!cleanSettings.hasOwnProperty('skeleton') &&
!cleanSettings.hasOwnProperty('dateType') &&
!cleanSettings.hasOwnProperty('timeType')) {
cleanSettings = {'dateType': 'short',
'timeType': 'short'};
}
locale = v8Locale.__createLocaleOrDefault(locale);
var formatter = NativeJSDateTimeFormat(locale.__icuLocaleID, cleanSettings);
// NativeJSDateTimeFormat creates formatter.options for us, we just need
// to append actual settings to it.
for (key in cleanSettings) {
formatter.options[key] = cleanSettings[key];
}
/**
* Clones existing date time format with possible overrides for some
* of the options.
* @param {!Object} overrideSettings - overrides for current format settings.
* @returns {Object} - new DateTimeFormat object.
*/
formatter.derive = function(overrideSettings) {
// To remove a setting user can specify undefined as its value. We'll remove
// it from the map in that case.
for (var prop in overrideSettings) {
if (settings.hasOwnProperty(prop) && !overrideSettings[prop]) {
delete settings[prop];
}
}
return new v8Locale.__DateTimeFormat(
locale, v8Locale.__createSettingsOrDefault(overrideSettings, settings));
};
return formatter;
};
/**
* Creates new DateTimeFormat based on current locale.
* @param {Object} - formatting flags. See constructor.
* @returns {Object} - new DateTimeFormat object.
*/
v8Locale.prototype.createDateTimeFormat = function(settings) {
return new v8Locale.__DateTimeFormat(this, settings);
};
/**
* Merges user settings and defaults.
* Settings that are not of object type are rejected.
@ -227,7 +146,7 @@ v8Locale.prototype.createDateTimeFormat = function(settings) {
* @param {!Object} defaults - default values for this type of settings.
* @returns {Object} - valid settings object.
*/
v8Locale.__createSettingsOrDefault = function(settings, defaults) {
v8Locale.createSettingsOrDefault_ = function(settings, defaults) {
if (!settings || typeof(settings) !== 'object' ) {
return defaults;
}
@ -236,17 +155,11 @@ v8Locale.__createSettingsOrDefault = function(settings, defaults) {
settings[key] = defaults[key];
}
}
// Clean up settings.
// Clean up values, like trimming whitespace.
for (var key in settings) {
// Trim whitespace.
if (typeof(settings[key]) === "string") {
settings[key] = settings[key].trim();
}
// Remove all properties that are set to undefined/null. This allows
// derive method to remove a setting we don't need anymore.
if (!settings[key]) {
delete settings[key];
}
}
return settings;
@ -258,7 +171,7 @@ v8Locale.__createSettingsOrDefault = function(settings, defaults) {
* @param {!Object} locale - user provided locale.
* @returns {Object} - v8Locale object.
*/
v8Locale.__createLocaleOrDefault = function(locale) {
v8Locale.createLocaleOrDefault_ = function(locale) {
if (!locale || !(locale instanceof v8Locale)) {
return new v8Locale();
} else {