1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
# Some of the monkeypatches in this file should possibly be submitted
# as patches, but most are here because they should go away when we
# upgrade to Rails 3.x
# override behaviour in fast_gettext/translation.rb
# so that we can interpolate our translation strings nicely
# TODO: We could simplify a lot of this code (as in remove it) if we moved from using the {{value}}
# convention in the translation strings for interpolation to %{value}. This is apparently the newer
# convention.
def _(key, options = {})
translation = (FastGettext._(key) || key).html_safe
gettext_interpolate(translation, options)
end
def n_(*keys)
# The last parameter should be the values to do the interpolation with
if keys.count > 3
options = keys.pop
else
options = {}
end
translation = FastGettext.n_(*keys).html_safe
gettext_interpolate(translation, options)
end
MATCH = /\{\{([^\}]+)\}\}/
def gettext_interpolate(string, values)
return string unless string.is_a?(String)
# $1, $2 don't work with SafeBuffer so casting to string as workaround
safe = string.html_safe?
string = string.to_str.gsub(MATCH) do
pattern, key = $1, $1.to_sym
if !values.include?(key)
raise I18n::MissingInterpolationArgument.new(pattern, string)
else
v = values[key].to_s
if safe && !v.html_safe?
ERB::Util.h(v)
else
v
end
end
end
safe ? string.html_safe : string
end
module I18n
# used by Globalize plugin.
# XXX much of this stuff should (might?) be in newer versions of Rails
@@fallbacks = nil
class << self
# Returns the current fallbacks implementation. Defaults to +I18n::Locale::Fallbacks+.
def fallbacks
@@fallbacks ||= I18n::Locale::Fallbacks.new
end
end
module Locale
module Tag
class Simple
class << self
def tag(tag)
new(tag)
end
end
attr_reader :tag
def initialize(*tag)
@tag = tag.join('-').to_sym
end
def subtags
@subtags = tag.to_s.split('-').map { |subtag| subtag.to_s }
end
def to_sym
tag
end
def to_s
tag.to_s
end
def to_a
subtags
end
def parent
@parent ||= begin
segs = to_a.compact
segs.length > 1 ? self.class.tag(*segs[0..(segs.length-2)].join('-')) : nil
end
end
def self_and_parents
@self_and_parents ||= [self] + parents
end
def parents
@parents ||= ([parent] + (parent ? parent.parents : [])).compact
end
end
end
class Fallbacks < Hash
def initialize(*mappings)
@map = {}
map(mappings.pop) if mappings.last.is_a?(Hash)
self.defaults = mappings.empty? ? [I18n.default_locale.to_sym] : mappings
end
def defaults=(defaults)
@defaults = defaults.map { |default| compute(default, false) }.flatten
end
attr_reader :defaults
def [](locale)
raise InvalidLocale.new(locale) if locale.nil?
locale = locale.to_sym
super || store(locale, compute(locale))
end
def map(mappings)
mappings.each do |from, to|
from, to = from.to_sym, Array(to)
to.each do |_to|
@map[from] ||= []
@map[from] << _to.to_sym
end
end
end
protected
def compute(tags, include_defaults = true)
result = Array(tags).collect do |tag|
tags = I18n::Locale::Tag::Simple.tag(tag).self_and_parents.map! { |t| t.to_sym }
tags.each { |_tag| tags += compute(@map[_tag]) if @map[_tag] }
tags
end.flatten
result.push(*defaults) if include_defaults
result.uniq.compact
end
end
autoload :Fallbacks, 'i18n/locale/fallbacks'
end
end
# this monkeypatch corrects inconsistency with gettext_i18n_rails
# where the latter deals with strings but rails i18n deals with
# symbols for locales
module GettextI18nRails
class Backend
def available_locales
FastGettext.available_locales.map{|l| l.to_sym} || []
end
end
end
|
