gettext 1.93.0 → 2.0.0

data/lib/gettext/active_record.rb

@@ -1,357 +0,0 @@
-=begin
-  gettext/active_record.rb - GetText for ActiveRecord
-
-  Copyright (C) 2006-2008  Masao Mutoh
-
-  You may redistribute it and/or modify it under the same
-  license terms as Ruby.
-
-  $Id: active_record.rb,v 1.25 2008/07/24 17:17:48 mutoh Exp $
-=end
-require 'gettext'
-require 'active_record'
-require 'gettext/rails_compat'
-
-module ActiveRecord #:nodoc:
-  class Migration
-    extend GetText
-    include GetText
-  end
-
-  class RecordInvalid < ActiveRecordError #:nodoc:
-    attr_reader :record
-    include GetText
-    bindtextdomain("rails")
-
-    def initialize(record)
-      @record = record
-      super(_("Validation failed: %{error_messages}") % 
-            {:error_messages => @record.errors.full_messages.join(", ")})
-    end
-  end
-
-  
-  module ConnectionAdapters #:nodoc:
-    # An abstract definition of a column in a table.
-    class Column
-      attr_accessor :table_class
-      alias :human_name_witout_localized :human_name 
-
-      def human_name_with_gettext
-        if table_class
-          table_class.human_attribute_name(@name)
-        else
-          @name.humanize
-        end
-      end
-      alias_method_chain :human_name, :gettext
-    end
-  end
-
-  module Validations # :nodoc:
-    class << self
-      def real_included(base)
-        base.extend ClassMethods
-        base.class_eval{
-          include GetText
-          def gettext(str)  #:nodoc:
-            _(str)
-          end
-          class << self
-            def human_attribute_name_with_gettext(attribute_key_name) #:nodoc:
-              s_("#{self}|#{attribute_key_name.humanize}")
-            end
-            alias_method_chain :human_attribute_name, :gettext
-            def human_attribute_table_name_for_error(table_name) #:nodoc:
-              _(table_name.gsub(/_/, " "))
-            end
-          end
-        }
-      end
-    end
-
-    if respond_to? :included
-      class << self
-        def included_with_gettext(base) # :nodoc:
-          unless base <= ActiveRecord::Base
-            included_without_gettext(base)
-          end
-          real_included(base)
-        end
-        alias_method_chain :included, :gettext
-      end
-    else
-      class << self
-        # Since rails-1.2.0.
-        def append_features_with_gettext(base) # :nodoc:
-          unless base <= ActiveRecord::Base
-            append_features_without_gettext(base)
-          end
-          real_included(base)
-        end
-        alias_method_chain :append_features, :gettext
-      end
-    end
-
-    module ClassMethods #:nodoc:
-      @@custom_error_messages_d = {}
-      # Very ugly but...
-      def validates_length_of_with_gettext(*attrs)  #:nodoc:
-	if attrs.last.is_a?(Hash)
-          [:message, :too_long, :too_short, :wrong_length].each do |msg_sym|
-            msg = attrs.last[msg_sym]
-            @@custom_error_messages_d[msg] = /\A#{Regexp.escape(msg).sub(/%d/, '(\d+)')}\Z/ if msg
-          end
-	end
-	validates_size_of(*attrs)
-      end
-      alias_method_chain :validates_length_of, :gettext
-
-      def _validates_parse_custom_messages(*attrs) #:nodoc:
-	if attrs.last.is_a?(Hash) and attrs.last[:message]
-          msg = attrs.last[:message]
-          key = msg.dup
-          msg.sub!(/%\{val\}/, '%s')
-          @@custom_error_messages_d[key] = /\A#{Regexp.escape(msg).sub('%s', '(.*)')}\Z/
-	end
-        attrs
-      end
-      
-      def validates_format_of_with_gettext(*attrs)  #:nodoc:
-        attrs = _validates_parse_custom_messages(*attrs)
-	validates_format_of_without_gettext(*attrs)
-      end
-      alias_method_chain :validates_format_of, :gettext
-
-      def validates_inclusion_of_with_gettext(*attrs)  #:nodoc:
-        attrs = _validates_parse_custom_messages(*attrs)
-	validates_inclusion_of_without_gettext(*attrs)
-      end
-      alias_method_chain :validates_inclusion_of, :gettext
-
-      def validates_exclusion_of_with_gettext(*attrs)  #:nodoc:
-        attrs = _validates_parse_custom_messages(*attrs)
-	validates_exclusion_of_without_gettext(*attrs)
-      end
-      alias_method_chain :validates_exclusion_of, :gettext
-
-      def custom_error_messages_d  #:nodoc:
-	@@custom_error_messages_d
-      end
-    end
-    def custom_error_messages_d  #:nodoc:
-      self.class.custom_error_messages_d
-    end
-  end
-  
-  class Base
-    include GetText
-    include Validations
-
-    @@gettext_untranslate = Hash.new(false)
-    @@gettext_untranslate_columns = {}
-
-    class << self
-      # Untranslate all of the tablename/fieldnames in this model class.
-      def untranslate_all
-        @@gettext_untranslate[self] = true
-      end
-
-      # Returns true if "untranslate_all" is called. Otherwise false.
-      def untranslate_all?
-        @@gettext_untranslate[self]
-      end
-
-      # Sets the untranslate columns.
-      # (e.g.) untranslate :foo, :bar, :baz
-      def untranslate(*w)
-        ary = @@gettext_untranslate_columns[self] || []
-        ary += w.collect{|v| v.to_s}
-        @@gettext_untranslate_columns[self] = ary
-      end
-      
-      # Returns true if the column is set "untranslate".
-      # (e.g.) untranslate? :foo
-      def untranslate?(columnname)
-        ary = @@gettext_untranslate_columns[self] || []
-        ary.include?(columnname)
-      end
-
-      def untranslate_data #:nodoc:
-        [@@gettext_untranslate[self], @@gettext_untranslate_columns[self] || []]
-      end
-
-      def columns_with_gettext
-        unless defined? @columns
-          @columns = nil 
-        end
-        unless @columns
-          @columns = columns_without_gettext
-          @columns.each {|column| 
-            column.table_class = self
-          }
-        end
-        @columns
-      end
-      alias_method_chain :columns, :gettext
-    
-      # call-seq:
-      # set_error_message_title(msg)
-      #
-      # ((*Deprecated*)) 
-      # Use ActionView::Helpers::ActiveRecordHelper::L10n.set_error_message_title
-      # instead.
-      #
-      # Sets a your own title of error message dialog.
-      # * msg: [single_msg, plural_msg]. Usually you need to call this with Nn_().
-      # * Returns: [single_msg, plural_msg]
-      def set_error_message_title(msg, plural_msg = nil)
-        ActionView::Helpers::ActiveRecordHelper::L10n.set_error_message_title(msg, plural_msg)
-      end
-      
-      # call-seq:
-      # set_error_message_explanation(msg)
-      #
-      # ((*Deprecated*)) 
-      # Use ActionView::Helpers::ActiveRecordHelper::L10n.set_error_message_explanation
-      # instead.
-      #
-      # Sets a your own explanation of the error message dialog.
-      # * msg: [single_msg, plural_msg]. Usually you need to call this with Nn_().
-      # * Returns: [single_msg, plural_msg]
-      def set_error_message_explanation(msg, plural_msg = nil)
-        ActionView::Helpers::ActiveRecordHelper::L10n.set_error_message_explanation(msg, plural_msg)
-      end
-    end
-  end
-
-  # activerecord-1.14.3/lib/active_record/validations.rb
-  class Errors #:nodoc:
-    include GetText
-
-    def initialize_with_gettext(base) # :nodoc:
-      initialize_without_gettext(base)
-      bindtextdomain("rails")
-    end
-    alias_method_chain :initialize, :gettext
-
-    def @@default_error_messages.[]=(id, msg) #:nodoc:
-      @@default_error_messages.update({id => msg})
-      if [:message, :too_long, :too_short, :wrong_length].include?(id)
-	@@default_error_messages_d[msg] = /\A#{Regexp.escape(msg).sub(/%d/, '(\d+)')}\Z/ 
-      end
-    end    
-
-    # You need to define this here, because this values will be updated by application.
-    default_error_messages.update(
-				  :inclusion => N_("%{fn} is not included in the list"),
-				  :exclusion => N_("%{fn} is reserved"),
-				  :invalid => N_("%{fn} is invalid"),
-				  :confirmation => N_("%{fn} doesn't match confirmation"),
-				  :accepted  => N_("%{fn} must be accepted"),
-				  :empty => N_("%{fn} can't be empty"),
-				  :blank => N_("%{fn} can't be blank"),
-				  :too_long => N_("%{fn} is too long (maximum is %d characters)"),  
-				  :too_short => N_("%{fn} is too short (minimum is %d characters)"), 
-				  :wrong_length => N_("%{fn} is the wrong length (should be %d characters)"),
-				  :taken => N_("%{fn} has already been taken"),
-				  :not_a_number => N_("%{fn} is not a number"),
-                                  :greater_than => N_("%{fn} must be greater than %d"),
-                                  :greater_than_or_equal_to => N_("%{fn} must be greater than or equal to %d"),
-                                  :equal_to => N_("%{fn} must be equal to %d"),
-                                  :less_than => N_("%{fn} must be less than %d"),
-                                  :less_than_or_equal_to => N_("%{fn} must be less than or equal to %d"),
-                                  :odd => N_("%{fn} must be odd"),
-                                  :even => N_("%{fn} must be even")
-				  )
-    @@default_error_messages_d = {
-      default_error_messages[:too_long] => /#{Regexp.escape(default_error_messages[:too_long]).sub(/%d/, '(\d+)')}/,
-      default_error_messages[:too_short] => /#{Regexp.escape(default_error_messages[:too_short]).sub(/%d/, '(\d+)')}/,
-      default_error_messages[:wrong_length] => /#{Regexp.escape(default_error_messages[:wrong_length]).sub(/%d/, '(\d+)')}/,
-      default_error_messages[:greater_than] => /#{Regexp.escape(default_error_messages[:greater_than]).sub(/%d/, '(\d+)')}/,
-      default_error_messages[:greater_than_or_equal_to] => /#{Regexp.escape(default_error_messages[:greater_than_or_equal_to]).sub(/%d/, '(\d+)')}/,
-      default_error_messages[:equal_to] => /#{Regexp.escape(default_error_messages[:equal_to]).sub(/%d/, '(\d+)')}/,
-      default_error_messages[:less_than] => /#{Regexp.escape(default_error_messages[:less_than]).sub(/%d/, '(\d+)')}/,
-      default_error_messages[:less_than_or_equal_to] => /#{Regexp.escape(default_error_messages[:less_than_or_equal_to]).sub(/%d/, '(\d+)')}/,
-      default_error_messages[:odd] => /#{Regexp.escape(default_error_messages[:odd]).sub(/%d/, '(\d+)')}/,
-      default_error_messages[:even] => /#{Regexp.escape(default_error_messages[:even]).sub(/%d/, '(\d+)')}/,
-    }
-    cattr_accessor :default_error_messages_d
-
-    def localize_error_message(attr, msg, append_field) # :nodoc:
-      custom_msg = nil
-      #Ugly but... :-<
-      @@default_error_messages_d.dup.merge(@base.custom_error_messages_d).each do |key, regexp|
-        if regexp =~ msg
-          custom_msg = @base.gettext(key)
-          custom_msg = _(msg) if custom_msg == msg 
-          custom_msg = _(custom_msg) % $1
-          custom_msg = _(custom_msg) % {:val => $1}
-          break
-        end
-      end
-
-      unless custom_msg
-        custom_msg = @base.gettext(msg)
-        custom_msg = _(msg) if custom_msg == msg 
-      end
-
-      if attr == "base"
-        full_message = custom_msg
-      elsif /%\{fn\}/ =~ custom_msg
-        full_message = custom_msg % {:fn => @base.class.human_attribute_name(attr)}
-      elsif append_field
-        full_message = @base.class.human_attribute_name(attr) + " " + custom_msg
-      else
-        full_message = custom_msg
-      end
-      full_message
-    end
-
-    def localize_error_messages(append_field = true) # :nodoc:
-      # e.g.) foo field: "%{fn} foo" => "Foo foo", "foo" => "Foo foo". 
-      errors = {}
-      each {|attr, msg|
-        next if msg.nil?
-        errors[attr] ||= []
-        errors[attr] << localize_error_message(attr, msg, append_field)
-      }
-      errors
-    end
-
-    # Returns error messages.
-    # * Returns nil, if no errors are associated with the specified attribute.
-    # * Returns the error message, if one error is associated with the specified attribute.
-    # * Returns an array of error messages, if more than one error is associated with the specified attribute.
-    # And for GetText,
-    # * If the error messages include %{fn}, it returns formatted text such as "foo %{fn}" => "foo Field"
-    # * else, the error messages are prepended the field name such as "foo" => "foo" (Same as default behavior).
-    # Note that this behaviour is different from full_messages.
-    def on_with_gettext(attribute)
-      # e.g.) foo field: "%{fn} foo" => "Foo foo", "foo" => "foo". 
-      errors = localize_error_messages(false)[attribute.to_s]
-      return nil if errors.nil?
-      errors.size == 1 ? errors.first : errors
-    end
-    alias_method_chain :on, :gettext 
-    alias :[] :on
-
-    # Returns all the full error messages in an array.
-    # * If the error messages include %{fn}, it returns formatted text such as "foo %{fn}" => "foo Field"
-    # * else, the error messages are prepended the field name such as "foo" => "Field foo" (Same as default behavior).
-    # As L10n, first one is recommanded because the order of subject,verb and others are not same in languages.
-    def full_messages_with_gettext
-      full_messages = []
-      errors = localize_error_messages
-      errors.each_key do |attr|
-        errors[attr].each do |msg|
-	  next if msg.nil?
-	  full_messages << msg
-	end
-      end
-      full_messages
-    end
-    alias_method_chain :full_messages, :gettext 
-  end
-end
-

