Sobre acoplamento e injeção de dependências em Ruby

Quem me conhece sabe que eu gosto bastante de linguagens com tipagem estática, mas vou parar um pouco para falar sobre acoplamento em linguagens com tipagem dinâmica e como isso é diferente do que eu estou acostumado a fazer normalmente.

Vou começar por uma execução de um método qualquer em ruby:

class MinhaClasse
  def faz_alguma_coisa(outro_cara)
    outro_cara.algum_metodo
  end
end

Qual é o nível de acoplamento da MinhaClasse com o outro_cara? O mais baixo possível! Só existe o acoplamento com a interface, no sentido mais puro da palavra, ou seja, só precisamos que o outro_cara tenha um método chamado algum_metodo, que não recebe nenhum argumento. Ou seja, o baixo acoplamento vem de graça! Não existe o acoplamento de tipos, que existe nas linguagens estáticas.

Se existirem duas classes que tem esse método, qualquer uma delas pode ser usada:

class CaraLegal
  def algum_metodo
    puts "yey!"
  end

  def outro_metodo
    puts "=)"
  end
end

class CaraChato
  def algum_metodo
    puts "Zzzzz"
  end
end

Agora se mudar um pouco a MinhaClasse, por exemplo:

class MinhaClasse
  def faz_alguma_coisa(outro_cara)
    outro_cara.algum_metodo

    outro_cara.outro_metodo
  end
end

Quebra todos os lugares que usam o CaraChato ou qualquer outra classe do sistema como argumento nesse método (inclusive os mocks que não esperavam a mensagem :‍outro_method ¬¬). Quanto mais métodos eu chamar no outro_cara, mais eu estou me acoplando à interface dele, e maior é a chance de quebrar algum código que usa a MinhaClasse. Ou seja, ao mesmo tempo em que eu estou me acoplando pouco a um objeto, estou me acoplando a todas as classes que possuem os métodos que chamei em faz_alguma_coisa.

Agora, suponha que a MinhaClasse precisa enviar um email, e eu resolvi implementar da seguinte maneira:

class MinhaClasse
  #...
  def processo_complicado
     email = gera_email 
     enviador = EnviadorDeEmail.new
     enviador.envia email
  end
end

Agora além de estar se acoplando a uma interface, estaria também se acoplando a uma implementação! A vida me ensinou que nesse caso, para remover esse acoplamento posso usar injeção de dependências e receber esse enviador no construtor da MinhaClasse, por exemplo. Mas peraí, isso é Ruby, será que esse código está acoplado à implementação do EnviadorDeEmail mesmo? Se eu quiser trocar a implementação padrão por uma que não fica esperando o email ser enviado, por exemplo, vou ter que varrer o sistema inteiro pra fazer isso? Não. Só preciso fazer isso em algum lugar:

EnviadorDeEmail = EnviadorDeEmailNaoBlocante

Se eu tenho várias classes que oferecem serviços e são usadas como dependências no meu sistema, basta eu escolher um nome para o serviço, e dar new na hora que eu precisar usar (ou coisa parecida). E no meu ponto de entrada do sistema, simplesmente faço o 'bind' desses serviços para as implementações:

EnviadorDeEmail = EnviadorDeEmailNaoBlocante
Cache = MemCache
GeradorDeNotaFiscal = NotaFiscal::GeradorViaSoap
#...

Sem contar que conseguimos implementar o new pra retornar a mesma instância, já que ele é um simples método da classe. Os motivos que tínhamos para não dar new nas classes não valem aqui (pelo menos não a maioria deles). O problema é: qual é o perigo disso?