brdinheiro 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+require File.join(File.dirname(__FILE__), 'lib', 'brdinheiro', 'version')
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'brdinheiro'
+PKG_VERSION   = BrDinheiro::VERSION::STRING + PKG_BUILD
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "brdinheiro"
+RUBY_FORGE_USER    = "tapajos"
+
+desc "Default Task"
+task :default => [ :test ]
+
+# Run the unit tests
+Rake::TestTask.new { |t|
+  t.libs << "test"
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+  t.warning = false
+}
+
+
+# Generate the RDoc documentation
+# Rake::RDocTask.new { |rdoc|
+#   rdoc.rdoc_dir = 'doc'
+#   rdoc.title    = "Action Mailer -- Easy email delivery and testing"
+#   rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+#   rdoc.options << '--charset' << 'utf-8'
+#   rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+#   rdoc.rdoc_files.include('README', 'CHANGELOG')
+#   rdoc.rdoc_files.include('lib/action_mailer.rb')
+#   rdoc.rdoc_files.include('lib/action_mailer/*.rb')
+# }
+
+
+# Create compressed packages
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = PKG_NAME
+  s.summary = "brdinheiro é uma das gems que compoem o Brazilian Rails"
+  s.description = %q{brdinheiro é uma das gems que compoem o Brazilian Rails}
+  s.version = PKG_VERSION
+
+  s.author = "Marcos Tapajós"
+  s.email = "tapajos@gmail.com"
+  s.rubyforge_project = "brdinheiro"
+  s.homepage = "http://www.improveit.com.br/software_livre/brazilian_rails"
+
+  s.add_dependency('actionpack', '>= 1.4.2')
+  s.add_dependency('activerecord', '>= 1.15.3')
+
+  s.has_rdoc = true
+  s.requirements << 'none'
+  s.require_path = 'lib'
+  # s.autorequire = 'brdinheiro'
+
+  s.files = [ "Rakefile", "README", "CHANGELOG", "TODO", "MIT-LICENSE" ]
+  s.files = s.files + Dir.glob( "lib/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+  s.files = s.files + Dir.glob( "test/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+end
+  
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+
+# desc "Publish the API documentation"
+# task :pgem => [:package] do 
+#   Rake::SshFilePublisher.new("wrath.rubyonrails.org", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
+# end
+# 
+# desc "Publish the API documentation"
+# task :pdoc => [:rdoc] do 
+#   Rake::SshDirPublisher.new("wrath.rubyonrails.org", "public_html/am", "doc").upload
+# end
+# 
+
+desc "Publish the release files to RubyForge."
+task :release => [ :package ] do
+  require 'rubyforge'
+  require 'rake/contrib/rubyforgepublisher'
+  
+  packages = %w( gem tgz zip ).collect{ |ext| "pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" }
+  
+  rubyforge = RubyForge.new
+  rubyforge.configure
+  rubyforge.login
+  rubyforge.add_release(PKG_NAME, PKG_NAME, "REL #{PKG_VERSION}", *packages)
+end

data/TODO

@@ -0,0 +1,5 @@
+# gem brdinheiro
+
+## testes do dinheiro_active_record
+## Ajustar o README
+## Verificar como regrar a documentação.

data/lib/brdinheiro/dinheiro.rb

@@ -0,0 +1,349 @@
+# == Como usar o Dinheiro em seu ActiveRecord?
+# 
+# * Arquivo 001_create_lancamentos.rb:
+# 
+#     class CreateLancamentos < ActiveRecord::Migration
+#       def self.up
+#         create_table :lancamentos do |t|
+#           t.column :descricao,   :string,    :null => false
+#           t.column :valor,       :decimal,   :precision => 14, :scale => 2
+#           t.column :mensalidade, :decimal,   :precision => 14, :scale => 2
+#         end
+#       end
+#
+#       def self.down
+#         drop_table :lancamentos
+#       end
+#     end
+# 
+# * Arquivo lancamento.rb:
+# 
+#     class Lancamento < ActiveRecord::Base
+#       usar_como_dinheiro :valor, :mensalidade
+#     end
+#
+# * No console (script/console):
+# 
+#     Loading development environment.
+#     >> lancamento = Lancamento.new
+#     => #<Lancamento:0x9652cd8 @attributes={"descricao"=>nil, 
+#                                            "valor"=>#<BigDecimal:9657008,'0.0',4(4)>, 
+#                                            "mensalidade"=>#<BigDecimal:9656e8c,'0.0',4(4)>}, 
+#                               @new_record=true>
+#     >> lancamento.valor = 100
+#     => 100
+#     >> lancamento.valor
+#     => #<Dinheiro:0x9650f3c @quantia=10000>
+#     >> lancamento.valor.real
+#     => "R$ 100,00"
+#     >> lancamento.valor = 100.50
+#     => 100.5
+#     >> lancamento.valor.real
+#     => "R$ 100,50"
+#     >> lancamento.valor = "250.50"
+#     => "250.50"
+#     >> lancamento.valor.real
+#     => "R$ 250,50"
+#     >> lancamento.valor = 354.58.reais
+#     => #<Dinheiro:0x9646384 @quantia=35458>
+#     >> lancamento.valor.real
+#     => "R$ 354,58"
+#     >> exit
+#  
+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)
+    begin 
+      outro_dinheiro = Dinheiro.new(outro_dinheiro) unless outro_dinheiro.kind_of?(Dinheiro)
+    rescue
+      return false
+    end
+    @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.
+  #
+  # Exemplo:
+  #  1.real + 1.real == 2.reais 
+  #  1.real + 1 == 2.reais 
+  def +(outro)
+    Dinheiro.new(transforma_em_string_que_represente_a_quantia(@quantia + quantia_de(outro)))
+  end
+  
+  # Retorna a subtracao entre dinheiros.
+  #
+  # Exemplo:
+  #  10.reais - 2.reais == 8.reais 
+  #  10.reais - 2 == 8.reais 
+  def -(outro)
+    Dinheiro.new(transforma_em_string_que_represente_a_quantia(@quantia - quantia_de(outro)))
+  end
+  
+  # Retorna a multiplicacao entre dinheiros.
+  #
+  # Exemplo:
+  #  5.reais * 2 == 10.reais
+  #  5.reais * 2.reais == 10.reais
+  def *(outro)
+    return Dinheiro.new(to_f * outro) unless outro.kind_of? Dinheiro
+    outro * to_f
+  end
+  
+  # Retorna a divisao entre dinheiros.
+  #
+  # Exemplo:
+  #  5.reais / 2 == (2.5).reais
+  #  5.reais / 2.reais == DivisaPorNaoEscalarError
+  #  5.reais / 0 == ZeroDivisionError
+  #
+  # Veja também o método parcelar
+  def /(outro)
+    raise DivisaPorNaoEscalarError unless outro.kind_of?(Numeric)
+    return @quantia/outro if outro == 0
+    Dinheiro.new(to_f / outro.to_f)
+  end
+
+  # Retorna um array de dinheiro com as parcelas
+  #
+  # Exemplo:
+  #  6.reais.parcelar(2) == [3.reais, 3.reais]
+  #  6.reais.parcelar(2.reais) == DisivaPorNaoEscalarError
+  #  6.reais.parcelar(0) == ZeroDivisionError
+  def parcelar(numero_de_parcelar)
+    Fixnum
+    raise DivisaPorNaoEscalarError unless numero_de_parcelar.kind_of?(Integer)
+    return @quantia/numero_de_parcelar if numero_de_parcelar == 0
+    soma_parcial = Dinheiro.new(0)
+    parcelas = []
+    (numero_de_parcelar-1).times do
+      parcela = Dinheiro.new(transforma_em_string_que_represente_a_quantia(@quantia/numero_de_parcelar))
+      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.to_extenso ==> 'um real'
+  #  (100.58).to_extenso ==> 'cem reais e cinquenta e oito centavos'
+  def to_extenso
+    (@quantia/100.0).por_extenso_em_reais
+  end
+  
+  # Alias para o metodo to_extenso.
+  alias_method :por_extenso, :to_extenso
+  
+  # Alias para o metodo to_extenso.
+  alias_method :por_extenso_em_reais, :to_extenso
+  
+  # Verifica se o valor é zero.
+  def zero?
+    to_f.zero?
+  end
+  
+  # Retorna um Float.
+  def to_f
+    to_s.gsub('.', '').gsub(',', '.').to_f
+  end
+  
+  def coerce(outro)#:nodoc:
+    [ Dinheiro.new(outro), self ]
+  end
+  
+  # Retorna a própria instância/
+  def real
+    self
+  end
+  
+  # Alias para real.
+  alias_method :reais, :real
+  
+  # Retorna uma string formatada com sigla em valor monetário.
+  # Exemplo:
+  #  Dinheiro.new(1).real_formatado ==> 'R$ 1,00'
+  #  Dinheiro.new(-1).real_formatado ==> 'R$ -1,00'
+  def real_formatado
+    "R$ #{to_s}"
+  end
+  
+  # Alias para real_formatado.
+  alias_method :reais_formatado, :real_formatado
+  
+  # Retorna uma string formatada com sigla em valor contábil.
+  #
+  # Exemplo:
+  #  Dinheiro.new(1).real_contabil ==> 'R$ 1,00'
+  #  Dinheiro.new(-1).real_contabil ==> 'R$ (1,00)'
+  def real_contabil
+    "R$ " + contabil
+  end
+  
+  # Alias para real_contabil.
+  alias_method :reais_contabeis, :real_contabil
+  
+  # Retorna uma string formatada sem sigla.
+  #
+  # 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
+  
+  def method_missing(symbol, *args) #:nodoc:
+    #Ex: Chama ao método valor_decimal() 
+    if (symbol.to_s =~ /^(.*)_decimal$/) && args.size == 0
+      BigDecimal.new quantia_sem_separacao_milhares.gsub(',','.')
+    else
+      super.method_missing(symbol, *args)
+    end
+  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