data/lib/gettext/container.rb

@@ -1,19 +0,0 @@
-=begin
-  gettext/erb.rb - Class-based container module for GetText 
-
-  Copyright (C) 2005,2006  Masao Mutoh
-
-  You may redistribute it and/or modify it under the same
-  license terms as Ruby.
-
-  $Id: container.rb,v 1.6 2006/06/11 15:36:20 mutoh Exp $
-=end
-
-require 'gettext'
-
-module GetText 
-  # Deprecated. You don't need this. Use GetText instead.
-  module Container
-    include GetText
-  end
-end

data/lib/gettext/erb.rb

@@ -1,56 +0,0 @@
-=begin
-  gettext/erb.rb - GetText for ERB
-
-  Copyright (C) 2005,2006  Masao Mutoh
-
-  You may redistribute it and/or modify it under the same
-  license terms as Ruby.
-
-  $Id: erb.rb,v 1.4 2006/12/06 16:39:58 mutoh Exp $
-=end
-
-require 'erb'
-require 'gettext'
-
-module GetText
-
-  # This module provides basic functions to evaluate plural ERB files(.rhtml) in a TextDomain.
-  # You need to implement a class which includes GetText::ErbContainer.
-  #
-  # See simple examples below:
-  #
-  #  require 'gettext/erb'
-  #  class SimpleContainer
-  #    include GetText::ErbContainer
-  #     
-  #    def initialize(domainname, domainpath = nil, locale = nil, charset = nil)
-  #      bindtextdomain(domainname, domainpath, locale)
-  #    end
-  #  end
-  #  
-  #  container = SimpleContainer.new("helloerb1", "locale")
-  #  puts container.eval_file("/your/erb/file.rhtml")
-  #
-  # This module is an example for template engines such as ERB. 
-  # You can implement another implementation easily to read gettext/erb.rb.
-  module ErbContainer
-    include GetText
-
-    # Evaluates ERB source(String) in the instance and returns the result HTML.
-    #
-    # * rhtml: an ERB source
-    # * Returns: the Evaluated ERB result
-    def eval_src(rhtml)
-      erb = ERB.new(rhtml).src
-      eval(erb, binding)
-    end
-
-    # Evaluates ERB file in the instance and returns the result HTML.
-    #
-    # * rhtml: an ERB file
-    # * Returns: the Evaluated ERB result
-    def eval_file(rhtmlpath)
-      eval_src(IO.read(rhtmlpath))
-    end
-  end
-end

