hallelujah-gettext_activerecord 2.0.4

data/lib/gettext_activerecord/i18n.rb

@@ -0,0 +1,27 @@
+=begin
+  lib/gettext_activerecord/i18n.rb - GetText for ActiveRecord's I18n.
+
+  Copyright (C) 2009 Masao Mutoh
+ 
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+=end
+ 
+module I18n  #:nodoc:
+  class << self 
+    include GetText
+    # gettext_activerecord doesn't define backend. So it can be used with another backend.
+    def translate_with_gettext_activerecord(key, options = {}) #:nodoc:
+      if options[:scope] == [:activerecord, :errors]
+        options[:attribute] = key.to_s.split(".")[3]
+        options   # This value will be used in ActiveRecord::Base::Errors.localize_error_messages
+      else
+        translate_without_gettext_activerecord(key, options)
+      end
+    end
+    alias_method_chain :translate, :gettext_activerecord #:nodoc:
+    alias_method :t_with_gettext_activerecord, :translate_with_gettext_activerecord #:nodoc:
+    alias_method_chain :t, :gettext_activerecord #:nodoc:
+
+  end
+end

data/lib/gettext_activerecord/migration.rb

@@ -0,0 +1,16 @@
+=begin
+  lib/gettext_activerecord/migration.rb - GetText for ActiveRecord::Migration
+
+  Copyright (C) 2009  Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+=end
+
+module ActiveRecord #:nodoc:
+  class Migration
+    extend GetText
+    include GetText
+  end
+end

data/lib/gettext_activerecord/parser.rb

