# TranslationBuddy
# These are all the hacks I had to do to make multi-language pluralization work.
module ActiveRecord
module Reflection
class AssociationReflection
private
def derive_class_name
class_name = name.to_s.camelize
class_name = class_name.singularize(I18n.default_locale) if [ :has_many, :has_and_belongs_to_many ].include?(macro)
class_name
end
end
end
class Base
class << self
def human_name(options = {})
defaults = self_and_descendants_from_active_record.map do |klass|
:"#{klass.name.underscore}"
end
# changed humanize to titleize
defaults << self.name.titleize
I18n.translate(defaults.shift, {:scope => [:activerecord, :models], :count => 1, :default => defaults}.merge(options))
end
private
# Guesses the table name, but does not decorate it with prefix and suffix information.
def undecorated_table_name(class_name = base_class.name)
table_name = class_name.to_s.demodulize.underscore
table_name = table_name.tableize if pluralize_table_names
table_name
end
end
end
end
module ActiveSupport
class ModelName
def initialize(name)
super
@singular = underscore.tr('/', '_').freeze
@plural = @singular.pluralize(I18n.default_locale).freeze
@cache_key = tableize.freeze
@partial_path = "#{@cache_key}/#{demodulize.underscore}".freeze
end
end
module CoreExtensions #:nodoc:
module String #:nodoc:
# String inflections define new methods on the String class to transform names for different purposes.
# For instance, you can figure out the name of a database from the name of a class.
#
# "ScaleScore".tableize # => "scale_scores"
module Inflections
# Returns the plural form of the word in the string.
#
# "post".pluralize # => "posts"
# "octopus".pluralize # => "octopi"
# "sheep".pluralize # => "sheep"
# "words".pluralize # => "words"
# "the blue mailman".pluralize # => "the blue mailmen"
# "CamelOctopus".pluralize # => "CamelOctopi"
def pluralize(locale = nil)
Inflector.pluralize(self, locale)
end
def singularize(locale = nil)
Inflector.singularize(self, locale)
end
end
end
end
module Inflector
# Yields a singleton instance of Inflector::Inflections so you can specify additional
# inflector rules.
#
# Example:
# ActiveSupport::Inflector.inflections do |inflect|
# inflect.uncountable "rails"
# end
def inflections(locale = nil)
locale ||= I18n.locale
locale_class = if locale.to_s == I18n.default_locale.to_s
ActiveSupport::Inflector::Inflections
else
ActiveSupport::Inflector.const_get("Inflections_#{locale}") rescue nil
end
if locale_class.nil?
ActiveSupport::Inflector.module_eval %{
class ActiveSupport::Inflector::Inflections_#{locale} < ActiveSupport::Inflector::Inflections
end
}
locale_class = ActiveSupport::Inflector.const_get("Inflections_#{locale}")
end
if block_given?
yield locale_class.instance
else
locale_class.instance
end
end
# Returns the plural form of the word in the string.
#
# Examples:
# "post".pluralize # => "posts"
# "octopus".pluralize # => "octopi"
# "sheep".pluralize # => "sheep"
# "words".pluralize # => "words"
# "CamelOctopus".pluralize # => "CamelOctopi"
def pluralize(word, locale = nil)
locale ||= I18n.locale
result = word.to_s.dup
if word.empty? || inflections(locale).uncountables.include?(result.downcase)
result
else
inflections(locale).plurals.each do |(rule, replacement)|
if replacement.respond_to?(:call)
break if result.gsub!(rule, &replacement)
else
break if result.gsub!(rule, replacement)
end
end
result
end
end
# The reverse of +pluralize+, returns the singular form of a word in a string.
#
# Examples:
# "posts".singularize # => "post"
# "octopi".singularize # => "octopus"
# "sheep".singluarize # => "sheep"
# "word".singularize # => "word"
# "CamelOctopi".singularize # => "CamelOctopus"
def singularize(word, locale = nil)
locale ||= I18n.locale
result = word.to_s.dup
if inflections.uncountables.include?(result.downcase)
result
else
inflections(locale).singulars.each do |(rule, replacement)|
if replacement.respond_to?(:call)
break if result.gsub!(rule, &replacement)
else
break if result.gsub!(rule, replacement)
end
end
result
end
end
# Create the name of a table like Rails does for models to table names. This method
# uses the +pluralize+ method on the last word in the string.
#
# Examples
# "RawScaledScorer".tableize # => "raw_scaled_scorers"
# "egg_and_ham".tableize # => "egg_and_hams"
# "fancyCategory".tableize # => "fancy_categories"
def tableize(class_name)
pluralize(underscore(class_name), I18n.default_locale)
end
end
end
module ActionController
module PolymorphicRoutes
def build_named_route_call(records, namespace, inflection, options = {})
unless records.is_a?(Array)
record = extract_record(records)
route = ''
else
record = records.pop
route = records.inject("") do |string, parent|
if parent.is_a?(Symbol) || parent.is_a?(String)
string << "#{parent}_"
else
string << "#{RecordIdentifier.__send__("plural_class_name", parent)}".singularize
string << "_"
end
end
end
if record.is_a?(Symbol) || record.is_a?(String)
route << "#{record}_"
else
route << "#{RecordIdentifier.__send__("plural_class_name", record)}"
route = route.singularize(I18n.default_locale) if inflection == :singular
route << "_"
end
action_prefix(options) + namespace + route + routing_type(options).to_s
end
end
end
) is private.