data/lib/gettext/mo.rb

@@ -1,320 +0,0 @@
-=begin
-    mo.rb - A simple class for operating GNU MO file.
-
-    Copyright (C) 2003-2008  Masao Mutoh
-    Copyright (C) 2002  Masahiro Sakai, Masao Mutoh
-    Copyright (C) 2001  Masahiro Sakai
-
-        Masahiro Sakai                  <s01397ms at sfc.keio.ac.jp>
-        Masao Mutoh                     <mutoh at highway.ne.jp>
-
-    You can redistribute this file and/or modify it under the same term
-    of Ruby.  License of Ruby is included with Ruby distribution in
-    the file "README".
-
-    $Id: mo.rb,v 1.10 2008/06/17 16:40:52 mutoh Exp $
-=end
-
-require 'gettext/iconv'
-require 'stringio'
-
-class MOFile < Hash 
-  class InvalidFormat < RuntimeError; end;
-
-  attr_reader :filename
-
-  Header = Struct.new(:magic,
-                      :revision,
-                      :nstrings,
-                      :orig_table_offset,
-                      :translated_table_offset,
-                      :hash_table_size,
-                      :hash_table_offset)
-
-  # The following are only used in .mo files 
-  # with minor revision >= 1.
-  class HeaderRev1 < Header
-    attr_accessor :n_sysdep_segments,
-                  :sysdep_segments_offset,
-                  :n_sysdep_strings,
-                  :orig_sysdep_tab_offset,
-                  :trans_sysdep_tab_offset
-  end
-
-  MAGIC_BIG_ENDIAN    = "\x95\x04\x12\xde"
-  MAGIC_LITTLE_ENDIAN = "\xde\x12\x04\x95"
-
-  def self.open(arg = nil, output_charset = nil)
-    result = self.new(output_charset)
-    result.load(arg)
-  end
-
-  def initialize(output_charset = nil)
-    @filename = nil
-    @last_modified = nil
-    @little_endian = true
-    @output_charset = output_charset
-    super()
-  end
-
-  def update!
-    if FileTest.exist?(@filename)
-      st = File.stat(@filename)
-      load(@filename) unless (@last_modified == [st.ctime, st.mtime])
-    else
-      puts "#{@filename} was lost." if $DEBUG
-      clear
-    end
-    self
-  end
-
-  def load(arg)
-    if arg.kind_of? String
-      begin
-	st = File.stat(arg)
-	@last_modified = [st.ctime, st.mtime]
-      rescue Exception
-      end
-      load_from_file(arg)
-    else
-      load_from_stream(arg)
-    end
-    @filename = arg
-    self
-  end
-
-  def load_from_stream(io)
-    magic = io.read(4)
-    case magic
-    when MAGIC_BIG_ENDIAN
-      @little_endian = false
-    when MAGIC_LITTLE_ENDIAN
-      @little_endian = true
-    else
-      raise InvalidFormat.new(sprintf("Unknown signature %s", magic.dump))
-    end
-
-    endian_type6 = @little_endian ? 'V6' : 'N6'
-    endian_type_astr = @little_endian ? 'V*' : 'N*'
-
-    header = HeaderRev1.new(magic, *(io.read(4 * 6).unpack(endian_type6)))
-
-    if header.revision == 1
-      # FIXME: It doesn't support sysdep correctly.
-      header.n_sysdep_segments = io.read(4).unpack(endian_type6)
-      header.sysdep_segments_offset = io.read(4).unpack(endian_type6)
-      header.n_sysdep_strings = io.read(4).unpack(endian_type6)
-      header.orig_sysdep_tab_offset = io.read(4).unpack(endian_type6)
-      header.trans_sysdep_tab_offset = io.read(4).unpack(endian_type6)
-    elsif header.revision > 1
-      raise InvalidFormat.new(sprintf("file format revision %d isn't supported", header.revision))
-    end
-    io.pos = header.orig_table_offset
-    orig_table_data = io.read((4 * 2) * header.nstrings).unpack(endian_type_astr)
-
-    io.pos = header.translated_table_offset
-    trans_table_data = io.read((4 * 2) * header.nstrings).unpack(endian_type_astr)
-
-    original_strings = Array.new(header.nstrings)
-    for i in 0...header.nstrings
-      io.pos = orig_table_data[i * 2 + 1]
-      original_strings[i] = io.read(orig_table_data[i * 2 + 0])
-    end
-
-    clear
-    for i in 0...header.nstrings
-      io.pos = trans_table_data[i * 2 + 1]
-      str = io.read(trans_table_data[i * 2 + 0])
-
-      if (! original_strings[i]) || original_strings[i] == ""
-        if str
-          @charset = nil
-          @nplurals = nil
-          @plural = nil
-          str.each_line{|line|
-            if /^Content-Type:/i =~ line and /charset=((?:\w|-)+)/i =~ line
-              @charset = $1
-            elsif /^Plural-Forms:\s*nplurals\s*\=\s*(\d*);\s*plural\s*\=\s*([^;]*)\n?/ =~ line
-              @nplurals = $1
-              @plural = $2
-            end
-            break if @charset and @nplurals
-          }
-          @nplurals = "1" unless @nplurals
-          @plural = "0" unless @plural
-        end
-      else
-        if @output_charset
-          begin
-            str = Iconv.conv(@output_charset, @charset, str) if @charset
-          rescue Iconv::Failure
-            if $DEBUG
-              $stderr.print "@charset = ", @charset, "\n"
-              $stderr.print "@output_charset = ", @output_charset, "\n"
-              $stderr.print "msgid = ", original_strings[i], "\n"
-              $stderr.print "msgstr = ", str, "\n"
-            end
-          end
-        end
-      end
-      self[original_strings[i]] = str.freeze
-    end
-    self
-  end
-
-  # From gettext-0.12.1/gettext-tools/lib/hash.c
-  def prime?(candidate)
-    divn = 3
-    sq = divn * divn
-
-    while (sq < candidate && candidate % divn != 0)
-      divn += 1
-      sq += 4 * divn
-      divn += 1
-    end
-    candidate % divn != 0
-  end
-
-  # From gettext-0.12.1/gettext-tools/lib/hash.c
-  def next_prime(seed)
-    seed |= 1
-    while (! prime?(seed))
-      seed += 2
-    end
-    seed
-  end
-
-  # From gettext-0.12.1/gettext-runtime/intl/hash-string.h
-  # Defines the so called `hashpjw' function by P.J. Weinberger
-  # [see Aho/Sethi/Ullman, COMPILERS: Principles, Techniques and Tools,
-  # 1986, 1987 Bell Telephone Laboratories, Inc.] 
-  HASHWORDBITS = 32
-  def hash_string(str)
-    hval = 0
-    i = 0
-    str.each_byte do |b|
-      break if b == '\0'
-      hval <<= 4
-      hval += b.to_i
-      g = hval & (0xf << (HASHWORDBITS - 4))
-      if (g != 0)
-        hval ^= g >> (HASHWORDBITS - 8)
-        hval ^= g
-      end
-    end
-    hval
-  end
-
-  def save_to_stream(io)
-    #Save data as little endian format.
-    header_size = 4 * 7
-    table_size  = 4 * 2 * size
-
-    hash_table_size = next_prime((size * 4) / 3) 
-    hash_table_size = 3 if hash_table_size <= 2
-    header = Header.new(
-      MAGIC_LITTLE_ENDIAN,          # magic
-      0,                            # revision
-      size,                         # nstrings
-      header_size,                  # orig_table_offset
-      header_size + table_size,     # translated_table_offset
-      hash_table_size,              # hash_table_size
-      header_size + table_size * 2  # hash_table_offset
-    )
-    io.write(header.to_a.pack('a4V*'))
-
-    ary = to_a
-    ary.sort!{|a, b| a[0] <=> b[0]} # sort by original string
-
-    pos = header.hash_table_size * 4 + header.hash_table_offset
-
-    orig_table_data = Array.new()
-    ary.each{|item, _|
-      orig_table_data.push(item.size)
-      orig_table_data.push(pos)
-      pos += item.size + 1 # +1 is <NUL>
-    }
-    io.write(orig_table_data.pack('V*'))
-
-    trans_table_data = Array.new()
-    ary.each{|_, item|
-      trans_table_data.push(item.size)
-      trans_table_data.push(pos)
-      pos += item.size + 1 # +1 is <NUL>
-    }
-    io.write(trans_table_data.pack('V*'))
-
-    hash_tab = Array.new(hash_table_size)
-    j = 0
-    ary[0...size].each {|key, _|
-      hash_val = hash_string(key)
-      idx = hash_val % hash_table_size
-      if hash_tab[idx] != nil
-        incr = 1 + (hash_val % (hash_table_size - 2))
-        begin
-          if (idx >= hash_table_size - incr)
-            idx -= hash_table_size - incr
-          else
-            idx += incr
-          end
-        end until (hash_tab[idx] == nil)
-      end
-      hash_tab[idx] = j + 1
-      j += 1
-    }
-    hash_tab.collect!{|i| i ? i : 0}
-
-    io.write(hash_tab.pack('V*'))
-
-    ary.each{|item, _| io.write(item); io.write("\0") }
-    ary.each{|_, item| io.write(item); io.write("\0") }
-
-    self
-  end
-
-  def load_from_file(filename)
-    @filename = filename
-    begin
-      File.open(filename, 'rb'){|f| load_from_stream(f)}
-    rescue => e
-      e.set_backtrace("File: #{@filename}")
-      raise e
-    end
-  end
-
-  def save_to_file(filename)
-    File.open(filename, 'wb'){|f| save_to_stream(f)}
-  end
-
-  def set_comment(msgid_or_sym, comment)
-    #Do nothing
-  end
-
-
-  attr_accessor :little_endian, :path, :last_modified
-  attr_reader :charset, :nplurals, :plural
-end
-
-
-# Test
-
-if $0 == __FILE__
-  if (ARGV.include? "-h") or (ARGV.include? "--help")
-    STDERR.puts("mo.rb [filename.mo ...]")
-    exit
-  end
-
-  ARGV.each{ |item|
-    mo = MOFile.open(item)
-    puts "------------------------------------------------------------------"
-    puts "charset  = \"#{mo.charset}\""
-    puts "nplurals = \"#{mo.nplurals}\""
-    puts "plural   = \"#{mo.plural}\""
-    puts "------------------------------------------------------------------"
-    mo.each do |key, value|
-      puts "original message = #{key.inspect}"
-      puts "translated message = #{value.inspect}"
-      puts "--------------------------------------------------------------------"
-    end
-  }
-end