Module: Locale

Includes:
Util::Memoizable
Defined in:
lib/locale.rb,
lib/locale/tag.rb,
lib/locale/driver.rb,
lib/locale/tag/rfc.rb,
lib/locale/taglist.rb,
lib/locale/version.rb,
lib/locale/tag/cldr.rb,
lib/locale/tag/posix.rb,
lib/locale/driver/cgi.rb,
lib/locale/driver/env.rb,
lib/locale/middleware.rb,
lib/locale/tag/common.rb,
lib/locale/tag/simple.rb,
lib/locale/info/region.rb,
lib/locale/driver/jruby.rb,
lib/locale/driver/posix.rb,
lib/locale/driver/win32.rb,
lib/locale/info/language.rb,
lib/locale/tag/irregular.rb,
lib/locale/util/memoizable.rb,
lib/locale/driver/win32_table.rb

Overview

win32_table.rb - Locale table for win32

Copyright (C) 2008 Masao Mutoh <mutomasa at gmail.com>

You may redistribute it and/or modify it under the same
license terms as Ruby.

Original: Ruby-GetText-Package-1.92.0.

$Id: win32_table.rb 27 2008-12-03 15:06:50Z mutoh $

Defined Under Namespace

Modules: Driver, Info, Tag, Util Classes: Middleware, TagList

Constant Summary collapse

DEFAULT_LANGUAGE_TAG =

:nodoc:

Locale::Tag::Simple.new("en")
VERSION = 
"2.0.8"
@@default_tag = 
nil
@@driver_name = 
nil
@@app_language_tags = 
nil

Constants included from Util::Memoizable

Util::Memoizable::MEMOIZED_IVAR

Class Method Summary collapse

Methods included from Util::Memoizable

#_memoize, #_memoize_dup, #freeze, #freeze_without_memoizable, #memoize, #memoize_clear, #memoize_dup, #memoize_impl

Class Method Details

.app_language_tags ⇒ Object

Returns the app_language_tags. Default is nil. See set_app_language_tags for more details.



331
332
333
 
# File 'lib/locale.rb', line 331

def app_language_tags
  @@app_language_tags
end

.candidates(options = {}) ⇒ Object

Returns the language tags which are variations of the current locales order by priority.

For example, if the current locales are [“fr”, “ja_JP”, “en_US”, “en-Latn-GB-VARIANT”], then returns [“fr”, “ja_JP”, “en_US”, “en-Latn-GB-VARIANT”, “en_Latn_GB”, “en_GB”, “ja”, “en”]. “en” is the default locale(You can change it using set_default). The default locale is added at the end of the list even if it isn’t exist.

Usually, this method is used to find the locale data as the path(or a kind of IDs).

  • options: options as a Hash or nil.

    • :supported_language_tags - An Array of the language tags order by the priority. This option restricts the locales which are supported by the library/application. Default is nil if you don’t need to restrict the locales.

      (e.g.1) ["fr_FR", "en_GB", "en_US", ...]

    • :type - The type of language tag. :common, :rfc, :cldr, :posix and :simple are available. Default value is :common



215
216
217
218
219
220
221
222
223
224
225
226
227
228
 
# File 'lib/locale.rb', line 215

def candidates(options = {})
  opts = {:supported_language_tags => nil, :current => current,
    :type => :common}.merge(options)

  if Thread.current[:candidates_caches]
    cache = Thread.current[:candidates_caches][opts.hash]
    return cache if cache
  else
    Thread.current[:candidates_caches] = {} 
  end
  Thread.current[:candidates_caches][opts.hash] =
    collect_candidates(opts[:type], opts[:current],
                       opts[:supported_language_tags])
end

.cgi=(cgi) ⇒ Object

Sets a CGI object.This is the convenient function of set_request().

This method is appeared when Locale.init(:driver => :cgi) is called.

  • cgi: CGI object

  • Returns: cgi



146
147
148
149
 
# File 'lib/locale/driver/cgi.rb', line 146

def cgi=(cgi)
  set_cgi(cgi)
  cgi
end

.charset ⇒ Object

Gets the current charset.

This returns the current user/system charset. This value is read only, so you can’t set it by yourself.

  • Returns: the current charset.



276
277
278
 
# File 'lib/locale.rb', line 276

def charset
  driver_module.charset || "UTF-8"
end

.clear ⇒ Object

Clear current locale.

  • Returns: self



283
284
285
286
287
 
# File 'lib/locale.rb', line 283

def clear
  Thread.current[:current_languages] = nil
  Thread.current[:candidates_caches] = nil
  self
end

