Initial import

vendor/plugins/brazilian-rails/lib/action_view_portuguese.rb

@@ -0,0 +1,64 @@
+module ActionView::Helpers::ActiveRecordHelper
+  # Traduz as mensagens de erro do ActiveRecord
+  def error_messages_for(*params)
+    options = params.last.is_a?(Hash) ? params.pop.symbolize_keys : {}
+    objects = params.collect { |object_name| instance_variable_get('@'+object_name.to_s()) }
+    objects.compact!
+    count   = objects.inject(0) {|sum, object| sum + object.errors.count }
+    unless count.zero?
+      html = {}
+      [:id, :class].each do |key|
+        if options.include?(key)
+          value = options[key]
+          html[key] = value unless value.blank?
+        else
+          html[key] = 'errorExplanation'
+        end
+      end
+      header_message = "#{pluralize(count, 'erro')} para #{(options[:object_name] || params.first).to_s.gsub('_', ' ')}"
+      error_messages = objects.map { |object| object.errors.full_messages.map {|msg| content_tag(:li, msg) } }
+      content_tag(:div,
+      content_tag(options[:header_tag] || :h2, header_message) <<
+      content_tag(:p, 'Foram detectados os seguintes erros:') <<
+      content_tag(:ul, error_messages),
+      html
+      )
+    else
+      ''
+    end
+  end
+end
+
+module ActionView::Helpers::DateHelper
+  # Traduz o método distance_of_time_in_words para retornar esse valor em português
+  #
+  def distance_of_time_in_words(from_time, to_time = 0, include_seconds = false)
+    from_time = from_time.to_time if from_time.respond_to?(:to_time)
+    to_time = to_time.to_time if to_time.respond_to?(:to_time)
+    distance_in_minutes = (((to_time - from_time).abs)/60).round
+    distance_in_seconds = ((to_time - from_time).abs).round
+
+    case distance_in_minutes
+    when 0..1
+      return (distance_in_minutes == 0) ? 'menos de um minuto' : '1 minuto' unless include_seconds
+      case distance_in_seconds
+      when 0..4   then 'menos de 5 segundos'
+      when 5..9   then 'menos de 10 segundos'
+      when 10..19 then 'menos de 20 segundos'
+      when 20..39 then 'meio minuto'
+      when 40..59 then 'menos de um minuto'
+      else             '1 minuto'
+      end
+
+    when 2..44           then "#{distance_in_minutes} minutos"
+    when 45..89          then 'aproximadamente 1 hora'
+    when 90..1439        then "aproximadamente #{(distance_in_minutes.to_f / 60.0).round} horas"
+    when 1440..2879      then '1 dia'
+    when 2880..43199     then "#{(distance_in_minutes / 1440).round} dias"
+    when 43200..86399    then 'aproximadamente 1 mês'
+    when 86400..525959   then "#{(distance_in_minutes / 43200).round} meses"
+    when 525960..1051919 then 'aproximadamente 1 ano'
+    else                      "mais de #{(distance_in_minutes / 525960).round} anos"
+    end
+  end
+end

vendor/plugins/brazilian-rails/lib/active_record_portuguese.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  # Traduz as mensagens de erro do ActiveRecord
+  class Errors
+    @@default_error_messages = {
+      :inclusion => "não está incluído na lista",
+      :exclusion => "está reservado",
+      :invalid => "é inválido.",
+      :confirmation => "não corresponde à confirmação",
+      :accepted => "deve ser aceito",
+      :empty => "não pode estar vazio",
+      :blank => "não pode estar em branco",
+      :too_long => "muito longo (máximo %d caracteres)",
+      :too_short => "muito curto (mínimo %d caracteres)",
+      :wrong_length => "de comprimento errado (deveria ter %d caracteres)",
+      :taken => "já está em uso",
+      :not_a_number => "não é um número"
+    }
+  end
+end

vendor/plugins/brazilian-rails/lib/date_portuguese.rb