data/lib/brdinheiro/dinheiro_active_record.rb

@@ -0,0 +1,41 @@
+module DinheiroActiveRecord#:nodoc:
+  def self.included(base)#:nodoc:
+    base.extend ClassMethods
+  end
+  module ClassMethods#:nodoc:
+    def usar_como_dinheiro(*args)#:nodoc:
+      unless args.size.zero?
+        args.each do |name|
+          composed_of name, :class_name => 'Dinheiro', :mapping => [name.to_s, "valor_decimal"], :allow_nil => true
+
+          name = name.to_s
+          module_eval <<-ADICIONANDO_METODO
+          validate :#{name}_valido?
+
+          def #{name}_valido?
+            begin
+              @#{name}.to_s.reais
+            rescue Exception => e
+              self.errors.add('#{name}', e.message)
+            end
+          end
+
+          def #{name}=(value)
+            if value.nil?
+              write_attribute('#{name}', nil)
+            elsif value.kind_of?(Dinheiro)
+              write_attribute('#{name}', value.valor_decimal)
+            else
+              begin
+                write_attribute('#{name}', value.reais.valor_decimal)
+              rescue
+                @#{name} = value
+              end
+            end
+          end
+          ADICIONANDO_METODO
+        end
+      end
+    end
+  end
+end

data/lib/brdinheiro/dinheiro_util.rb

@@ -0,0 +1,43 @@
+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
+

data/lib/brdinheiro/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.")
+