Module: When::Parts::Locale

Included in:
BasicTypes::M17n
Defined in:
lib/when_exe/parts/locale.rb

Overview

Multilingualization(M17n) 対応モジュール

When::BasicTypes::M17n の実装のうち When::BasicTypes 内部で
定義すべきでない部分を切り出してモジュールとしている

Constant Summary collapse

Alias =

Locale 読み替えの初期設定

{'alias'=>'ja', '日本語'=>'ja', '英語'=>'en'}
DefaultUnification =

漢字の包摂

{
  '煕' => '熙',
  '廣' => '広',
  '寶' => '宝',
  '國' => '国',
  '應' => '応',
  '觀' => '観',
  '龜' => '亀',
  '齊' => '斉',
  '靈' => '霊',
  '攝' => '摂',
  '壽' => '寿',
  '萬' => '万',
  '廢' => '廃',
  '顯' => '顕',
  '會' => '会',
  '聰' => '聡',
  '總' => '総',
  '證' => '証',
  '禮' => '礼',
  '竜' => '龍',
}
Escape = 
'__!_ESCAPE_%2C_!__'

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#keys ⇒ Array<String> (readonly)

有効なローケール指定

Returns:



214
215
216
 
# File 'lib/when_exe/parts/locale.rb', line 214

def keys
  @keys
end

#link ⇒ Hash (readonly)

文字列の説明 - additional attribute

Returns:

  • (Hash) —

    { anyURI }



224
225
226
 
# File 'lib/when_exe/parts/locale.rb', line 224

def link
  @link
end

#names ⇒ Hash (readonly)

ローケール指定時の文字列

Returns:

  • (Hash) 


209
210
211
 
# File 'lib/when_exe/parts/locale.rb', line 209

def names
  @names
end

#values ⇒ Array<String> (readonly)

有効な文字列 - additional attribute

Returns:



219
220
221
 
# File 'lib/when_exe/parts/locale.rb', line 219

def values
  @values
end

Class Method Details

._hash_value(hash, locale, default = '') ⇒ Object

locale 指定を解析して Hash の値を取り出す



190
191
192
193
194
195
196
197
 
# File 'lib/when_exe/parts/locale.rb', line 190

def _hash_value(hash, locale, default='')
  locale = locale.sub(/\..*/, '').sub(/-/,'_')
  return hash[locale] if (hash[locale])
  return _hash_value(hash, _alias[locale], default) if (_alias[locale])
  language = locale.sub(/_.*/, '')
  return hash[language] if (hash[language])
  return hash[default]
end

._locale(source = nil) ⇒ Object

locale 指定を Array に変換する



143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/when_exe/parts/locale.rb', line 143

