merb

see properly formatted ticket there: http://pastie.textmate.org/priva...

internationalization

=====================

Now:

when 2..44 then "#{distance_in_minutes} minutes"

when 45..89 then 'about 1 hour'

when 90..1439 then "about #{(distance_in_minutes.to_f / 60.0).round} hours"

when 1440..2879 then '1 day'

when 2880..43199 then "#{(distance_in_minutes / 1440).round} days"

when 43200..86399 then 'about 1 month'

when 86400..525599 then "#{(distance_in_minutes / 43200).round} months"

when 525600..1051199 then 'about 1 year'

else "over #{(distance_in_minutes / 525600).round} years"

The problem is that it can't be translated properly and only English is supported. To internationalize this piece of code, a plugin would need to overwrite the method which obviously will break if the original code is changed.

My goal is not to provide an official i18n solution but a easily solution for 3rd party developers to internationalize merb's components.

I18n solutions are usually based on a key, value solution. The i18n method usually lookups the translation in a dictionary/data store using the localization key and returns it.

For instance:

1. localization data store
2. English dictionary

:greetings => 'welcome'

1. Spanish dictionary

:greetings => 'hola'

1. internationalization

def greet_the_world

translate(:greetings, :language => 'es')

end

------------

Merb shouldn't include an i18n/l10n solution by default. However having a no op method would make things really easier for developers.

Something like that could work out:

@@merb_default_translations = {

:greetings => 'hello',

:about_1_hour => 'about 1 hour'

}

1. ==== Parameters
2. key:: translation key used to look up the string to return

#

1. ==== Options
2. optional, used by localization/internationalization plugins

#

1. ==== Returns
2. String:: translation

def translate(key, *options)

@@merb_default_translations[key]

end

The above solution works great until you actually need to use interpolation and pluralization. I'll skip pluralization for now but interpolation is a major problem. For instance how would you internationalize:

"about #{(distance_in_minutes.to_f / 60.0).round} hours ago"

Because we need to look up the translation we have to use a key, but keys are not dynamic and the amount of hours is. The usual solution is to pass the arguments to use in the translation as params.

translate(:about_x_hours_ago, {:hours => (distance_in_minutes.to_f / 60.0).round})

In your data store, the translation will be stored as:

:about_x_hours => "about {{hours}} hours ago"

An interpolation needs to happen so {{hours}} can be replaced by the correct/dynamic amount.

Note that we could have also passed only the needed param, but that would cause issues when you have multiple params. Here is an example:

:user_notice_email_received => "Hi {{first_name}} {{last_name}}, you have {{email_count}} emails"

If you were using an Asian translation, you would more than likely switch first_name and last_name, without using specific identifiers, the translator couldn't switch interpolations.

Potential solution:

@@merb_default_translations = {

:greetings => 'hello',

:about_x_hours => "about {{hours}} hours ago",

:user_notice_email_received => "Hi {{first_name}} {{last_name}}, you have {{email_count}} emails"

}

1. ==== Parameters
2. key:: translation key used to look up the string to return

#

1. ==== Options
2. values a hash defining values used for interpolation
3. optional, used by localization/internationalization plugins

#

1. ==== Returns
2. String:: translation

def translate(key, *options)

translation = merb_default_translations[key]

if options[:values]

interpolate_string(translation.dup, options[:values].dup)

else

translation

end

end

def interpolate_string(string, args={})

if args.length > 0

args.each do |arg|

string = string.gsub("{{#{arg[0].to_s}}}", arg[1].to_s)

end

end

string

end