gloc.rb
300 lines
| 10.4 KiB
| text/x-ruby
|
RubyLexer
|
r10 | # Copyright (c) 2005-2006 David Barri | ||
require 'yaml' | ||||
require 'gloc-internal' | ||||
require 'gloc-helpers' | ||||
module GLoc | ||||
UTF_8= 'utf-8' | ||||
SHIFT_JIS= 'sjis' | ||||
EUC_JP= 'euc-jp' | ||||
# This module will be included in both instances and classes of GLoc includees. | ||||
# It is also included as class methods in the GLoc module itself. | ||||
module InstanceMethods | ||||
include Helpers | ||||
# Returns a localized string. | ||||
def l(symbol, *arguments) | ||||
return GLoc._l(symbol,current_language,*arguments) | ||||
end | ||||
# Returns a localized string in a specified language. | ||||
# This does not effect <tt>current_language</tt>. | ||||
def ll(lang, symbol, *arguments) | ||||
return GLoc._l(symbol,lang.to_sym,*arguments) | ||||
end | ||||
# Returns a localized string if the argument is a Symbol, else just returns the argument. | ||||
def ltry(possible_key) | ||||
possible_key.is_a?(Symbol) ? l(possible_key) : possible_key | ||||
end | ||||
# Uses the default GLoc rule to return a localized string. | ||||
# See lwr_() for more info. | ||||
def lwr(symbol, *arguments) | ||||
lwr_(:default, symbol, *arguments) | ||||
end | ||||
# Uses a <em>rule</em> to return a localized string. | ||||
# A rule is a function that uses specified arguments to return a localization key prefix. | ||||
# The prefix is appended to the localization key originally specified, to create a new key which | ||||
# is then used to lookup a localized string. | ||||
def lwr_(rule, symbol, *arguments) | ||||
GLoc._l("#{symbol}#{GLoc::_l_rule(rule,current_language).call(*arguments)}",current_language,*arguments) | ||||
end | ||||
# Returns <tt>true</tt> if a localized string with the specified key exists. | ||||
def l_has_string?(symbol) | ||||
return GLoc._l_has_string?(symbol,current_language) | ||||
end | ||||
# Sets the current language for this instance/class. | ||||
# Setting the language of a class effects all instances unless the instance has its own language defined. | ||||
def set_language(language) | ||||
|
r1955 | GLoc.current_language = language | ||
|
r10 | end | ||
# Sets the current language if the language passed is a valid language. | ||||
# If the language was valid, this method returns <tt>true</tt> else it will return <tt>false</tt>. | ||||
# Note that <tt>nil</tt> is not a valid language. | ||||
# See set_language(language) for more info. | ||||
def set_language_if_valid(language) | ||||
if GLoc.valid_language?(language) | ||||
set_language(language) | ||||
true | ||||
else | ||||
false | ||||
end | ||||
end | ||||
end | ||||
#--------------------------------------------------------------------------- | ||||
# Instance | ||||
include ::GLoc::InstanceMethods | ||||
# Returns the instance-level current language, or if not set, returns the class-level current language. | ||||
def current_language | ||||
|
r1955 | GLoc.current_language | ||
|
r10 | end | ||
#--------------------------------------------------------------------------- | ||||
# Class | ||||
# All classes/modules that include GLoc will also gain these class methods. | ||||
# Notice that the GLoc::InstanceMethods module is also included. | ||||
module ClassMethods | ||||
include ::GLoc::InstanceMethods | ||||
# Returns the current language, or if not set, returns the GLoc current language. | ||||
def current_language | ||||
|
r1955 | GLoc.current_language | ||
|
r10 | end | ||
end | ||||
def self.included(target) #:nodoc: | ||||
super | ||||
class << target | ||||
include ::GLoc::ClassMethods | ||||
end | ||||
end | ||||
#--------------------------------------------------------------------------- | ||||
# GLoc module | ||||
class << self | ||||
include ::GLoc::InstanceMethods | ||||
|
r1955 | |||
@@current_language = nil | ||||
|
r10 | |||
|
r1955 | # Returns the current language | ||
|
r10 | def current_language | ||
|
r1955 | @@current_language || GLoc::CONFIG[:default_language] | ||
end | ||||
def current_language=(lang) | ||||
@@current_language = lang.blank? ? nil : lang.to_sym | ||||
|
r10 | end | ||
# Adds a collection of localized strings to the in-memory string store. | ||||
def add_localized_strings(lang, symbol_hash, override=true, strings_charset=nil) | ||||
_verbose_msg {"Adding #{symbol_hash.size} #{lang} strings."} | ||||
_add_localized_strings(lang, symbol_hash, override, strings_charset) | ||||
_verbose_msg :stats | ||||
end | ||||
# Creates a backup of the internal state of GLoc (ie. strings, langs, rules, config) | ||||
# and optionally clears everything. | ||||
def backup_state(clear=false) | ||||
s= _get_internal_state_vars.map{|o| o.clone} | ||||
_get_internal_state_vars.each{|o| o.clear} if clear | ||||
s | ||||
end | ||||
# Removes all localized strings from memory, either of a certain language (or languages), | ||||
# or entirely. | ||||
def clear_strings(*languages) | ||||
if languages.empty? | ||||
_verbose_msg {"Clearing all strings"} | ||||
LOCALIZED_STRINGS.clear | ||||
LOWERCASE_LANGUAGES.clear | ||||
else | ||||
languages.each {|l| | ||||
_verbose_msg {"Clearing :#{l} strings"} | ||||
l= l.to_sym | ||||
LOCALIZED_STRINGS.delete l | ||||
LOWERCASE_LANGUAGES.each_pair {|k,v| LOWERCASE_LANGUAGES.delete k if v == l} | ||||
} | ||||
end | ||||
end | ||||
alias :_clear_strings :clear_strings | ||||
# Removes all localized strings from memory, except for those of certain specified languages. | ||||
def clear_strings_except(*languages) | ||||
clear= (LOCALIZED_STRINGS.keys - languages) | ||||
_clear_strings(*clear) unless clear.empty? | ||||
end | ||||
# Returns the charset used to store localized strings in memory. | ||||
def get_charset(lang) | ||||
CONFIG[:internal_charset_per_lang][lang] || CONFIG[:internal_charset] | ||||
end | ||||
# Returns a GLoc configuration value. | ||||
def get_config(key) | ||||
CONFIG[key] | ||||
end | ||||
# Loads the localized strings that are included in the GLoc library. | ||||
def load_gloc_default_localized_strings(override=false) | ||||
GLoc.load_localized_strings "#{File.dirname(__FILE__)}/../lang", override | ||||
end | ||||
# Loads localized strings from all yml files in the specifed directory. | ||||
def load_localized_strings(dir=nil, override=true) | ||||
_charset_required | ||||
_get_lang_file_list(dir).each {|filename| | ||||
# Load file | ||||
raw_hash = YAML::load(File.read(filename)) | ||||
raw_hash={} unless raw_hash.kind_of?(Hash) | ||||
filename =~ /([^\/\\]+)\.ya?ml$/ | ||||
lang = $1.to_sym | ||||
file_charset = raw_hash['file_charset'] || UTF_8 | ||||
# Convert string keys to symbols | ||||
dest_charset= get_charset(lang) | ||||
_verbose_msg {"Reading file #{filename} [charset: #{file_charset} --> #{dest_charset}]"} | ||||
symbol_hash = {} | ||||
Iconv.open(dest_charset, file_charset) do |i| | ||||
raw_hash.each {|key, value| | ||||
symbol_hash[key.to_sym] = i.iconv(value) | ||||
} | ||||
end | ||||
# Add strings to repos | ||||
_add_localized_strings(lang, symbol_hash, override) | ||||
} | ||||
_verbose_msg :stats | ||||
end | ||||
# Restores a backup of GLoc's internal state that was made with backup_state. | ||||
def restore_state(state) | ||||
_get_internal_state_vars.each do |o| | ||||
o.clear | ||||
o.send o.respond_to?(:merge!) ? :merge! : :concat, state.shift | ||||
end | ||||
end | ||||
# Sets the charset used to internally store localized strings. | ||||
# You can set the charset to use for a specific language or languages, | ||||
# or if none are specified the charset for ALL localized strings will be set. | ||||
def set_charset(new_charset, *langs) | ||||
CONFIG[:internal_charset_per_lang] ||= {} | ||||
# Convert symbol shortcuts | ||||
if new_charset.is_a?(Symbol) | ||||
new_charset= case new_charset | ||||
when :utf8, :utf_8 then UTF_8 | ||||
when :sjis, :shift_jis, :shiftjis then SHIFT_JIS | ||||
when :eucjp, :euc_jp then EUC_JP | ||||
else new_charset.to_s | ||||
end | ||||
end | ||||
# Convert existing strings | ||||
(langs.empty? ? LOCALIZED_STRINGS.keys : langs).each do |lang| | ||||
cur_charset= get_charset(lang) | ||||
if cur_charset && new_charset != cur_charset | ||||
_verbose_msg {"Converting :#{lang} strings from #{cur_charset} to #{new_charset}"} | ||||
Iconv.open(new_charset, cur_charset) do |i| | ||||
bundle= LOCALIZED_STRINGS[lang] | ||||
bundle.each_pair {|k,v| bundle[k]= i.iconv(v)} | ||||
end | ||||
end | ||||
end | ||||
# Set new charset value | ||||
if langs.empty? | ||||
_verbose_msg {"Setting GLoc charset for all languages to #{new_charset}"} | ||||
CONFIG[:internal_charset]= new_charset | ||||
CONFIG[:internal_charset_per_lang].clear | ||||
else | ||||
langs.each do |lang| | ||||
_verbose_msg {"Setting GLoc charset for :#{lang} strings to #{new_charset}"} | ||||
CONFIG[:internal_charset_per_lang][lang]= new_charset | ||||
end | ||||
end | ||||
end | ||||
# Sets GLoc configuration values. | ||||
def set_config(hash) | ||||
CONFIG.merge! hash | ||||
end | ||||
# Sets the $KCODE global variable according to a specified charset, or else the | ||||
# current default charset for the default language. | ||||
def set_kcode(charset=nil) | ||||
_charset_required | ||||
charset ||= get_charset(current_language) | ||||
$KCODE= case charset | ||||
when UTF_8 then 'u' | ||||
when SHIFT_JIS then 's' | ||||
when EUC_JP then 'e' | ||||
else 'n' | ||||
end | ||||
_verbose_msg {"$KCODE set to #{$KCODE}"} | ||||
end | ||||
# Tries to find a valid language that is similar to the argument passed. | ||||
# Eg. :en, :en_au, :EN_US are all similar languages. | ||||
# Returns <tt>nil</tt> if no similar languages are found. | ||||
def similar_language(lang) | ||||
return nil if lang.nil? | ||||
return lang.to_sym if valid_language?(lang) | ||||
# Check lowercase without dashes | ||||
lang= lang.to_s.downcase.gsub('-','_') | ||||
return LOWERCASE_LANGUAGES[lang] if LOWERCASE_LANGUAGES.has_key?(lang) | ||||
# Check without dialect | ||||
if lang.to_s =~ /^([a-z]+?)[^a-z].*/ | ||||
lang= $1 | ||||
return LOWERCASE_LANGUAGES[lang] if LOWERCASE_LANGUAGES.has_key?(lang) | ||||
end | ||||
# Check other dialects | ||||
lang= "#{lang}_" | ||||
LOWERCASE_LANGUAGES.keys.each {|k| return LOWERCASE_LANGUAGES[k] if k.starts_with?(lang)} | ||||
# Nothing found | ||||
nil | ||||
end | ||||
# Returns an array of (currently) valid languages (ie. languages for which localized data exists). | ||||
def valid_languages | ||||
LOCALIZED_STRINGS.keys | ||||
end | ||||
# Returns <tt>true</tt> if there are any localized strings for a specified language. | ||||
# Note that although <tt>set_langauge nil</tt> is perfectly valid, <tt>nil</tt> is not a valid language. | ||||
def valid_language?(language) | ||||
LOCALIZED_STRINGS.has_key? language.to_sym rescue false | ||||
end | ||||
end | ||||
end | ||||