@@ -0,0 +1,40 @@
+module ActiveSupport::CoreExtensions::String::Conversions
+  # Cria a data no padrao brasileiro e permanece aceitando no formato tradicional.
+  #
+  # Exemplo:
+  # "27/09/2007".to_date
+  def to_date
+    if /(\d{1,2})\W(\d{1,2})\W(\d{4})/ =~ self
+      ::Date.new($3.to_i, $2.to_i, $1.to_i)
+    else
+      ::Date.new(*ParseDate.parsedate(self)[0..2])
+    end
+  end
+end
+
+class Date
+  # Retorna a data no padrao brasileiro
+  #
+  # Exemplo:
+  #  data = Date.new(2007, 9, 27)
+  #  data.to_s_br ==> "27/09/2007"
+  def to_s_br
+    strftime("%d/%m/%Y")
+  end
+  
+  # Valida se uma string eh uma data valida
+  #
+  # Exemplo:
+  #  Date.valid?('01/01/2007') ==> true
+  #  Date.valid?('32/01/2007') ==> false
+  def self.valid?(date)
+    begin
+      date = date.to_date
+      Date.valid_civil?(date.year, date.month, date.day)        
+    rescue
+      return false
+    end
+    true
+  end
+  
+end

vendor/plugins/brazilian-rails/lib/dinheiro.rb