.clear_all ⇒ Object

Clear all locales and charsets of all threads. This doesn’t clear the default and app_language_tags. Use Locale.default = nil to unset the default locale.

  • Returns: self



293
294
295
296
297
298
299
300
 
# File 'lib/locale.rb', line 293

def clear_all
  Thread.list.each do |thread|
    thread[:current_languages] = nil
    thread[:candidates_caches] = nil
  end
  memoize_clear
  self
end

.collect_candidates(type, tags, supported_tags) ⇒ Object

collect tag candidates and memoize it. The result is shared from all threads.



232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
 
# File 'lib/locale.rb', line 232

def collect_candidates(type, tags, supported_tags) # :nodoc:
  candidate_tags = tags.collect{|v| v.send("to_#{type}").candidates}
  default_tags = default.send("to_#{type}").candidates
  if app_language_tags
    app_tags = app_language_tags.collect{|v| v.send("to_#{type}")}.flatten.uniq
  end
  if supported_tags
    supported_tags = supported_tags.collect{|v| Locale::Tag.parse(v).send("to_#{type}")}.flatten.uniq
  end

  tags = []
  unless candidate_tags.empty?
    (0...candidate_tags[0].size).each {|i|
      tags += candidate_tags.collect{|v| v[i]}
    }
  end
  tags += default_tags
  tags.uniq!

  all_tags = nil
  if app_tags
    if supported_tags
      all_tags = app_tags & supported_tags
    else
      all_tags = app_tags
    end
  elsif supported_tags
    all_tags = supported_tags
  end
  if all_tags
    tags &= all_tags
    tags = default_tags.uniq if tags.size == 0
  end

  Locale::TagList.new(tags)
end

.create_language_tag(tag) ⇒ Object

:nodoc:



36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/locale.rb', line 36

def create_language_tag(tag)  #:nodoc:
  case tag
  when nil
  when Locale::Tag::Simple
    tag
  when Locale::TagList
    tag[0]
  else
    Locale::Tag.parse(tag)
  end
end

.current ⇒ Object

Gets the current locales (Locale::Tag’s class). If the current locale is not set, this returns system/default locale.

This method returns the current language tags even if it isn’t included in app_language_tags.

Usually, the programs should use Locale.candidates to find the correct locale, not this method.

  • Returns: an Array of the current locales (Locale::Tag’s class).



180
181
182
183
184
185
186
 
# File 'lib/locale.rb', line 180

def current
  unless Thread.current[:current_languages]
    loc = driver_module.locales
    Thread.current[:current_languages] = loc ? loc : Locale::TagList.new([default])
  end
  Thread.current[:current_languages]
end

.current=(tag) ⇒ Object

Sets a current locale. This is a single argument version of Locale.set_current.

  • tag: the language tag such as “ja-JP”

  • Returns: an Array of the current locale (Locale::Tag’s class).

    Locale.current = "ja-JP"
Locale.current = "ja_JP.eucJP"



167
168
169
170
 
# File 'lib/locale.rb', line 167

def current=(tag)
  set_current(tag)
  Thread.current[:current_languages]
end

.default ⇒ Object

Gets the default locale(language tag).

If the default language tag is not set, this returns nil.

  • Returns: the default locale (Locale::Tag’s class).



124
125
126
 
# File 'lib/locale.rb', line 124

def default
  @@default_tag || DEFAULT_LANGUAGE_TAG
end

.default=(tag) ⇒ Object

Same as Locale.set_default.

  • locale: the default locale (Locale::Tag’s class) or a String such as “ja-JP”.

  • Returns: locale.



114
115
116
117
 
# File 'lib/locale.rb', line 114

def default=(tag)
  set_default(tag)
  @@default_tag
end

.driver_module ⇒ Object

Gets the driver module.

Usually you don’t need to call this method.

  • Returns: the driver module.



89
90
91
92
 
# File 'lib/locale.rb', line 89

def driver_module 
  Locale.init if @@driver_name.nil?
  Driver::MODULES[@@driver_name]
end

.get ⇒ Object

Deprecated.



189
190
191
 
# File 'lib/locale.rb', line 189

def get #:nodoc: 
  current
end

.init(opts = {}) ⇒ Object

Initialize Locale library. Usually, you don’t need to call this directly, because this is called when Locale’s methods are called.

If you use this library with CGI or the kind of CGI. You need to call Locale.init(:driver => :cgi).

For Framework designers/programers:

If your framework is for WWW, call this once like: Locale.init(:driver => :cgi).

To Application programers:

If your framework doesn’t use ruby-locale and the application is for WWW, call this once like: Locale.init(:driver => :cgi).