@@ -0,0 +1,215 @@
+=begin
+  lib/gettext_activerecord/parser.rb - parser for ActiveRecord
+
+  Copyright (C) 2005-2009  Masao Mutoh
+ 
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id$
+=end
+
+require 'gettext'
+require 'gettext/tools/rgettext'
+require 'gettext/parser/ruby'
+
+include GetText
+
+ActiveRecord::Base.instance_eval do
+  alias inherited_without_log inherited
+
+  def inherited(subclass)
+    puts "registering an ActiveRecord model for later processing: #{subclass}" if $DEBUG
+    active_record_classes_list << "#{subclass}" unless subclass.name.empty?
+    inherited_without_log(subclass)
+  end
+
+  def active_record_classes_list
+    $active_record_classes_list ||= []
+  end
+
+  def reset_active_record_classes_list
+    $active_record_classes_list = []
+  end
+end
+
+module GetText
+  module ActiveRecordParser
+    extend GetText
+    include GetText
+    bindtextdomain "gettext_activerecord"
+
+    @config = {
+      :db_yml => "config/database.yml",
+      :db_mode => "development",
+      :activerecord_classes => ["ActiveRecord::Base"],
+      :untranslate_classes => ["ActiveRecord::Base", "ActiveRecord::SessionStore::Session"],
+      :untranslate_columns => ["id"],
+      :untranslate_table_name => false,
+      :use_classname => true,
+    }
+
+    @ar_re = nil
+
+    module_function
+    def require_rails(file) # :nodoc:
+      begin
+        require file
+      rescue MissingSourceFile
+        $stderr.puts _("'%{file}' is not found.") % {:file => file}
+      end
+    end
+
+    # Sets some preferences to parse ActiveRecord files.
+    #
+    # * config: a Hash of the config. It can takes some values below:
+    #   * :use_classname - If true, the msgids of ActiveRecord become "ClassName|FieldName" (e.g. "Article|Title"). Otherwise the ClassName is not used (e.g. "Title"). Default is true.
+    #   * :db_yml - the path of database.yml. Default is "config/database.yml".
+    #   * :db_mode - the mode of the database. Default is "development"
+    #   * :activerecord_classes - an Array of the superclass of the models. The classes should be String value. Default is ["ActiveRecord::Base"]
+    #   * :untranslate_classes - an Array of the modules/class names which is ignored as the msgid.
+    #   * :untranslate_columns - an Array of the column names which is ignored as the msgid.
+    #   * :untranslate_table_name - a Boolean that avoids table name to be translated if it is true ... Generally, we don't have to translate table_name, do we? Maybe it is not true..... but it is a test
+    #   * :adapter - the options for ActiveRecord::Base.establish_connection. If this value is set, :db_yml option is ignored.
+    #   * :host - ditto
+    #   * :username - ditto
+    #   * :password - ditto
+    #   * :database - ditto
+    #   * :socket - ditto
+    #   * :encoding - ditto
+    #
+    # "ClassName|FieldName" uses GetText.sgettext. So you don't need to translate the left-side of "|". 
+    # See <Documents for Translators for more details(http://www.yotabanana.com/hiki/ruby-gettext-translate.html)>.
+    def init(config)
+      puts "\nconfig: #{config.inspect}\n\n" if $DEBUG
+      if config
+        config.each{|k, v|
+          @config[k] = v
+        }
+      end
+      @ar_re = /class.*(#{@config[:activerecord_classes].join("|")})/
+    end
+
+    def translatable_class?(klass)
+      if klass.is_a?(Class) && klass < ActiveRecord::Base
+        if klass.untranslate_all? || klass.abstract_class? || @config[:untranslate_classes].include?(klass.name)
+          false
+        else
+          true
+        end
+      else
+        true
+      end
+    end
+
+    def translatable_column?(klass, columnname)
+      ! (klass.untranslate?(columnname) || @config[:untranslate_columns].include?(columnname))
+    end
+
+    def parse(file, targets = []) # :nodoc:
+      puts "parse file #{file}" if $DEBUG
+      
+      GetText.locale = "en"
+      old_constants = Object.constants
+      begin
+        eval(open(file).read, TOPLEVEL_BINDING)
+      rescue
+        $stderr.puts _("Ignored '%{file}'. Solve dependencies first.") % {:file => file}
+        $stderr.puts $! 
+      end
+      #loaded_constants = Object.constants - old_constants
+      loaded_constants = ActiveRecord::Base.active_record_classes_list
+      ActiveRecord::Base.reset_active_record_classes_list
+      loaded_constants.each do |classname|
+        klass = eval(classname, TOPLEVEL_BINDING)
+        if translatable_class?(klass)
+          puts "processing class #{klass.name}" if $DEBUG 
+          add_target(targets, file, ActiveSupport::Inflector.singularize(klass.table_name.gsub(/_/, " "))) unless @config[:untranslate_table_name]
+          unless klass.class_name == classname
+            add_target(targets, file, ActiveSupport::Inflector.singularize(klass.to_s_with_gettext.gsub(/_/, " ").downcase))
+          end
+          begin
+            klass.columns.each do |column|
+              if translatable_column?(klass, column.name)
+                if @config[:use_classname]
+                  msgid = klass.to_s_with_gettext + "|" +  klass.human_attribute_name(column.name)
+                  else
+                  msgid = klass.human_attribute_name(column.name)
+                end
+                add_target(targets, file, msgid)
+              end
+            end
+          rescue
+            $stderr.puts _("No database is available.")
+            $stderr.puts $!
+          end
+        end
+      end
+      if RubyParser.target?(file)
+        targets = RubyParser.parse(file, targets)
+      end
+      targets.uniq!
+      targets
+    end
+
+    def add_target(targets, file, msgid) # :nodoc:
+      file_lineno = "#{file}:-"
+      key_existed = targets.assoc(msgid)
+      if key_existed 
+        unless targets[targets.index(key_existed)].include?(file_lineno)
+          targets[targets.index(key_existed)] = key_existed << file_lineno
+        end
+      else
+        targets << [msgid, "#{file}:-"]
+      end
+      targets
+    end
+
+    def target?(file) # :nodoc:
+      init(nil) unless @ar_re
+      data = IO.readlines(file)
+      data.each do |v|
+        if @ar_re =~ v
+          unless ActiveRecord::Base.connected?
+            begin
+              require 'rubygems'
+            rescue LoadError
+              $stderr.puts _("rubygems are not found.") if $DEBUG
+            end
+            begin
+              ENV["RAILS_ENV"] = @config[:db_mode]
+              require 'config/boot.rb'
+              require 'config/environment.rb'
+              require_rails 'activesupport'
+              require_rails 'gettext_activerecord'
+            rescue LoadError
+              require_rails 'rubygems'
+              gem 'activerecord'
+              require_rails 'activesupport'
+              require_rails 'active_record'
+              require_rails 'gettext_activerecord'
+            end
+            begin
+              yaml = YAML.load(IO.read(@config[:db_yml]))
+              if yaml[@config[:db_mode]]
+                ActiveRecord::Base.establish_connection(yaml[@config[:db_mode]])
+              else
+                ActiveRecord::Base.establish_connection(yaml)
+              end
+            rescue
+              if @config[:adapter]
+                ActiveRecord::Base.establish_connection(@config)
+              else
+                return false
+              end
+            end
+          end
+          return true
+        end
+      end
+      false
+    end
+  end
+  
+  RGetText.add_parser(GetText::ActiveRecordParser)
+end

data/lib/gettext_activerecord/schema_definitions.rb

@@ -0,0 +1,28 @@
+=begin
+  lib/gettext_activerecord/schema_definitions.rb - GetText for ActiveRecord::ConnectionAdapters::Column
+
+  Copyright (C) 2009  Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+=end
+
+module ActiveRecord #:nodoc:
+  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_activerecord
+        if table_class
+          table_class.human_attribute_name(@name)
+        else
+          @name.humanize
+        end
+      end
+      alias_method_chain :human_name, :gettext_activerecord
+    end
+  end
+end

data/lib/gettext_activerecord/tools.rb

@@ -0,0 +1,30 @@
+=begin
+  tools.rb - Utility functions
+
+  Copyright (C) 2009 Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+=end
+
+require 'gettext/tools'
+require 'gettext_activerecord'
+require 'gettext_activerecord/parser'
+
+module GetText
+  extend self
+
+  alias :create_mofiles_org :create_mofiles  #:nodoc:
+  alias :update_pofiles_org :update_pofiles  #:nodoc:
+
+  # update_pofiles for ActiveRecord.
+  # In this method, GetText::ActiveRecordParser.init is called 
+  # with "options".
+  #  (e.g.)
+  #  GetText.update_po_files("foo", Dir.glob("lib/**/*"), "1.0.0", :untranslate_classes = ["UntranslateClass"]
+  def update_pofiles(textdomain, files, app_version, options = {})
+    GetText::ActiveRecordParser.init(options)
+    GetText.update_pofiles_org(textdomain, files, app_version, options)
+  end
+
+end

data/lib/gettext_activerecord/validations.rb

@@ -0,0 +1,191 @@
+=begin
+  lib/gettext_activerecord/validations.rb - GetText for ActiveRecord
+
+  Copyright (C) 2006-2009  Masao Mutoh
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+
+  $Id$
+=end
+
+module ActiveRecord #:nodoc:
+  class RecordInvalid < ActiveRecordError #:nodoc:
+    attr_reader :record
+    include GetText
+    bindtextdomain "gettext_activerecord"
+
+    def initialize(record)
+      @record = record
+      super(_("Validation failed: %{error_messages}") % 
+            {:error_messages => @record.errors.full_messages.join(", ")})
+    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_activerecord(attribute_key_name) #:nodoc:
+              s_("#{self.to_s_with_gettext}|#{attribute_key_name.humanize}")
+            end
+            alias_method_chain :human_attribute_name, :gettext_activerecord
+
+            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_activerecord(base) # :nodoc:
+          unless base <= ActiveRecord::Base
+            included_without_gettext_activerecord(base)
+          end
+          real_included(base)
+        end
+        alias_method_chain :included, :gettext_activerecord
+      end
+    else
+      class << self
+        # Since rails-1.2.0.
+        def append_features_with_gettext_activerecord(base) # :nodoc:
+          unless base <= ActiveRecord::Base
+            append_features_without_gettext_activerecord(base)
+          end
+          real_included(base)
+        end
+        alias_method_chain :append_features, :gettext_activerecord
+      end
+    end
+  end
+
+  # activerecord-1.14.3/lib/active_record/validations.rb
+  class Errors #:nodoc:
+    include GetText
+
+    textdomain "gettext_activerecord"
+
+    class << self
+      include GetText
+
+      def default_error_messages_with_gettext_activerecord
+        @@default_error_messages || {}
+      end
+      alias_method_chain :default_error_messages, :gettext_activerecord
+
+      # To use other backends, gettext_activerecord doesn't use backend architecture.
+      # You can use GetText with other backends.
+      @@default_error_messages = {
+          :inclusion => N_("%{attribute} is not included in the list"),
+          :exclusion => N_("%{attribute} is reserved"),
+          :invalid => N_("%{attribute} is invalid"),
+          :confirmation => N_("%{attribute} doesn't match confirmation"),
+          :accepted  => N_("%{attribute} must be accepted"),
+          :empty => N_("%{attribute} can't be empty"),
+          :blank => N_("%{attribute} can't be blank"),
+          :too_long => N_("%{attribute} is too long (maximum is %{count} characters)"),  
+          :too_short => N_("%{attribute} is too short (minimum is %{count} characters)"), 
+          :wrong_length => N_("%{attribute} is the wrong length (should be %{count} characters)"),
+          :taken => N_("%{attribute} has already been taken"),
+          :not_a_number => N_("%{attribute} is not a number"),
+          :greater_than => N_("%{attribute} must be greater than %{count}"),
+          :greater_than_or_equal_to => N_("%{attribute} must be greater than or equal to %{count}"),
+          :equal_to => N_("%{attribute} must be equal to %{count}"),
+          :less_than => N_("%{attribute} must be less than %{count}"),
+          :less_than_or_equal_to => N_("%{attribute} must be less than or equal to %{count}"),
+          :odd => N_("%{attribute} must be odd"),
+          :even => N_("%{attribute} must be even")
+      }
+    end
+
+    def each_with_gettext_activerecord #:nodoc:
+      @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, localize_error_message(attr, msg, false) } }
+    end
+    alias_method_chain :each, :gettext_activerecord
+
+    # 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_activerecord(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_activerecord
+    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_activerecord
+      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_activerecord 
+
+    private
+    def localize_error_message(attr, obj, append_field) # :nodoc:
+      msgid, count, value = obj, 0, ""
+      if obj.kind_of? Hash
+        msgid = obj[:default].select{|v| v.is_a? String}[0]
+        unless msgid
+          symbol = obj[:default][0].to_s.split(".").last.to_sym
+          msgid = @@default_error_messages[symbol]
+        end
+        #attr, count, value = obj[:attribute], obj[:count], obj[:value]
+        count, value = obj[:count], obj[:value]
+        attr = obj[:attribute] if obj[:attribute]
+      end
+      msgstr = @base.gettext(msgid)
+      msgstr = _(msgid) if msgstr == msgid 
+      msgstr = msgstr.gsub("%{fn}", "%{attribute}").gsub("%d", "%{count}").gsub("%{val}", "%{value}")  # for backward compatibility.
+      if attr == "base"
+        full_message = msgstr
+      elsif /%\{attribute\}/ =~ msgstr
+        full_message = msgstr % {:attribute => @base.class.human_attribute_name(attr)}
+      elsif append_field
+        full_message = @base.class.human_attribute_name(attr) + " " + msgstr
+      else
+        full_message = msgstr
+      end
+      full_message % {:count => count, :value => value}
+    end
+
+    def localize_error_messages(append_field = true) # :nodoc:
+      # e.g.) foo field: "%{fn} foo" => "Foo foo", "foo" => "Foo foo". 
+      errors = {}
+      each_without_gettext_activerecord {|attr, msg|
+        next if msg.nil?
+        errors[attr] ||= []
+        errors[attr] << localize_error_message(attr, msg, append_field)
+      }
+      errors
+    end
+
+  end
+end
+