@@ -0,0 +1,243 @@
+class Dinheiro
+  
+  include Comparable
+  
+  attr_reader :quantia
+  
+  FORMATO_VALIDO_BR  = /^([R|r]\$\s*)?(([+-]?\d{1,3}(\.?\d{3})*))?(\,\d{0,2})?$/
+  FORMATO_VALIDO_EUA = /^([R|r]\$\s*)?(([+-]?\d{1,3}(\,?\d{3})*))?(\.\d{0,2})?$/
+  SEPARADOR_MILHAR = "."
+  SEPARADOR_FRACIONARIO = ","
+  QUANTIDADE_DIGITOS = 3
+  PRECISAO_DECIMAL = 100
+  
+  def initialize(quantia)
+    self.quantia = quantia
+  end
+  
+  # Retorna o valor armazenado em string.
+  #
+  # Exemplo:
+  #  1000.to_s ==> '1.000,00'
+  def to_s
+    inteiro_com_milhar(parte_inteira) + parte_decimal
+  end
+  
+  # Compara com outro dinheiro se eh igual.
+  #
+  # Exemplo:
+  #  um_real = Dinheiro.new(1)
+  #  um_real == Dinheiro.new(1) ==> true
+  #  um_real == Dinheiro.new(2) ==> false
+  def ==(outro_dinheiro)
+    outro_dinheiro = Dinheiro.new(outro_dinheiro) unless outro_dinheiro.kind_of?(Dinheiro)
+    @quantia == outro_dinheiro.quantia
+  end
+  
+  # Compara com outro dinheiro se eh maior ou menor.
+  #
+  # Exemplo:
+  #  1.real < 2.reais ==> true
+  #  1.real > 2.reais ==> false
+  #  2.real < 1.reais ==> false
+  #  2.real > 1.reais ==> true
+  def <=>(outro_dinheiro)
+    outro_dinheiro = Dinheiro.new(outro_dinheiro) unless outro_dinheiro.kind_of?(Dinheiro)
+    @quantia <=> outro_dinheiro.quantia
+  end
+  
+  # Retorna a adicao entre dinheiros.
+  def +(outro)
+    Dinheiro.new(transforma_em_string_que_represente_a_quantia(@quantia + quantia_de(outro)))
+  end
+  
+  # Retorna a subtracao entre dinheiros.
+  def -(outro)
+    Dinheiro.new(transforma_em_string_que_represente_a_quantia(@quantia - quantia_de(outro)))
+  end
+  
+  # Retorna a multiplicacao entre dinheiros.
+  def *(outro)
+    return Dinheiro.new(to_f * outro) unless outro.kind_of? Dinheiro
+    outro * to_f
+  end
+  
+  # Retorna a divisao entre dinheiros.
+  def /(outro)
+    raise DivisaPorNaoEscalarError unless outro.kind_of?(Numeric)
+    return @quantia/outro if outro == 0
+    soma_parcial = Dinheiro.new(0)
+    parcelas = []
+    (outro-1).times do
+      parcela = Dinheiro.new(transforma_em_string_que_represente_a_quantia(@quantia/outro))
+      parcelas << parcela
+      soma_parcial += parcela
+    end
+    parcelas << Dinheiro.new(transforma_em_string_que_represente_a_quantia(@quantia - quantia_de(soma_parcial)))
+  end
+  
+  # Escreve o valor por extenso.
+  # 
+  # Exemplo:
+  #  1.real.por_extenso ==> 'um real'
+  #  (100.58).por_extenso ==> 'cem reais e cinquenta e oito centavos'
+  def por_extenso
+    (@quantia/100.0).por_extenso_em_reais
+  end
+  
+  # Alias para o metodo por_extenso.
+  alias_method :por_extenso_em_reais, :por_extenso
+  
+  # DEPRECATION WARNING: use por_extenso ou por_extenso_em_reais, pois este sera removido no proximo release.
+  def to_extenso
+    warn("DEPRECATION WARNING: use por_extenso ou por_extenso_em_reais, pois este sera removido no proximo release.")
+    self.por_extenso
+  end
+  
+  # Retorna um Float.
+  def to_f
+    to_s.gsub(',', '.').to_f
+  end
+  
+  def coerce(outro)
+    [ Dinheiro.new(outro), self ]
+  end
+  
+  # Retorna uma string formatada em valor monetario.
+  #
+  # Exemplo:
+  #  Dinheiro.new(1).real ==> 'R$ 1,00'
+  #  Dinheiro.new(-1).real ==> 'R$ -1,00'
+  def real
+    "R$ " + to_s
+  end
+  
+  # Retorna uma string formatada em valor monetario.
+  #
+  # Exemplo:
+  #  Dinheiro.new(1).real ==> 'R$ 1,00'
+  #  Dinheiro.new(-1).real ==> 'R$ (1,00)'
+  def real_contabil
+    "R$ " + contabil
+  end
+  
+  # Alias para real.
+  alias_method :reais, :real
+  
+  # Alias para real_contabil.
+  alias_method :reais_contabeis, :real_contabil
+  
+  # Retorna uma string formatada.
+  #
+  # Exemplo:
+  #  Dinheiro.new(1).contabil ==> '1,00'
+  #  Dinheiro.new(-1).contabil ==> '(1,00)'
+  def contabil
+    if @quantia >= 0
+      to_s      
+    else  
+      "(" + to_s[1..-1] + ")"    
+    end  
+  end
+  
+  # Retorna um BigDecinal.
+  def valor_decimal
+    BigDecimal.new quantia_sem_separacao_milhares.gsub(',','.')
+  end
+    
+  private
+  def quantia_de(outro)
+    outro = outro.to_f if outro.kind_of?(BigDecimal)
+    return outro.quantia if outro.kind_of?(Dinheiro)
+    (outro * 100).round
+  end
+  
+  def transforma_em_string_que_represente_a_quantia(quantia)
+    if /^([+-]?)(\d)$/ =~ quantia.to_s
+      return "#{$1}0.0#{$2}"
+    end
+    /^([+-]?)(\d*)(\d\d)$/ =~ quantia.to_s
+    "#{$1}#{$2.to_i}.#{$3}"
+  end
+  
+  def quantia=(quantia)
+    raise DinheiroInvalidoError unless quantia_valida?(quantia)
+    quantia = quantia.to_f if quantia.kind_of?(BigDecimal)
+    @quantia = (quantia * 100).round if quantia.kind_of?(Numeric)
+    @quantia = extrai_quantia_como_inteiro(quantia) if quantia.kind_of?(String)
+  end
+  
+  def parte_inteira
+    quantia_sem_separacao_milhares[0,quantia_sem_separacao_milhares.length-QUANTIDADE_DIGITOS]
+  end
+  
+  def parte_decimal
+    quantia_sem_separacao_milhares[-QUANTIDADE_DIGITOS, QUANTIDADE_DIGITOS]
+  end
+  
+  def inteiro_com_milhar(inteiro)
+    return inteiro if quantidade_de_passos(inteiro) == 0
+    resultado = ""
+    quantidade_de_passos(inteiro).times do |passo| 
+      resultado = "." + inteiro[-QUANTIDADE_DIGITOS + passo * -QUANTIDADE_DIGITOS, QUANTIDADE_DIGITOS] + resultado            
+    end
+    resultado = inteiro[0, digitos_que_sobraram(inteiro)] + resultado
+    resultado.gsub(/^(-?)\./, '\1')
+  end
+  
+  def quantia_sem_separacao_milhares
+    sprintf("%.2f", (@quantia.to_f / PRECISAO_DECIMAL)).gsub(SEPARADOR_MILHAR, SEPARADOR_FRACIONARIO)
+  end  
+  
+  def quantidade_de_passos(inteiro)
+    resultado = inteiro.length / QUANTIDADE_DIGITOS
+    resultado = (resultado - 1) if inteiro.length % QUANTIDADE_DIGITOS == 0
+    resultado
+  end
+  
+  def digitos_que_sobraram(inteiro)
+    inteiro.length - (quantidade_de_passos(inteiro) * QUANTIDADE_DIGITOS)
+  end
+  
+  def quantia_valida?(quantia)
+    return false if quantia.kind_of?(String) && !quantia_respeita_formato?(quantia)
+    quantia.kind_of?(String) || quantia.kind_of?(Numeric)
+  end
+   
+  def extrai_quantia_como_inteiro(quantia)
+    if FORMATO_VALIDO_BR =~ quantia
+      return sem_milhar($2, $5, '.')
+    end
+    if FORMATO_VALIDO_EUA =~ quantia 
+      return sem_milhar($2, $5, ',')
+    end
+  end
+  
+  def sem_milhar(parte_inteira, parte_decimal, delimitador_de_milhar)
+    (inteiro(parte_inteira, delimitador_de_milhar) + decimal(parte_decimal)).to_i
+  end
+  
+  def inteiro(inteiro_com_separador_milhar, separador)
+    return inteiro_com_separador_milhar.gsub(separador, '') unless inteiro_com_separador_milhar.blank?
+    ""
+  end
+  
+  def decimal(parte_fracionaria)
+    unless parte_fracionaria.blank?
+      return sem_delimitador_decimal(parte_fracionaria) if parte_fracionaria.length == 3
+      return sem_delimitador_decimal(parte_fracionaria) + "0" if parte_fracionaria.length == 2
+    end
+    "00"
+  end
+  
+  def sem_delimitador_decimal(parte_fracionaria)
+    "#{parte_fracionaria}".gsub(/[.|,]/, '')
+  end
+  
+  
+  def quantia_respeita_formato?(quantia)
+    return true if FORMATO_VALIDO_BR.match(quantia) || FORMATO_VALIDO_EUA.match(quantia)
+    false
+  end
+  
+end