To Library authors:

Don’t call this, even if your application is only for WWW.

  • opts: Options as a Hash.

    • :driver - The driver. :cgi if you use Locale module with CGI, nil if you use system locale.

      (ex) Locale.init(:driver => :cgi)



70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/locale.rb', line 70

def init(opts = {})
  if opts[:driver]
    require_driver opts[:driver]
  else
    if /cygwin|mingw|win32/ =~ RUBY_PLATFORM
      require_driver 'win32' 
    elsif /java/ =~ RUBY_PLATFORM
      require_driver 'jruby' 
    else
      require_driver 'posix' 
    end
  end
end

.require_driver(name) ⇒ Object

:nodoc:



31
32
33
34
 
# File 'lib/locale.rb', line 31

def require_driver(name)  #:nodoc:
  require "locale/driver/#{name}"
  @@driver_name = name.to_sym
end

.set(tag) ⇒ Object

Deprecated.



194
195
196
 
# File 'lib/locale.rb', line 194

def set(tag)  #:nodoc:
  set_current(tag)
end

.set_app_language_tags(*tags) ⇒ Object

Set the language tags which is supported by the Application. This value is same with supported_language_tags in Locale.candidates to restrict the result but is the global setting. If you set a language tag, the application works as the single locale application.

If the current locale is not included in app_language_tags, Locale.default value is used. Use Locale.set_default() to set correct language if “en” is not included in the language tags.

Set nil if clear the value.

Note that the libraries/plugins shouldn’t set this value.

(e.g.) Locale.set_app_language_tags("fr_FR", "en-GB", "en_US", ...)



319
320
321
322
323
324
325
326
327
328
 
# File 'lib/locale.rb', line 319

def set_app_language_tags(*tags)
  if tags[0]
    @@app_language_tags = tags.collect{|v| Locale::Tag.parse(v)}
  else
    @@app_language_tags = nil
  end
  
  clear_all
  self
end

.set_cgi(cgi) ⇒ Object

Sets a CGI object. This is the convenient function of set_request().

This method is appeared when Locale.init(:driver => :cgi) is called.

  • cgi: CGI object

  • Returns: self



134
135
136
137
138
 
# File 'lib/locale/driver/cgi.rb', line 134

def set_cgi(cgi)
  set_request(cgi.params["lang"], cgi.cookies["lang"],
              cgi.accept_language, cgi.accept_charset)
  self
end

.set_current(*tags) ⇒ Object

Sets the locales of the current thread order by the priority. Each thread has a current locales. The system locale/default locale is used if the thread doesn’t have current locales.

  • tag: Locale::Language::Tag’s class or the language tag as a String. nil if you need to clear current locales.

  • charset: the charset (override the charset even if the locale name has charset) or nil.

  • Returns: self

(e.g.)

Locale.set_current("ja_JP.eucJP")
Locale.set_current("ja-JP")
Locale.set_current("en_AU", "en_US", ...)
Locale.set_current(Locale::Tag::Simple.new("ja", "JP"), ...)



142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/locale.rb', line 142

def set_current(*tags)
  languages = nil
  if tags[0]
    languages = Locale::TagList.new
    tags.each do |tag|
      case tag
      when Locale::TagList
        languages.concat(tag)
      else
        languages << create_language_tag(tag)
      end
    end
  end
  Thread.current[:current_languages] = languages
  Thread.current[:candidates_caches] = nil
  self
end

.set_default(tag) ⇒ Object

Sets the default locale as the language tag (Locale::Tag’s class or String(such as “ja_JP”)).

  • tag: the default language_tag

  • Returns: self.



101
102
103
104
105
106
107
108
 
# File 'lib/locale.rb', line 101

def set_default(tag)
  Thread.list.each do |thread|
    thread[:current_languages] = nil
    thread[:candidates_caches] = nil
  end
  @@default_tag = create_language_tag(tag)
  self
end

.set_request(query_langs, cookie_langs, accept_language, accept_charset) ⇒ Object

Sets a request values for lang/charset.

  • query_langs: An Array of QUERY_STRING value “lang”.

  • cookie_langs: An Array of cookie value “lang”.

  • accept_language: The value of HTTP_ACCEPT_LANGUAGE

  • accept_charset: The value of HTTP_ACCEPT_CHARSET



123
124
125
126
 
# File 'lib/locale/driver/cgi.rb', line 123

def set_request(query_langs, cookie_langs, accept_language, accept_charset)
  driver_module.set_request(query_langs, cookie_langs, accept_language, accept_charset)
  self
end