refactor.rb

def transfere(to, valor)
  to.link("transfer").post(:valor => valor)
end

def processa_pagamento(pessoa, aulas, consultorias, opensource, bank)

  parcelas = []
  total = 0
	aulas.each do |a|
	  aula.verify do |v|
	    parcelas << a.horas * pessoa.valor if v.confirmed?
	    total += a.horas * pessoa.valor
    end
	end
	
	consultorias.each do |c|
	  parcelas << c.horas * pessoa.valor_consultoria
	  total += c.horas * pessoa.valor_consultoria
  end
  
  parcelas << opensource.horas * 1000 if opensource
  total += opensource.horas * 1000
  
  if parcelas.size>10
    parcelas << 500
    total += 500
  end
  
  parcelas << (-total * 0.2)
  
  b = Restfulie.at(bank.uri).get
  transfere(b, 500, parcelas)
  
end

# transforma no assinc
Restfulie.at(bank.uri).get do |b|
  # assincrono
  transfere(b, 500, parcelas)
end


# refatora os 3 << de parcelas em EACH, depois em MAP, depois em INJECT
class PagamentoMensal
  
  def initialize
    @funcoes = []
  end
  
  def add_processor(&block)
    @funcoes << block
  end
  
  def processa_pagamento(pessoa, aulas, consultorias, opensource, bank)
    gastos(...)
  	Restfulie.at(bank.uri).get do |b|
  	  # assincrono
  	  transfere(b, 500, parcelas)
    end

  end
  
  def gastos(...)
    parcelas = []
    total = 0
    @funcoes.each do |f|
      ps = f.call(pessoa, aulas, consultorias, opensource, bank)
      total = ps.inject(total) do |total, p|
        total + p
      end
      parcelas += ps
    end

    parcelas << (-total * 0.2)
  end
  
end

# refatorar para que pessoa etc vire um escopo so, algo como ENV
# mudar para INFORMACOES DE PAGAMENTO (tiny type, imutavel)

# toda vez que eu chamar gastos, o resultado EH O MESMO!



def compose(f,g)
  lambda {|*args| f.call(g.call(*args))}
end



MAP REDUCE
def map_reduce(elements, map, reduce)
  # invoke random
  mapped = elements.map_slice do |a|
    map.call(a)
  end
  groups = mapped.sort.split_per_group
  groups.reduce_slice do |s|
    reduce.call(s)
  end
end

array = ["Guilherme", "Paulo", "Carlos", "Anderson", "Guilherme", "Anderson", "Guilherme"]
map = lambda { |e| e.inject({}) lambda { |m, ac| m.fetch(ac,0) + 1} }
class Array
  def map_slice(qtd)
    h = {}
    each_slice(qtd) do |e|
      yield(e).each do |k, v|
        h.fetch(k,
      end
    end
  end
end
map_reduce(array, map)