vendor/plugins/brazilian-rails/lib/dinheiro_util.rb

@@ -0,0 +1,42 @@
+module DinheiroUtil
+  # Transforma numero em dinheiro
+  #
+  # Exemplo:
+  #  1.para_dinheiro.class ==> Dinheiro
+  def para_dinheiro
+    Dinheiro.new(self)
+  end
+  
+  # Alias para para_dinheiro
+  alias_method :reais, :para_dinheiro
+  
+  # Alias para para_dinheiro
+  alias_method :real, :para_dinheiro
+  
+  # Retorna string formatada com simbolo monetario
+  #
+  # Exemplo:
+  #  1.real_contabil ==> 'R$ 1,00'
+  #  -1.real_contabil ==> 'R$ (1,00)'
+  def real_contabil
+    Dinheiro.new(self).real_contabil
+  end
+  
+  # Retorna string formatada com simbolo monetario
+  #
+  # Exemplo:
+  #  2.reais_contabeis ==> 'R$ 2,00'
+  #  -2.reais_contabeis ==> 'R$ 2,00'
+  def reais_contabeis
+    Dinheiro.new(self).reais_contabeis
+  end
+  
+  # Retorna string formatada com simbolo monetario
+  #
+  # Exemplo:
+  #  1.contabil ==> '1,00'
+  #  -1.contabil ==> '(1,00)'
+  def contabil
+    Dinheiro.new(self).contabil
+  end
+end

vendor/plugins/brazilian-rails/lib/excecoes.rb

@@ -0,0 +1,7 @@
+def cria_excecao(classe, mensagem)
+  eval "class #{classe}; def initialize; super('#{mensagem}'); end; end"
+end
+  
+cria_excecao("DinheiroInvalidoError < ArgumentError", "O valor deve estar preenchido e no formato correto. Ex.: 100.00 .")
+cria_excecao("DivisaPorNaoEscalarError < ArgumentError", "So eh possivel dividir dinheiro por numeros.")
+

