davidgf
diff --git a/‎translations/pt-BR/README.md
+43 b/‎translations/pt-BR/README.md
+43
diff --git a/‎translations/pt-BR/adapter.md
+68 b/‎translations/pt-BR/adapter.md
+68
diff --git a/‎translations/pt-BR/builder.md
+109 b/‎translations/pt-BR/builder.md
+109
diff --git a/‎translations/pt-BR/command.md
+118 b/‎translations/pt-BR/command.md
+118
@@ -0,0 +1,43 @@
+# Padrões de Design em Ruby
+
+Sumário dos padrões de design explicados no livro [Design Patterns in Ruby](http://designpatternsinruby.com/), onde [Russ Olsen](http://russolsen.com/)
+explica e adapta para Ruby 14 dos 23 padrões de design da Gangue dos Quatro
+(GoF - Gang of Four).
+
+## Padrões de Design
+
+### Padrões dos GoF
+
+* [Adapter](adapter.md): ajuda duas interfaces incompatíveis a trabalharem em conjunto
+* [Builder](builder.md): cria objetos complexos que são difíceis de serem configurados
+* [Command](command.md): executa uma tarefa específica sem ter informação alguma sobre o receptor da requisição
+* [Composite](composite.md): constrói  uma hierarquia de objetos árvore e interage com todos eles da mesma forma
+* [Decorator](decorator.md): modifica as responsabilidades de um objeto adicionando algumas funcionalidades
+* [Factory](factory.md): cria objetos sem ter que especificar a classe exata do objeto que será criado
+* [Interpreter](interpreter.md): fornece uma linguagem especializada para resolver um problema bem definido em um domínio conhecido
+* [Iterator](iterator.md): fornece um jeito de acessar uma coleção de sub-objetos sem expor a representação por baixo
+* [Observer](observer.md): ajuda na construção de uma sistema altamente integrado, sustentável e evita acoplamento entre classes
+* [Proxy](proxy.md): permite que tenhamos mais controle sobre como e quando nós acessamos um determinado objeto
+* [Singleton](singleton.md): tenha uma única instância de uma certa classe em toda sua aplicação
+* [Strategy](strategy.md): modifica parte de um algoritmo em tempo de execução
+* [Template Method](template_method.md): redefine certos passos de um algoritmo sem mudar a estrutura do algoritmo
+
+### Padrões que não são dos GoF: Padrões para Ruby
+
+* [Convention Over Configuration](convention_over_configuration.md): constrói um sistema extensível sem ter que carregar o peso da configuração
+* [Domain-Specific Language](dsl.md): constrói uma sintaxe conveniente para resolver problemas de um domínio específico
+* [Meta-Programming](meta_programming.md): ganhe mais flexibilidade quando estiver definindo novas classes e criando objetos customizado em tempo de execução
+
+## Contribuições
+
+Contribuições são bem-vindas! O que você poderia fazer?:
+
+* Encontrar erros de digitação e gramática
+* Propor um jeito melhor de explicar algum dos padrões
+* Adicionar um exemplo melhor de utilização de um padrões
+* Adicionar algum outro padrão da GoF que não foi coberto no livro
+
+Pull Requests de **refatoração de exemplos de código não serão consideradas**.
+Os exemplos fornecidos por Russ Olsen no livro foram feito para serem simples
+e auto explicativo, não o mais elegante ou com melhor desempenho, o propósito
+deles é apenas educacional.
@@ -0,0 +1,68 @@
+# O Padrão *Adapter*
+
+## Problema
+Nós queremos conversar que um objeto converse com outro objeto, mas as interfaces
+deles não combinam.
+
+## Solução
+Nós simplesmente envolvemos o **adaptado** com a nossa nova classe **adaptadora**.
+Essa classe implementa uma interface que o invocador compreenda, embora todo o
+trabalho seja realizado pelo objeto adaptado.
+
+## Exemplo
+Vamos pensar em uma classe que receba dois arquivos (um leitor e um escritor) e
+criptografe um arquivo.
+
+```ruby
+class Encrypter
+  def initialize(key)
+    @key = key
+  end
+
+  def encrypt(reader, writer)
+    key_index = 0
+    while not reader.eof?
+      clear_char = reader.getc
+      encrypted_char = clear_char ^ @key[key_index]
+      writer.putc(encrypted_char)
+      key_index = (key_index + 1) % @key.size
+    end
+  end
+end
+```
+Mas o que acontece se a informação que queremos deixar segura estiver em uma
+string, ao invés de em um arquivo? Nós precisamos de um objeto que se parece
+com um arquivo, ou seja, suporte a mesma interface que um objeto de `IO` do
+Ruby. Podemos criar uma classe adaptadora `StringIOAdapter` para alcançar isso:
+
+```ruby
+class StringIOAdapter
+  def initialize(string)
+    @string = string
+    @position = 0
+  end
+
+  def getc
+    if @position >= @string.length
+      raise EOFError
+    end
+    ch = @string[@position]
+    @position += 1
+    return ch
+  end
+
+  def eof?
+    return @position >= @string.length
+  end
+end
+```
+
+Agora podemos usar uma `String` como se fosse um arquivo, apenas uma pequena
+parte da interface `IO` é implementada, basicamente o que precisamos.
+
+```ruby
+encrypter = Encrypter.new('XYZZY')
+reader= StringIOAdapter.new('We attack at dawn')
+writer=File.open('out.txt', 'w')
+encrypter.encrypt(reader, writer)
+```
@@ -0,0 +1,109 @@
+# O Padrão *Builder*
+
+## Problema
+Precisamos criar um objeto complexo que é difícil de configurar.
+
+## Solução
+O Padrão *Builder* encapsula a lógica de construção de objetos complexos em sua
+própria classe. Ele define uma interface para configurar o objeto passo a passo,
+ escondendo os detalhes de implementação.
+
+## Exemplo
+Vamos imaginar que nós temos que construir um sistema que mantém o controle dos
+componentes de um computador.
+
+```ruby
+class Computer
+  attr_accessor :display
+  attr_accessor :motherboard
+  attr_reader :drives
+
+  def initialize(display=:crt, motherboard=Motherboard.new, drives=[])
+    @motherboard = motherboard
+    @drives = drives
+    @display = display
+  end
+end
+```
+
+A criação de um objeto `Computer` (Computador) pode se tornar muito complexa,
+assim como `Motherboard` (Placa Mãe), por exemplo, é um objeto completo:
+
+```ruby
+class CPU
+  # Common CPU stuff...
+end
+
+class BasicCPU < CPU
+  # Lots of not very fast CPU-related stuff...
+end
+
+class TurboCPU < CPU
+  # Lots of very fast CPU stuff...
+end
+
+class Motherboard
+  attr_accessor :cpu
+  attr_accessor :memory_size
+
+  def initialize(cpu=BasicCPU.new, memory_size=1000)
+    @cpu = cpu
+    @memory_size = memory_size
+  end
+end
+```
+Então, o processo de construir um `Computer` pode ser realmente tedioso.
+
+```ruby
+# Build a fast computer with lots of memory...
+motherboard = Motherboard.new(TurboCPU.new, 4000)
+
+# ...and a hard drive, a CD writer, and a DVD
+drives = []
+drives << Drive.new(:hard_drive, 200000, true)
+drives << Drive.new(:cd, 760, true)
+drives << Drive.new(:dvd, 4700, false)
+computer = Computer.new(:lcd, motherboard, drives)
+```
+Podemos tornar esse processo muito mais simples ao encapsular a lógica de
+construção em uma classe.
+
+```ruby
+class ComputerBuilder
+  attr_reader :computer
+
+  def initialize
+    @computer = Computer.new
+  end
+
+  def turbo(has_turbo_cpu=true)
+    @computer.motherboard.cpu = TurboCPU.new
+  end
+
+  def display=(display)
+    @computer.display=display
+  end
+
+  def memory_size=(size_in_mb)
+    @computer.motherboard.memory_size = size_in_mb
+  end
+
+  def add_cd(writer=false)
+    @computer.drives << Drive.new(:cd, 760, writer)
+  end
+
+  def add_dvd(writer=false)
+    @computer.drives << Drive.new(:dvd, 4000, writer)
+  end
+
+  def add_hard_disk(size_in_mb)
+    @computer.drives << Drive.new(:hard_disk, size_in_mb, true)
+  end
+end
+
+builder = ComputerBuilder.new
+builder.turbo
+builder.add_cd(true)
+builder.add_dvd
+builder.add_hard_disk(100000)
+```
@@ -0,0 +1,118 @@
+# O Padrão *Command*
+
+## Problema
+Nós queremos realizar alguma tarefa específica sem saber como todo o processo
+funciona ou ter qualquer informação sobre o destinatário da requisição.
+
+## Solução
+O Padrão *Command* (Comando) desacopla o objeto que precisa realizar uma tarefa
+específica daquele que sabe como fazer. Ele encapsula toda a informação necessária
+para fazer o trabalho em seu próprio objeto incluindo: quem são os destinatários,
+os métodos que serão chamados e seus parâmetros. Dessa forma, qualquer objeto
+que quiser realizar a tarefa apenas precisa conhecer a interface do objeto comando.
+
+## Exemplo
+Vamos considerar uma implementação de um botão de algum framework GUI, o qual tem
+um método chamado durante um clique de um botão.
+
+```ruby
+class SlickButton
+
+  # Lots of button drawing and management
+  # code omitted...
+
+  def on_button_push
+    # Do something when the button is pushed
+  end
+end
+```
+
+Nós podemos estender a classe botão que sobrescreve o método `on_button_push`
+para realizar certas ações sempre que o usuário clique no botão. Por exemplo,
+se o objetivo do botão é salvar um documento, poderíamos fazer algo assim:  
+
+```ruby
+class SaveButton < SlickButton
+  def on_button_push
+    # Save the current document...
+  end
+end
+```
+
+No entanto, uma GUI complexa poderia ter centenas de botões, o que significa que
+nós poderíamos acabar tendo centenas de subclasses para nossos botões. Existe
+uma maneira mais fácil. Nós podemos refatorar o código que executa a ação em seu
+ próprio objeto, o qual implementa uma interface simples. Então, nós podemos
+refatorar a implementação de nosso botão para receber um objeto comando como
+parâmetro e chama-lo quando clicado.
+
+```ruby
+class SaveCommand
+  def execute
+    # Save the current document...
+  end
+end
+
+class SlickButton
+  attr_accessor :command
+
+  def initialize(command)
+    @command = command
+  end
+
+  def on_button_push
+    @command.execute if @command
+  end
+end
+
+save_button = SlickButton.new(SaveCommand.new)
+```
+
+O padrão *Command* é muito útil se nós precisarmos implementar uma funcionalidade
+ do tipo **desfazer/voltar**. Tudo que precisamos fazer é implementar o método
+ `unexecute` em nosso objeto comando. Por exemplo, assim é como nós iríamos
+ implementar a criação de um arquivo:
+
+```ruby
+class CreateFile < Command
+  def initialize(path, contents)
+    super "Create file: #{path}"
+    @path = path
+    @contents = contents
+  end
+
+  def execute
+    f = File.open(@path, "w")
+    f.write(@contents)
+    f.close
+  end
+
+  def unexecute
+    File.delete(@path)
+  end
+end
+```
+Outra situação útil onde o padrão **Command** é muito conveniente é em programas
+de instalação. Ao combinar ele com o padrão **Composite** (Composto), nós podemos
+guardar uma lista de tarefas que precisem ser realizadas.
+
+```ruby
+class CompositeCommand < Command
+  def initialize
+    @commands = []
+  end
+
+  def add_command(cmd)
+    @commands << cmd
+  end
+
+  def execute
+    @commands.each {|cmd| cmd.execute}
+  end
+end
+
+cmds = CompositeCommand.new
+cmds.add_command(CreateFile.new('file1.txt', "hello world\n"))
+cmds.add_command(CopyFile.new('file1.txt', 'file2.txt'))
+cmds.add_command(DeleteFile.new('file1.txt'))
+```