experteer-gettext 2.0.4

data/lib/gettext/tools.rb

@@ -0,0 +1,195 @@
+=begin
+  tools.rb - Utility functions
+
+  Copyright (C) 2005-2008 Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+=end
+
+require 'rbconfig'
+if /mingw|mswin|mswin32/ =~ RUBY_PLATFORM
+  ENV['PATH'] = %w(bin lib).collect{|dir|
+    "#{Config::CONFIG["prefix"]}\\lib\\GTK\\#{dir};"
+  }.join('') + ENV['PATH']
+end
+
+require 'gettext/tools/rgettext'
+require 'gettext/tools/rmsgfmt'
+require 'gettext/mofile'
+require 'fileutils'
+
+module GetText
+  bindtextdomain "rgettext"
+
+  BOM_UTF8 = [0xef, 0xbb, 0xbf].pack("c3")
+
+  # Currently, GNU msgmerge doesn't accept BOM. 
+  # This mesthod remove the UTF-8 BOM from the po-file.
+  def remove_bom(path)  #:nodoc:
+    bom = IO.read(path, 3)
+    if bom == BOM_UTF8
+      data = IO.read(path)[3..-1]
+      File.open(path, "w") {|f| f.write(data)}
+    end
+  end
+
+  # Merges two Uniforum style .po files together. 
+  #
+  # *Note* This function requires "msgmerge" tool included in GNU GetText. So you need to install GNU GetText. 
+  #
+  # The def.po file is an existing PO file with translations which will be taken 
+  # over to the newly created file as long as they still match; comments will be preserved,
+  # but extracted comments and file positions will be discarded. 
+  #
+  # The ref.pot file is the last created PO file with up-to-date source references but
+  # old translations, or a PO Template file (generally created by rgettext);
+  # any translations or comments in the file will be discarded, however dot
+  # comments and file positions will be preserved.  Where an exact match
+  # cannot be found, fuzzy matching is used to produce better results.
+  #
+  # Usually you don't need to call this function directly. Use GetText.update_pofiles instead.
+  #
+  # * defpo: a po-file. translations referring to old sources
+  # * refpo: a po-file. references to new sources
+  # * app_version: the application information which appears "Project-Id-Version: #{app_version}" in the pot/po-files.
+  # * Returns: self 
+  def msgmerge(defpo, refpo, app_version, options={})
+    verbose = options.delete(:verbose)
+    puts "msgmerge called" if verbose
+    $stderr.print defpo + " "
+
+    content = merge_po_files(defpo,refpo,options.delete(:msgmerge),verbose)
+    
+    if content.empty?
+      # report failure
+      failed_filename = refpo + "~"
+      FileUtils.cp(refpo, failed_filename)
+      $stderr.puts _("Failed to merge with %{defpo}") % {:defpo => defpo}
+      $stderr.puts _("New .pot was copied to %{failed_filename}") %{:failed_filename => failed_filename}
+      raise _("Check these po/pot-files. It may have syntax errors or something wrong.")
+    else
+      # update version and save merged data
+      content.sub!(/(Project-Id-Version\:).*$/, "\\1 #{app_version}\\n\"")
+      File.open(defpo, "w") {|f|f.write(content)}
+    end
+    
+    self
+  end
+
+  # Creates mo-files using #{po_root}/#{lang}/*.po an put them to 
+  # #{targetdir}/#{targetdir_rule}/. 
+  #
+  # This is a convenience function of GetText.rmsgfmt for multiple target files.
+  # * options: options as a Hash.
+  #   * verbose: true if verbose mode, otherwise false
+  #   * po_root: the root directory of po-files.
+  #   * mo_root: the target root directory where the mo-files are stored.
+  #   * mo_path_rule: the target directory for each mo-files.
+  def create_mofiles(options = {})
+    options = {:po_root => "./po"}.merge(options)
+
+    Dir.glob(File.join(options[:po_root], "*/*.po")) do |po_file|
+      mo_file = mo_file_from_po_file(po_file,options)
+      $stderr.print %Q[#{po_file} -> #{mo_file} ... ] if options[:verbose]
+      FileUtils.mkdir_p(File.dirname(mo_file))
+      rmsgfmt(po_file, mo_file)
+      $stderr.puts "Done." if options[:verbose]
+    end
+  end
+
+
+  # At first, this creates the #{po_root}/#{domainname}.pot file using GetText.rgettext.
+  # In the second step, this updates(merges) the #{po_root}/#{domainname}.pot and all of the
+  # #{po_root}/#{lang}/#{domainname}.po files under "po_root" using "msgmerge". 
+  #
+  # *Note* "msgmerge" tool is included in GNU GetText. So you need to install GNU GetText. 
+  #
+  # See <HOWTO maintain po/mo files(http://www.yotabanana.com/hiki/ruby-gettext-howto-manage.html)> for more detals.
+  # * domainname: the textdomain name.
+  # * targetfiles: An Array of target files, that should be parsed for messages (See GetText.rgettext for more details).
+  # * app_version: the application information which appears "Project-Id-Version: #{app_version}" in the pot/po-files.
+  # * options: a hash with following possible settings
+  #     :lang    - update files only for one language - the language specified by this option
+  #     :po_root - the root directory of po-files
+  #     :msgmerge - an array with the options, passed through to the gnu msgmerge tool
+  #                 symbols are automatically translated to options with dashes,
+  #                 example: [:no_wrap, :no_fuzzy_matching, :sort_output] translated to '--no-fuzzy-matching --sort-output'
+  #     :verbose - true to show verbose messages. default is false.
+  #
+  # Example: GetText.update_pofiles("myapp", Dir.glob("lib/*.rb"), "myapp 1.0.0", :verbose => true)
+  def update_pofiles(textdomain, files, app_version, options = {})
+    puts options.inspect if options[:verbose]
+
+    #write found messages to tmp.pot
+    temp_pot = "tmp.pot"
+    rgettext(files, temp_pot)
+
+    #merge tmp.pot and existing pot
+    po_root = options.delete(:po_root) || "po"
+    FileUtils.mkdir_p(po_root)
+    msgmerge("#{po_root}/#{textdomain}.pot", temp_pot, app_version, options.dup)
+
+    #update local po-files
+    only_one_language = options.delete(:lang)
+    if only_one_language
+      msgmerge("#{po_root}/#{only_one_language}/#{textdomain}.po", temp_pot, app_version, options.dup)
+    else
+      Dir.glob("#{po_root}/*/#{textdomain}.po") do |po_file|
+        msgmerge(po_file, temp_pot, app_version, options.dup)
+      end
+    end
+
+    File.delete(temp_pot)
+  end
+
+  private
+
+  # Merge 2 po files, using msgmerge
+  def merge_po_files(po_a,po_b,msgmerge_options=[],verbose=false)
+    return File.read(po_b) unless FileTest.exist? po_a
+
+    cmd = ENV["MSGMERGE_PATH"] || "msgmerge"
+    ensure_command_exists(cmd)
+
+    remove_bom(po_a)
+
+    cmd_params = array_to_cli_options(msgmerge_options)
+    to_run = "#{cmd} #{cmd_params} #{po_a} #{po_b}"
+    puts "\nrunning #{to_run}" if verbose
+    `#{to_run}`
+  end
+
+  # convert an array of String/Symbol to cli options
+  def array_to_cli_options(array)
+    [*array].map do |o|
+      o.kind_of?(Symbol) ? "--#{o}".gsub('_','-') : o.to_s
+    end.join(' ')
+  end
+
+  def ensure_command_exists(cmd)
+    `#{cmd} --help`
+    unless $? && $?.success?
+      raise _("`%{cmd}' can not be found. \nInstall GNU Gettext then set PATH or MSGMERGE_PATH correctly.") % {:cmd => cmd}
+    end
+  end
+
+  # where lies the mo file for a given po_file
+  # generare directory unless it exists
+  def mo_file_from_po_file(po_file,options)
+    options = {
+      :mo_root => "./data/locale",
+      :mo_path_rule => "%{lang}/LC_MESSAGES"
+    }.merge(options)
+    
+    lang, textdomain = %r[/([^/]+?)/(.*)\.po].match(po_file[options[:po_root].size..-1]).to_a[1,2]
+
+    mo_dir_rule = File.join(options[:mo_root], options[:mo_path_rule])
+    mo_dir = mo_dir_rule % {:lang => lang}
+    File.join(mo_dir, "#{textdomain}.mo")
+  end
+end
+
+if __FILE__ == $0
+  GetText.update_pofiles("foo", ARGV, "foo 1.1.0")
+end

data/lib/gettext/translation_target.rb

@@ -0,0 +1,93 @@
+module GetText
+  class ParseError < StandardError
+  end
+
+  # Contains data related to the expression or sentence that 
+  # is to be translated (translation target).
+  # Implements a sort of state machine to assist the parser.
+  class TranslationTarget
+    attr_accessor :type, :msgid, :occurrences # obligatory attributes
+    attr_accessor :plural, :msgctxt, :extracted_comment # optional attributes
+
+    def initialize(new_type)
+      @type = new_type
+      @occurrences = Array.new
+      @param_number = 0
+    end
+
+    # Supports parsing by setting attributes by and by.
+    def set_current_attribute(str)
+      case @param_number 
+      when 0
+        set_string_value :msgid, str
+      when 1
+        case type
+        when :plural
+          set_string_value :plural, str
+        when :msgctxt, :msgctxt_plural
+          set_string_value :msgctxt, str
+        else
+          raise ParseError, 'no more string parameters expected'
+        end
+      when 2
+        if :msgctxt_plural
+          set_string_value plural, str
+        else
+          raise ParseError, 'no more string parameters expected'
+        end
+      end
+    end
+
+    def advance_to_next_attribute
+      @param_number += 1
+    end
+
+    # Support for extracted comments. Explanation s.
+    # http://www.gnu.org/software/gettext/manual/gettext.html#Names
+    def add_extracted_comment(new_comment)
+      @extracted_comment = @extracted_comment.to_s + new_comment
+      to_s
+    end
+
+    # Returns a parameter representation suitable for po-files
+    # and other purposes.
+    def escaped(param_name)
+      orig = self.send param_name
+      orig.gsub(/"/, '\"').gsub(/\r/, '')
+    end
+
+    # Checks if the other translation target is mergeable with
+    # the current one. Relevant are msgid and translation context (msgctxt).
+    def matches?(other)
+      other.msgid == self.msgid && other.msgctxt == self.msgctxt
+    end
+
+    # Merges two translation targets with the same msgid and returns the merged
+    # result. If one is declared as plural and the other not, then the one
+    # with the plural wins.
+    def merge(other)
+      return self if other.nil?
+      raise ParseError, "Translation targets do not match: \n" \
+      "  self: #{self.inspect}\n  other: '#{other.inspect}'" unless matches?(other)
+      if other.plural && !self.plural
+        res = other
+        res.occurrences.concat self.occurrences
+      else
+        res = self
+        res.occurrences.concat other.occurrences
+      end
+      res
+    end
+
+    private
+
+    # sets or extends the value of a translation target params like msgid,
+    # msgctxt etc.
+    #   param is symbol with the name of param
+    #   value - new value
+    def set_string_value(param, value)
+      send "#{param}=", (send(param) || '') + value.gsub(/\n/, '\n')
+    end
+  end
+
+end

data/lib/gettext/utils.rb

@@ -0,0 +1,37 @@
+=begin
+  utils.rb - Utility functions
+
+  Copyright (C) 2005,2006 Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+=end
+
+require 'gettext/tools'
+
+warn "'gettext/utils.rb' is deprecated. Use gettext/tools.rb."
+
+module GetText
+
+  alias :create_mofiles_org :create_mofiles #:nodoc:
+  alias :update_pofiles_org :update_pofiles #:nodoc:
+
+
+  # Deprecated. Use gettext/tools instead.
+  def create_mofiles(verbose = false,
+                     podir = "./po", targetdir = "./data/locale",
+                     targetpath_rule = "%s/LC_MESSAGES")  # :nodoc:
+    warn "'gettext/utils.rb' is deprecated. Use gettext/tools.rb."
+    create_mofiles_org(:verbose => verbose,
+                        :po_root => podir,
+                        :mo_root => targetdir,
+                        :mo_root_rule => targetpath_rule)
+  end
+
+  # Deprecated. Use gettext/tools instead.
+  def update_pofiles(textdomain, files, app_version, po_root = "po", refpot = "tmp.pot") # :nodoc:
+    warn "'gettext/utils.rb' is deprecated. Use gettext/tools.rb."
+    options = {:po_root => po_root}
+    update_pofiles_org(textdomain, files, app_version, options)
+  end
+end

data/lib/gettext/version.rb

@@ -0,0 +1,12 @@
+#! /usr/bin/ruby
+=begin
+  version - version information of Ruby-GetText-Package
+
+  Copyright (C) 2005-2009 Masao Mutoh
+ 
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+=end
+module GetText
+  VERSION = "2.0.4"
+end

data/lib/gettext.rb

@@ -0,0 +1,312 @@
+=begin
+  gettext.rb - GetText module
+
+  Copyright (C) 2001-2009  Masao Mutoh
+  Copyright (C) 2001-2003  Masahiro Sakai
+
+      Masao Mutoh       <mutomasa at gmail.com>
+      Masahiro Sakai    <s01397ms@sfc.keio.ac.jp>
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id: gettext.rb,v 1.46 2008/09/13 18:23:55 mutoh Exp $
+=end
+
+if Object.constants.include? "Gem"
+  begin
+    begin
+      gem 'locale', '>=2.0.4' 
+    rescue Gem::LoadError
+    end
+  rescue NoMethodError
+  else LoadError
+  end
+end
+
+require 'locale'
+raise "Install locale as gem or uninstall old gettext" unless Locale.respond_to? :candidates
+
+require 'gettext/version'
+require 'gettext/textdomain_manager'
+
+module GetText
+  # If the textdomain isn't bound when calling GetText.textdomain, this error is raised.
+  class NoboundTextDomainError < RuntimeError
+    def initialize(domainname)
+      @domainname = domainname
+    end
+    def message
+      "#{@domainname} is not bound."
+    end
+  end
+
+  extend self
+
+  def self.included(mod)  #:nodoc:
+    mod.extend self
+  end
+
+  # bindtextdomain(domainname, options = {})
+  #
+  # Bind a textdomain(%{path}/%{locale}/LC_MESSAGES/%{domainname}.mo) to 
+  # your program.
+  # Normally, the texdomain scope becomes the class/module(and parent 
+  # classes/included modules).
+  #
+  # * domainname: the textdomain name.
+  # * options: options as an Hash.
+  #   * :path - the path to the mo-files. When the value is nil, it will search default paths such as 
+  #     /usr/share/locale, /usr/local/share/locale)
+  #   * :output_charset - The output charset. Same with GetText.set_output_charset. Usually, L10n
+  #     library doesn't use this option. Application may use this once.
+  # * Returns: the GetText::TextDomainManager.
+  #
+  def bindtextdomain(domainname, *options)
+    bindtextdomain_to(self, domainname, *options)
+  end
+
+  # Includes GetText module and bind a textdomain to a class.
+  # * klass: the target ruby class.
+  # * domainname: the textdomain name.
+  # * options: options as an Hash. See GetText.bindtextdomain.
+  def bindtextdomain_to(klass, domainname, *options) 
+    if options[0].kind_of? Hash
+      opts = options[0]
+    else
+      # for backward compatibility.
+      opts = {}
+      opts[:path] = options[0] if options[0]
+      opts[:output_charset] = options[2] if options[2]
+    end
+    unless (klass.kind_of? GetText or klass.include? GetText)
+      klass.__send__(:include, GetText)
+    end
+    TextDomainManager.bind_to(klass, domainname, opts)
+  end
+
+  # Binds a existed textdomain to your program. 
+  # This is the same function with GetText.bindtextdomain but simpler(and faster) than bindtextdomain.
+  # Note that you need to call GetText.bindtextdomain first. If the domainname hasn't bound yet, 
+  # raises GetText::NoboundTextDomainError.
+  # * domainname: a textdomain name.
+  # * Returns: the GetText::TextDomainManager.
+  def textdomain(domainname) #:nodoc:
+    textdomain_to(self, domainname)
+  end
+
+  # Includes GetText module and bind an exsited textdomain to a class. 
+  # See textdomain for more detail.
+  # * klass: the target ruby class.
+  # * domainname: the textdomain name.
+
+  def textdomain_to(klass, domainname)  #:nodoc:
+    domain = TextDomainManager.textdomain_pool(domainname)
+    raise NoboundTextDomainError.new(domainname) unless domain
+    bindtextdomain_to(klass, domainname)
+  end
+
+  # call-seq:
+  #   gettext(msgid)
+  #   _(msgid)
+  #
+  # Translates msgid and return the message.
+  # This doesn't make a copy of the message. 
+  #
+  # You need to use String#dup if you want to modify the return value 
+  # with destructive functions. 
+  #
+  # (e.g.1) _("Hello ").dup << "world"
+  # 
+  # But e.g.1 should be rewrite to:
+  #
+  # (e.g.2) _("Hello %{val}") % {:val => "world"}
+  #
+  # Because the translator may want to change the position of "world".
+  #
+  # * msgid: the message id.
+  # * Returns: localized text by msgid. If there are not binded mo-file, it will return msgid.
+  def gettext(msgid)
+    TextDomainManager.translate_singluar_message(self, msgid)
+  end
+
+  # call-seq:
+  #   sgettext(msgid, div = '|')
+  #   s_(msgid, div = '|')
+  #
+  # Translates msgid, but if there are no localized text, 
+  # it returns a last part of msgid separeted "div".
+  #
+  # * msgid: the message id.
+  # * separator: separator or nil for no seperation.
+  # * Returns: the localized text by msgid. If there are no localized text, 
+  #   it returns a last part of the msgid separeted by "seperator".
+  #   <tt>Movie|Location -> Location</tt>
+  # See: http://www.gnu.org/software/gettext/manual/html_mono/gettext.html#SEC151
+  def sgettext(msgid, seperator = "|")
+    TextDomainManager.translate_singluar_message(self, msgid, seperator)
+  end
+
+  # call-seq:
+  #   pgettext(msgctxt, msgid)
+  #   p_(msgctxt, msgid)
+  #
+  # Translates msgid with msgctxt. This methods is similer with s_().
+  #  e.g.) p_("File", "New")   == s_("File|New")
+  #        p_("File", "Open")  == s_("File|Open")
+  #
+  # * msgctxt: the message context.
+  # * msgid: the message id.
+  # * Returns: the localized text by msgid. If there are no localized text, 
+  #   it returns msgid.
+  # See: http://www.gnu.org/software/autoconf/manual/gettext/Contexts.html
+  def pgettext(msgctxt, msgid)
+    TextDomainManager.translate_singluar_message(self, "#{msgctxt}\004#{msgid}", "\004")
+  end
+
+  # call-seq:
+  #   ngettext(msgid, msgid_plural, n)
+  #   ngettext(msgids, n)  # msgids = [msgid, msgid_plural]
+  #   n_(msgid, msgid_plural, n)
+  #   n_(msgids, n)  # msgids = [msgid, msgid_plural]
+  #
+  # The ngettext is similar to the gettext function as it finds the message catalogs in the same way. 
+  # But it takes two extra arguments for plural form.
+  #
+  # * msgid: the singular form.
+  # * msgid_plural: the plural form.
+  # * n: a number used to determine the plural form.
+  # * Returns: the localized text which key is msgid_plural if n is plural(follow plural-rule) or msgid.
+  #   "plural-rule" is defined in po-file.
+  def ngettext(msgid, msgid_plural, n = nil)
+    TextDomainManager.translate_plural_message(self, msgid, msgid_plural, n)
+  end
+
+  # call-seq:
+  #   nsgettext(msgid, msgid_plural, n, div = "|")
+  #   nsgettext(msgids, n, div = "|")  # msgids = [msgid, msgid_plural]
+  #   ns_(msgid, msgid_plural, n, div = "|")
+  #   ns_(msgids, n, div = "|")  # msgids = [msgid, msgid_plural]
+  #
+  # The nsgettext is similar to the ngettext.
+  # But if there are no localized text, 
+  # it returns a last part of msgid separeted "div".
+  #
+  # * msgid: the singular form with "div". (e.g. "Special|An apple")
+  # * msgid_plural: the plural form. (e.g. "%{num} Apples")
+  # * n: a number used to determine the plural form.
+  # * Returns: the localized text which key is msgid_plural if n is plural(follow plural-rule) or msgid.
+  #   "plural-rule" is defined in po-file.
+  def nsgettext(msgid, msgid_plural, n="|", seperator = "|")
+    TextDomainManager.translate_plural_message(self, msgid, msgid_plural, n, seperator)
+  end
+
+  # call-seq:
+  #   npgettext(msgctxt, msgid, msgid_plural, n)
+  #   npgettext(msgctxt, msgids, n)  # msgids = [msgid, msgid_plural]
+  #   np_(msgctxt, msgid, msgid_plural, n)
+  #   np_(msgctxt, msgids, n)  # msgids = [msgid, msgid_plural]
+  #
+  # The npgettext is similar to the nsgettext function.
+  #   e.g.) np_("Special", "An apple", "%{num} Apples", num) == ns_("Special|An apple", "%{num} Apples", num)
+  # * msgctxt: the message context.
+  # * msgid: the singular form.
+  # * msgid_plural: the plural form.
+  # * n: a number used to determine the plural form.
+  # * Returns: the localized text which key is msgid_plural if n is plural(follow plural-rule) or msgid.
+  #   "plural-rule" is defined in po-file.
+  def npgettext(msgctxt, msgids, arg2 = nil, arg3 = nil)
+    if msgids.kind_of?(Array)
+      msgid = msgids[0]
+      msgid_ctxt = "#{msgctxt}\004#{msgid}"
+      msgid_plural = msgids[1]
+      opt1 = arg2
+      opt2 = arg3
+    else
+      msgid = msgids
+      msgid_ctxt = "#{msgctxt}\004#{msgid}"
+      msgid_plural = arg2
+      opt1 = arg3
+      opt2 = nil
+    end
+    
+    msgstr = TextDomainManager.translate_plural_message(self, msgid_ctxt, msgid_plural, opt1, opt2)
+    if msgstr == msgid_ctxt
+      msgid
+    else
+      msgstr
+    end
+  end
+  
+  # makes dynamic translation messages readable for the gettext parser.
+  # <tt>_(fruit)</tt> cannot be understood by the gettext parser. To help the parser find all your translations,
+  # you can add <tt>fruit = N_("Apple")</tt> which does not translate, but tells the parser: "Apple" needs translation.
+  # * msgid: the message id.
+  # * Returns: msgid.
+  def N_(msgid)
+    msgid
+  end
+
+  # This is same function as N_ but for ngettext. 
+  # * msgid: the message id.
+  # * msgid_plural: the plural message id.
+  # * Returns: msgid.
+  def Nn_(msgid, msgid_plural)
+    [msgid, msgid_plural]
+  end
+
+  # Sets charset(String) such as "euc-jp", "sjis", "CP932", "utf-8", ... 
+  # You shouldn't use this in your own Libraries.
+  # * charset: an output_charset
+  # * Returns: self
+  def set_output_charset(charset)
+    TextDomainManager.output_charset = charset
+    self
+  end
+
+  # Gets the current output_charset which is set using GetText.set_output_charset.
+  # * Returns: output_charset.
+  def output_charset
+    TextDomainManager.output_charset
+  end
+
+  # Set the locale. This value forces the locale whole the programs.
+  # This method calls Locale.set_app_language_tags, Locale.default, Locale.current.
+  # Use Locale methods if you need to handle locales more flexible.
+  def set_locale(lang)
+    Locale.set_app_language_tags(lang)
+    Locale.default = lang
+    Locale.current = lang
+  end
+
+  # Set the locale to the current thread. 
+  # Note that if #set_locale is set, this value is ignored.
+  # If you need, set_locale(nil); set_current_locale(lang) 
+  def set_current_locale(lang)
+    Locale.current = lang
+  end
+
+  def locale
+    Locale.current[0]
+  end
+
+  alias :locale= :set_locale #:nodoc:
+  alias :current_locale= :set_current_locale #:nodoc:
+  alias :_ :gettext   #:nodoc:
+  alias :n_ :ngettext #:nodoc:
+  alias :s_ :sgettext #:nodoc:
+  alias :ns_ :nsgettext #:nodoc:
+  alias :np_ :npgettext #:nodoc:
+
+  alias :output_charset= :set_output_charset #:nodoc:
+
+unless defined? XX
+  # This is the workaround to conflict p_ methods with the xx("double x") library.
+  # http://rubyforge.org/projects/codeforpeople/
+  alias :p_ :pgettext #:nodoc:
+end
+
+  # for backward compatibility
+  alias :set_locale_all :set_locale #:nodoc:
+  alias :setlocale :set_locale #:nodoc:
+end