vendor/plugins/brazilian-rails/lib/inflector_portuguese.rb

@@ -0,0 +1,45 @@
+module Inflector
+  Inflector.inflections do |inflect|
+    inflect.plural /^([a-zA-z]*)r$/i, '\1res'
+    inflect.plural /^([a-zA-z]*)z$/i, '\1zes'
+    
+    inflect.plural /^([a-zA-z]*)al$/i, '\1ais'
+    inflect.plural /^([a-zA-z]*)el$/i, '\1eis'
+    inflect.plural /^([a-zA-z]*)ol$/i, '\1ois'
+    inflect.plural /^([a-zA-z]*)ul$/i, '\1uis'
+
+    inflect.plural /^([a-zA-z]*)il$/i, '\1is'
+    
+    inflect.plural /^([a-zA-z]*)m$/i, '\1ns'
+
+    inflect.plural /^([a-zA-z]*)([aeiou]s)$/i, '\1\2es'
+    
+    inflect.plural /^([a-zA-z]*)ão$/i, '\1ões'
+    
+    inflect.singular /^([a-zA-z]*)as$/i, '\1a'
+    inflect.singular /^([a-zA-z]*)es$/i, '\1e'
+    inflect.singular /^([a-zA-z]*)is$/i, '\1i'
+    inflect.singular /^([a-zA-z]*)os$/i, '\1o'
+    inflect.singular /^([a-zA-z]*)us$/i, '\1u'
+
+    inflect.singular /^([a-zA-z]*)res$/i, '\1r'
+    inflect.singular /^([a-zA-z]*)zes$/i, '\1z'
+
+    inflect.singular /^([a-zA-z]*)ais$/i, '\1al'
+    inflect.singular /^([a-zA-z]*)eis$/i, '\1el'
+    inflect.singular /^([a-zA-z]*)ois$/i, '\1ol'
+    inflect.singular /^([a-zA-z]*)uis$/i, '\1ul'
+
+    inflect.singular /^([a-zA-z]*)ns$/i, '\1m'
+    inflect.singular /^([a-zA-z]*)ões$/i, '\1ão'
+    inflect.singular /^([a-zA-z]*)ães$/i, '\1ão'
+    inflect.singular /^([a-zA-z]*)ãos$/i, '\1ão'
+
+    inflect.irregular 'cão', 'cães'
+    inflect.irregular 'pão', 'pães'
+    inflect.irregular 'mão', 'mãos'
+    inflect.irregular 'alemão', 'alemães'
+
+    inflect.uncountable %w( tennis torax )
+  end  
+end

vendor/plugins/brazilian-rails/lib/nil_class.rb

@@ -0,0 +1,24 @@
+class NilClass
+
+  def valor
+    ""
+  end
+
+  def valor_contabil
+    ""
+  end
+  
+  def para_dinheiro
+    ""
+  end
+
+  def reais
+    ""
+  end
+
+  def real
+    ""
+  end  
+
+end
+

vendor/plugins/brazilian-rails/lib/number_portuguese.rb