def _locale(source=nil)
  # default の Locale
  return [[nil, '', nil]] unless source

  # source の配列化
  if source.kind_of?(String)
    source = $1 if (source=~/\A\s*\[?(.+?)\]?\s*\z/m)
    source = source.split(/[\n\r,]+/)
  end

  # 各Localeの展開
  source.map {|v|
    if v.kind_of?(String)
      v = v.strip
      next if (v=~/^#/)
      (v =~ /^(\*)?(.*?)(?:\s*=\s*(.+))?$/) ? $~[1..3] : [[nil, '', nil]]
    else
      v
    end
  }.compact
end

._namespace(source = nil) ⇒ Object

文字列で表現された namespace 指定を Hash に変換する



123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/when_exe/parts/locale.rb', line 123

def _namespace(source=nil)
  case source
  when Hash ; return source
  when nil  ; return {}
  when String
    namespace = {}
    source = $1 if (source=~/\A\s*\[?(.+?)\]?\s*\z/m)
    source.split(/[\n\r,]+/).each do |v|
      v.strip!
      next if (v=~/^#/)
      pair = [''] + v.split(/\s*=\s*/, 2)
      namespace[pair[-2]] = pair[-1]
    end
    return namespace
  else ; raise TypeError, "Irregal Namespace Type"
  end
end

._setup_(aliases = nil) ⇒ Object

When::Parts::Locale Module のグローバルな設定を行う

Parameters:

  • aliases (Hash) (defaults to: nil) —

    Locale の読み替えパターンを Hash で指定する。 aliases の指定がない場合、aliases は Alias(モジュール定数)と解釈する。



59
60
61
 
# File 'lib/when_exe/parts/locale.rb', line 59

def _setup_(aliases=nil)
  @aliases = aliases || Alias
end

._split(line) ⇒ Object

文字列 [.., .., ..] を分割する



167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/when_exe/parts/locale.rb', line 167

def _split(line)
  line  = line.dup
  b = d = s = 0
  (line.length-1).downto(0) do |i|
    bs = 0
    (i-1).downto(0) do |k|
      break unless (line[k,1] == '\\')
      bs += 1
    end
    next if (bs[0] == 1)
    case line[i,1]
    when "'" ; s  = 1-s  if (d == 0)
    when '"' ; d  = 1-d  if (s == 0)
    when ']' ; b += 1 if  (d+s == 0)
    when '[' ; b -= 1 if  (d+s == 0 && b > 0)
    when ',' ; line[i,1] = Escape if (b+d+s == 0)
    end
  end
  return (line =='') ? [''] : line.split(Escape, -1)
end

.ideographic_unification(source, pattern = DefaultUnification) ⇒ When::Parts::Locale, ...

包摂リストに登録されている文字を包摂する

Parameters:

  • source (When::Parts::Locale) —

    文字を包摂しようとする国際化文字列

  • source (String) —

    文字を包摂しようとする文字列

  • source (Regexp) —

    文字を包摂しようとする正規表現

  • pattern (Hash) (defaults to: DefaultUnification) —

    包摂ルール

Returns:

  • (When::Parts::Locale) —

    文字を包摂した国際化文字列

  • (String) —

    文字を包摂した文字列

  • (Regexp) —

    文字を包摂した正規表現



106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/when_exe/parts/locale.rb', line 106

def ideographic_unification(source, pattern=DefaultUnification)
  case source
  when When::Parts::Locale
    source.ideographic_unification(pattern)
  when Regexp
    Regexp.compile(ideographic_unification(source.source.encode('UTF-8'), pattern), source.options)
  when String
    source.gsub(/./) do |c|
      pattern[c] ? pattern[c] : c
    end
  else
    source
  end
end

.translate(source, loc = '') ⇒ String

Note:

source が Hash や Array の場合、その構成要素を変換して返す

特定 locale に対応した文字列の取得

@param loc locale の指定 ( langcountry.encode )

[ lang    - 言語               ]
[ country - 国(省略可)         ]
[ encode  - 文字コード(省略可) ]

Parameters:

  • source (String) —

    もとにする String または M17n

Returns:

  • (String) —

    loc に対応した文字列



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/when_exe/parts/locale.rb', line 76

def translate(source, loc='')
  return source unless loc
  case source
  when Hash
    result = {}
    source.each_pair do |key, value|
      result[translate(key, loc)] = translate(value, loc)
    end
    return result
  when Array
    return source.map {|value| translate(value, loc)}
  when Locale
    return source.translate(loc)
  when String
    return source.encode($1) if loc =~ /\.(.+)$/
  end
  source
end

Instance Method Details

#+(other) ⇒ When::Toos::Locale

文字列の連結

Parameters:

  • other (String, When::Toos::Locale) —

    連結する文字列

Returns:

  • (When::Toos::Locale) —

    連結された文字列



298
299
300
301
302
303
304
305
306
307
308
309
310
311
 
# File 'lib/when_exe/parts/locale.rb', line 298

def +(other)
  names = {}
  case other
  when Locale
    (@names.keys + other.names.keys).uniq.each do |key|
      names[key] = _label_value(key) + other._label_value(key)
    end
  else
    @names.keys.each do |key|
      names[key] = _label_value(key) + other.to_s
    end
  end
  return dup._copy({:names=>names, :label=>to_s + other.to_s})
end

#=~(regexp) ⇒ Integer?

文字列の一致

Parameters:

Returns:

  • (Integer) —

    マッチした位置のindex(いずれかの locale でマッチが成功した場合)

  • (nil) —

    すべての locale でマッチに失敗した場合



284
285
286
287
288
289
290
 
# File 'lib/when_exe/parts/locale.rb', line 284

def =~(regexp)
  @keys.each do |key|
    index = (@names[key] =~ regexp)
    return index if index
  end
  return nil
end

#[](range) ⇒ When::Parts::Locale

部分文字列

Parameters:

  • range (Range) —

    String#[] と同様の指定方法で範囲を指定する

Returns:



267
268
269
270
271
272
273
274
275
 
# File 'lib/when_exe/parts/locale.rb', line 267

def [](range)
  dup._copy({
    :label => to_s[range],
    :names => @names.keys.inject({}) {|l,k|
      l[k] =  @names[k][range]
      l
    }
  })
end

#_printf(other, locale = nil) ⇒ When::Toos::Locale Also known as: %

書式指定による文字列化

Parameters:

  • other (Array<Object>) —

    文字列化する Object の Array

  • locale (Array<String>) (defaults to: nil) —

    文字列化を行う locale の指定(デフォルト : すべて)

Returns:

  • (When::Toos::Locale) —

    文字列化された Object



320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
 
# File 'lib/when_exe/parts/locale.rb', line 320

def _printf(other, locale=nil)
  # 処理する配列
  terms = other.kind_of?(Array) ? [self] + other : [self, other]

  # locale key の配列
  if locale == []
    keys = []
  else
    keys = terms.inject([]) {|k,t|
      k += t.keys if t.kind_of?(Locale)
      k
    }.uniq
    if locale
      locale = [locale] unless locale.kind_of?(Array)
      keys   = locale | (locale & keys)
    end
  end
  keys << nil if keys.include?('')

  # names ハッシュ
  names = keys.inject({}) {|l,k|
    l[k] = When::Coordinates::Pair._format(
             (block_given? ? yield(k, *terms) : terms).map {|t|
               t.kind_of?(Locale) ? t.translate(k) : t
             }
           )
    l
  }

  # 生成
  # @private
  dup._copy({
    :label => keys.include?('') ? names.delete(nil) : (names[''] = names[keys[0]]),
    :names => names
  })
end

#ideographic_unification(pattern = DefaultUnification) ⇒ When::Parts::Locale

包摂リストに登録されている文字を包摂する(自己保存)

Parameters:

  • pattern (Hash) (defaults to: DefaultUnification) —

    包摂ルール

Returns:



406
407
408
 
# File 'lib/when_exe/parts/locale.rb', line 406

def ideographic_unification(pattern=DefaultUnification)
  dup.ideographic_unification!(pattern)
end

#prefix(other, locale = nil) ⇒ Object

閏の表記を扱うための書式付整形



412
413
414
415
416
417
418
419
420
 
# File 'lib/when_exe/parts/locale.rb', line 412

def prefix(other, locale=nil)
  return self.dup unless other
  other = m17n(other) unless other.kind_of?(Locale)
  other._printf(self, locale) do |k, *t|
    t[0]  = t[0].translate(k)
    t[0] += "%s" unless t[0] =~ /%[-+]?[.\d]*s/
    t
  end
end

#reference(loc = '') ⇒ String

特定 locale に対応した reference URI の取得

Parameters:

  • loc (String) (defaults to: '') —

    locale の指定

Returns:

  • (String) —

    loc に対応した reference URI



256
257
258
259
 
# File 'lib/when_exe/parts/locale.rb', line 256

def reference(loc='')
  loc ||= ''
  return Locale._hash_value(@link, loc)
end

#translate(loc = '') ⇒ String Also known as: /

特定 locale に対応した文字列の取得

Parameters:

  • loc (String) (defaults to: '') —

    locale の指定 ( langcountry.encode )

    lang - 言語
    country - 国(省略可)
    encode - 文字コード(省略可)

Returns:

  • (String) —

    loc に対応した文字列



241
242
243
244
245
246
247
 
# File 'lib/when_exe/parts/locale.rb', line 241

def translate(loc='')
  return to_s unless loc
  lang, code = loc.split(/\./)
  result = _label_value(loc)
  return result if !code || @names.member?(loc)
  return result.encode(code)
end

#update(options = {}) ⇒ self

Note:

Hashキーはすべて Optional で、存在するもののみ更新します

ローケールの更新

Parameters:

  • options (Hash) (defaults to: {}) —

    下記の通り

Options Hash (options):

  • カントリーコード (String) —

    表現文字列

  • :link (Hash) —

    { カントリーコード => 参照URL文字列 }

  • :code_space (String) —

    規格や辞書を特定するコードスペースのURL文字列

  • :label (String) —

    代表文字列

Returns:

  • (self) —

    更新された Object



369
370
371
372
373
374
375
376
377
378
379
380
 
# File 'lib/when_exe/parts/locale.rb', line 369

def update(options={})
  options = options.dup
  @link.update(options.delete(:link))       if (options.key?(:link))
  @code_space = options.delete(:code_space) if (options.key?(:code_space))
  self[0..-1] = options.delete(:label)      if (options.key?(:label))
  unless (options.empty?)
    @names.update(options)
    @keys     = @names.keys.sort
    @values   = @names.values.sort.reverse
  end
  return self
end