Eu sempre me lembro daquele artigo do Akita onde ele provocava dizendo que aprender Ruby nos torna programadores piores. Estes dias conversando com o próprio citei isto ao revelar minha insatisfação quanto a ter de continuar desenvolvendo em C#. Não que eu não goste da linguagem, muito pelo contrário, gosto muito de C#, mas neste momento minha cabeça está pensando em Ruby on Rails.
Mas infelizmente, aqui no Brasil, RoR ainda não é uma "realidade" na maioria das empresas.
Apenas como exemplo, um dia destes precisei desenvolver um módulo aqui onde seria necessário usar pluralização. É nessas horas que você para e pensa: "Poxa vida, se eu estivesse usando o Rails, já estava pronto…". Mas, nem tudo é perfeito.
Mas eu é que não ia ficar batendo cabeça para recriar a roda, fui atrás dos fontes do Rails e portei o código para C# exatamente da mesma maneira como é no Rails.
[source:csharp]
///
/// Classe para inflexão de palavras em inglês.
///
public class Inflections
{
///
/// Relação de palavras sem plural.
///
private static string[] uncountables = new string[] {“equipment”, “information”, “rice”, “money”, “species”, “series”, “fish”, “sheep”};
///
/// Verifica se a palavra não tem plural.
///
/// A palavra.
/// Verdadeiro se a palavra não tem plural.
private static bool IsUncountable(string word)
{
word = word.ToLower();
foreach(string s in uncountables)
{
if (s.Equals(word))
return true;
}
return false;
}
///
/// Regras de pluralização.
///
private static Plural[] plurals =
new Plural[] {
new Plural(“$”, “s”),
new Plural(”s$”, “s”),
new Plural(“(ax|test)is$”, “$1es”),
new Plural(“(octop|vir)us$”, “$1i”),
new Plural(“(alias|status)$”, “$1es”),
new Plural(“(bu)s$”, “$1ses”),
new Plural(“(buffal|tomat)o$”, “$1oes”),
new Plural(“([ti])um$”, “$1a”),
new Plural(“sis$”, “ses”),
new Plural(“(?:([^f])fe|([lr])f)$”, “$1$2ves”),
new Plural(“(hive)$”, “$1s”),
new Plural(“([^aeiouy]|qu)y$”, “$1ies”),
new Plural(“(x|ch|ss|sh)$”, “$1es”),
new Plural(“(matr|vert|ind)ix|ex$”, “$1ices”),
new Plural(“([m|l])ouse$”, “$1ice”),
new Plural(“^(ox)$”, “$1en”),
new Plural(“(quiz)$”, “$1zes”)
};
///
/// Retorna a lista de regras de pluralização.
///
private static Plural[] Plurals
{
get
{
return plurals;
}
}
///
/// Relação de palavras irregulares.
///
private static string[][] irregular =
new string[][] {
new string[] {“person”, “people”},
new string[] {“man”, “men”},
new string[] {“child”, “children”},
new string[] {“sex”, “sexes”},
new string[] {“move”, “moves”}
};
///
/// Retorna o plural de uma palavra irregular.
///
/// A palavra.
/// O plural da palavra.
private static string Irregular(string word)
{
word = word.ToLower();
foreach(string[] s in irregular)
{
if (s[0].Equals(word))
return s[1];
}
return string.Empty;
}
///
/// Verifica se uma palavra é irregular.
///
/// A palavra.
/// Verdadeiro se a palavra for irregular.
private static bool IsIrregular(string word)
{
word = word.ToLower();
foreach(string[] s in irregular)
{
if (s[0].Equals(word))
return true;
}
return false;
}
///
/// Retorna o plural de uma palavra.
///
/// A palavra.
/// O plural da palavra.
public static string Pluralize(string word)
{
string result = word;
if (!Inflections.IsUncountable(word))
{
if (Inflections.IsIrregular(word))
return Inflections.Irregular(word);
else
{
foreach(Plural p in Inflections.Plurals)
{
if (p.Rule.Match(word).Success)
{
result = p.Rule.Replace(word, p.Replacement);
}
}
}
}
return result;
}
}
///
/// Representa uma regra de pluralização.
///
class Plural
{
///
/// Construtor da classe.
///
/// Uma expressão regular com a regra de pluralização.
/// A substituição necessária.
public Plural(string rule, string replacement)
{
this.rule = new Regex(rule);
this.replacement = replacement;
}
Regex rule;
string replacement;
///
/// A regra de pluralização.
///
public Regex Rule{ get{ return rule; } }
///
/// A substituição necessária.
///
public string Replacement{ get{ return replacement; } }
}
[/source]
Pois é, depois que aprendi Ruby, sou um programador muito pior…