@@ -0,0 +1,158 @@
+module Extenso 
+  @@unidade = {
+    0 => "zero",  
+    1 => "um",  
+    2 => "dois",  
+    3 => "três",  
+    4 => "quatro",  
+    5 => "cinco",  
+    6 => "seis",  
+    7 => "sete",  
+    8 => "oito",  
+    9 => "nove" 
+  }
+  @@dezena = {
+    10 => "dez",  
+    11 => "onze",  
+    12 => "doze",  
+    13 => "treze",  
+    14 => "quatorze",  
+    15 => "quinze",  
+    16 => "dezesseis",  
+    17 => "dezessete",  
+    18 => "dezoito",  
+    19 => "dezenove",  
+    20 => "vinte",  
+    30 => "trinta",  
+    40 => "quarenta",  
+    50 => "cinquenta",  
+    60 => "sessenta",  
+    70 => "setenta",  
+    80 => "oitenta",  
+    90 => "noventa"  }
+  @@centena = {100 => "cento",  
+    200 => "duzentos",  
+    300 => "trezentos",  
+    400 => "quatrocentos",  
+    500 => "quinhentos",  
+    600 => "seiscentos",  
+    700 => "setecentos",  
+    800 => "oitocentos",  
+    900 => "novecentos"  }
+  
+  # Escreve o numero por extenso.
+  # 
+  # Exemplo:
+  #  1.por_extenso ==> 'um'
+  #  100.por_extenso ==> 'cem'
+  #  158.por_extenso ==> 'cento e cinquenta e oito'
+  def por_extenso
+    Extenso.por_extenso(self)
+  end
+
+  # DEPRECATION WARNING: use por_extenso, pois este sera removido no proximo release.
+  def to_extenso
+    warn('DEPRECATION WARNING: use por_extenso, pois este sera removido no proximo release.')
+    self.por_extenso
+  end
+  
+  # Escreve o numero por extenso.
+  # 
+  # Exemplo:
+  #  Extenso.por_extenso(1) ==> "um"
+  #  Extenso.por_extenso(100) ==> "cem"
+  #  Extenso.por_extenso(158) ==> "cento e cinquenta e oito"  
+  def Extenso.por_extenso(numero)
+    n=numero.to_i.abs
+    return case n
+    when 0..9: @@unidade[n].to_s 
+    when 10..19: @@dezena[n].to_s
+    when 20..99:
+      v=n % 10
+      if  v== 0
+        @@dezena[n].to_s
+      else
+        "#{@@dezena[n-v]} e #{por_extenso(v)}"
+      end
+    when 100
+      "cem"     
+    when 101..999
+      v=n % 100
+      if  v== 0
+        @@centena[n].to_s
+      else
+        "#{@@centena[n-v]} e #{por_extenso(v)}"
+      end
+    when 1000..999999  
+      m,c=n/1000,n%1000
+      %(#{por_extenso(m)} mil#{c > 0 ? " e #{por_extenso(c)}":''})
+    when 1_000_000..999_999_999
+      mi,m=n/1_000_000,n%1_000_000
+      %(#{por_extenso(mi)} milh#{mi > 1 ? 'ões':'ão'}#{m > 0 ? " e #{por_extenso(m)}" : ''})
+    when 1_000_000_000..999_999_999_999
+      bi,mi=n/1_000_000_000,n%1_000_000_000
+      %(#{por_extenso(bi)} bilh#{bi > 1 ? 'ões':'ão'}#{mi > 0 ? " e #{por_extenso(mi)}" : ''})
+    when 1_000_000_000_000..999_999_999_999_999
+      tri,bi=n/1_000_000_000_000,n%1_000_000_000_000
+      %(#{por_extenso(tri)} trilh#{tri > 1 ? 'ões':'ão'}#{bi > 0 ? " e #{por_extenso(bi)}" : ''})
+    else
+      raise "Valor excede o permitido: #{n}"
+    end
+  end
+end
+
+module ExtensoReal
+  include Extenso
+ 
+  # Escreve por extenso em reais.
+  # 
+  # Exemplo:
+  #  1.por_extenso_em_reais ==> 'um real'
+  #  (100.58).por_extenso_em_reais ==> 'cem reais e cinquenta e oito centavos'
+  def por_extenso_em_reais
+    ExtensoReal.por_extenso_em_reais(self.to_s)
+  end
+
+  # DEPRECATION WARNING: use por_extenso_em_reais, pois este sera removido no proximo release.
+  def to_extenso_real
+    warn('DEPRECATION WARNING: use por_extenso_em_reais, pois este sera removido no proximo release.')
+    self.por_extenso_em_reais
+  end
+ 
+  # Escreve o numero por extenso em reais.
+  # 
+  # Exemplo:
+  #  Extenso.por_extenso_em_reais(1) ==> "um real"
+  #  Extenso.por_extenso_em_reais(100) ==> "cem reais"
+  #  Extenso.por_extenso_em_reais(100.58) ==> "cem reais e cinquenta e oito centavos"  
+  def ExtensoReal.por_extenso_em_reais(valor)
+    return 'grátis' if valor == 0
+    case valor
+    when Integer 
+      extenso = Extenso.por_extenso(valor)
+      if extenso =~ /^(.*)(ão$|ões$)/
+        complemento = 'de '
+      else
+        complemento = ''
+      end
+      %(#{extenso} #{valor <= 1 ? 'real': "#{complemento}reais"})
+    when Float
+      real,cents=("%.2f" % valor).split(/\./).map{ |m| m.to_i}
+      valor_cents=Extenso.por_extenso(cents%100)
+       
+      valor_cents+= case cents.to_i%100
+      when 0: ""
+      when 1: " centavo"
+      when 2..99: " centavos"
+      end 
+       
+      if real.to_i > 0
+        "#{ExtensoReal.por_extenso_em_reais(real.to_i)}#{cents > 0 ? ' e ' + valor_cents : ''}"
+      else
+        "#{valor_cents}"
+      end
+    else
+      ExtensoReal.por_extenso_em_reais(valor.to_s.strip.gsub(/[^\d]/,'.').to_f)
+    end
+  end
+end

vendor/plugins/brazilian-rails/lib/string_portuguese.rb

@@ -0,0 +1,46 @@
+module StringPortuguese
+  MINUSCULAS_COM_ACENTO = 'áéíóúâêîôûàèìòùäëïöüãõñç'
+  MAIUSCULAS_COM_ACENTO = 'ÁÉÍÓÚÂÊÎÔÛÀÈÌÒÙÄËÏÖÜÃÕÑÇ'
+  
+  # Normaliza nomes proprios
+  #
+  # Exemplo:
+  #  'maria de souza dos santos e silva da costa'.nome_proprio ==> 'Maria de Souza dos Santos e Silva da Costa'
+  def nome_proprio
+    palavras = []
+    self.titleize().each do |palavra|
+      palavra =~ /^(.)(.*)$/
+      palavras << "#{$1.upcase_br}#{$2}"
+    end
+    palavras.join(' ').gsub(/ D(a|e|o|as|os) /, ' d\1 ').gsub(/ E /, ' e ')
+  end
+  
+  # Remove as letras acentuadas
+  # 
+  # Exemplo:
+  #  'texto está com acentuação'.remover_acentos ==> 'texto esta com acentuacao'
+  def remover_acentos
+    texto = self
+    texto = texto.gsub(/[á|à|ã|â|ä]/, 'a').gsub(/(é|è|ê|ë)/, 'e').gsub(/(í|ì|î|ï)/, 'i').gsub(/(ó|ò|õ|ô|ö)/, 'o').gsub(/(ú|ù|û|ü)/, 'u')
+    texto = texto.gsub(/(Á|À|Ã|Â|Ä)/, 'A').gsub(/(É|È|Ê|Ë)/, 'E').gsub(/(Í|Ì|Î|Ï)/, 'I').gsub(/(Ó|Ò|Õ|Ô|Ö)/, 'O').gsub(/(Ú|Ù|Û|Ü)/, 'U')
+    texto = texto.gsub(/ñ/, 'n').gsub(/Ñ/, 'N')
+    texto = texto.gsub(/ç/, 'c').gsub(/Ç/, 'C')
+    texto
+  end
+  
+  # Retorna uma string com caracteres maiusculos
+  # 
+  # Exemplo:
+  #  'texto com acentuação'.upcase_br ==> 'TEXTO COM ACENTUAÇÃO'
+  def upcase_br
+    self.tr(MINUSCULAS_COM_ACENTO, MAIUSCULAS_COM_ACENTO).upcase
+  end
+
+  # Retorna uma string com caracteres minúsculos
+  # 
+  # Exemplo:
+  #  'TEXTO COM ACENTUAÇÃO'.downcase_br ==> 'texto com acentuação'
+  def downcase_br
+    self.tr(MAIUSCULAS_COM_ACENTO, MINUSCULAS_COM_ACENTO).downcase
+  end
+end

vendor/plugins/brazilian-rails/lib/time_portuguese.rb

@@ -0,0 +1,10 @@
+class Time
+  # Retorna a hora no padrao brasileiro
+  #
+  # Exemplo:
+  #  hora = Time.new
+  #  hora.to_s_br ==> "27/09/2007 13:54"
+  def to_s_br
+    self.strftime("%d/%m/%Y %H:%M")
+  end
+end