brdinheiro-lite 0.0.1

data/CHANGELOG

@@ -0,0 +1 @@
+Version 0.0.1 -> Versão alpha da gem.

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/README

@@ -0,0 +1,3 @@
+Esse projeto é uma versão mais leve da gem brdinheiro, sem integração com as gems ActiveRecord e brnumeros.
+
+AVISO: Esta versão ainda é ALPHA, erros podem acontecer ainda, então use por sua conta e risco :)

data/Rakefile

@@ -0,0 +1,66 @@
+# encoding: UTF-8
+
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+
+require File.join(File.dirname(__FILE__), 'lib', 'brdinheiro_lite', 'version')
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'brdinheiro-lite'
+PKG_VERSION   = BrDinheiro::VERSION::STRING + PKG_BUILD
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+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    = "brdinheiro-lite"
+  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/**/*')
+}
+
+# Create compressed packages
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = PKG_NAME
+  s.summary = "brdinheiro-lite é uma versão simplificada da gem brdinheiro do Brazilian Rails"
+  s.description = %q{brdinheiro-lite é uma versão simplificada da gem brdinheiro do Brazilian Rails}
+  s.version = PKG_VERSION
+
+  s.authors = ["Marcos Tapajós", "Celestino Gomes", "Andre Kupkosvki", "Vinícius Teles", "Rafael Souza"]
+  s.email = "me@rafaelss.com"
+  s.rubyforge_project = "brdinheiro-lite"
+  s.homepage = "http://rafaelss.com/brdinheiro-lite"
+
+  s.has_rdoc = true
+  s.require_path = 'lib'
+
+  s.files = [ "Rakefile", "README", "CHANGELOG", "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

data/lib/brdinheiro_lite/dinheiro.rb

@@ -0,0 +1,286 @@
+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)
+    raise DivisaPorNaoEscalarError unless numero_de_parcelar.kind_of?(Integer)
+    resto = @quantia % numero_de_parcelar
+    valor_menor = Dinheiro.new((@quantia/numero_de_parcelar)/100.0)
+    valor_maior = Dinheiro.new((@quantia/numero_de_parcelar+1)/100.0)
+    [valor_menor] * (numero_de_parcelar - resto) + [valor_maior] * resto
+  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
+  
+  # Method missing para retorna um BigDecinal quando chamada .
+  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_lite/dinheiro_util.rb

@@ -0,0 +1,51 @@
+module DinheiroUtil
+
+  # Ao incluir o modulo, cria aliases para_dinheiro
+  def self.included(base)
+    base.class_eval do
+      # Alias para para_dinheiro
+      alias_method :real, :para_dinheiro
+
+      # Alias para para_dinheiro
+      alias_method :reais, :para_dinheiro
+    end
+  end
+
+  # Transforma numero em dinheiro
+  #
+  # Exemplo:
+  #  1.para_dinheiro.class ==> Dinheiro
+  def para_dinheiro
+    Dinheiro.new(self)
+  end
+
+  # 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
+
+Numeric.send(:include, DinheiroUtil)
+String.send(:include, DinheiroUtil)

data/lib/brdinheiro_lite/excecoes.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+class DinheiroInvalidoError < ArgumentError
+  def initialize
+    super('O valor deve estar preenchido e no formato correto. Ex.: 100.00 .')
+  end
+end
+
+class DivisaPorNaoEscalarError < ArgumentError
+  def initialize
+    super('Só é possível dividir dinheiro por numeros.')
+  end
+end

data/lib/brdinheiro_lite/extenso.rb

@@ -0,0 +1,101 @@
+# encoding: UTF-8
+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
+  
+  # Alias para o metodo por_extenso
+  alias_method :to_extenso, :por_extenso
+  
+  # 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)
+    negativo=(numero<0)? "menos " : ""
+    n=numero.to_i.abs
+    return case n
+    when 0..9 then negativo + @@unidade[n].to_s
+    when 10..19 then negativo + @@dezena[n].to_s
+    when 20..99
+      v=n % 10
+      if  v== 0
+        negativo + @@dezena[n].to_s
+      else
+        "#{negativo}#{@@dezena[n-v]} e #{por_extenso(v)}"
+      end
+    when 100
+      negativo+"cem"
+    when 101..999
+      v=n % 100
+      if  v== 0
+        negativo + @@centena[n].to_s
+      else
+        "#{negativo}#{@@centena[n-v]} e #{por_extenso(v)}"
+      end
+    when 1000..999999
+      m,c=n/1000,n%1000
+      %(#{negativo}#{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
+      %(#{negativo}#{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
+      %(#{negativo}#{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
+      %(#{negativo}#{por_extenso(tri)} trilh#{tri > 1 ? 'ões':'ão'}#{bi > 0 ? " e #{por_extenso(bi)}" : ''})
+    else
+      raise "Valor excede o permitido: #{n}"
+    end
+  end
+end

data/lib/brdinheiro_lite/extenso_real.rb

@@ -0,0 +1,60 @@
+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)
+  end
+  
+  # Alias para por_extenso_em_reais
+  alias_method :to_extenso_real, :por_extenso_em_reais
+
+  # 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)
+    negativo=(valor<0)? " negativo" : ""
+    negativos=(valor<0)? " negativos" : ""
+    valor = valor.abs
+    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#{negativo}": "#{complemento}reais#{negativos}"})
+    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 then ""
+      when 1 then " centavo"
+      when 2..99 then " centavos"
+      end
+
+      if real.to_i > 0
+        "#{ExtensoReal.por_extenso_em_reais(real.to_i)}#{cents > 0 ? ' e ' + valor_cents + negativos : real.to_i > 1 ? negativos : negativo }"
+      else
+        if (cents.to_i%100)==1
+           "#{valor_cents}#{negativo}"
+        else
+           "#{valor_cents}#{negativos}"
+        end
+      end
+    else
+      ExtensoReal.por_extenso_em_reais(valor.to_s.strip.gsub(/[^\d]/,'.').to_f)
+    end
+  end
+end
+
+Numeric.send(:include, ExtensoReal)

data/lib/brdinheiro_lite/nil_class.rb

@@ -0,0 +1,24 @@
+class NilClass
+
+  def valor
+    0.real
+  end
+
+  def contabil
+    0.contabil
+  end
+  
+  def para_dinheiro
+    0.real
+  end
+
+  def reais
+    0.real
+  end
+
+  def real
+    0.real
+  end  
+
+end
+

data/lib/brdinheiro_lite/version.rb

@@ -0,0 +1,9 @@
+module BrDinheiro
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY = 1
+
+    STRING = "#{MAJOR}.#{MINOR}.#{TINY}"
+  end
+end

data/lib/brdinheiro_lite.rb

@@ -0,0 +1,19 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+  
+%w(dinheiro
+dinheiro_util
+excecoes
+nil_class
+extenso
+extenso_real).each {|req| require File.dirname(__FILE__) + "/brdinheiro_lite/#{req}"}
+
+require 'bigdecimal'
+
+String.send(:include, DinheiroUtil)
+
+class Object
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+end