From 6dab86ce9d6df4211328e64afadb94a64fd955bb Mon Sep 17 00:00:00 2001
From: Bruno Henrique <garu@jarvis.(none)>
Date: Mon, 12 Aug 2013 23:31:46 -0300
Subject: for review

---
 pt-br/ruby-pt.html.markdown | 598 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 598 insertions(+)
 create mode 100644 pt-br/ruby-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown
new file mode 100644
index 00000000..cedd2db1
--- /dev/null
+++ b/pt-br/ruby-pt.html.markdown
@@ -0,0 +1,598 @@
+---
+language: ruby
+filename: learnruby.rb
+contributors:
+  - ["Bruno Henrique - Garu", "http://garulab.com"]
+---
+
+```ruby
+# Isso é um comentario
+
+=begin
+This is a multiline comment
+No-one uses them
+You shouldn't either
+
+Isso é um comentario multilinha
+Ninguém os usa
+
+=end
+
+# First and foremost: Everything is an object.
+# Primeiro e principal: Tudo é um objeto.
+
+# Numbers are objects
+# Números são objetos
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Some basic arithmetic
+# Aritmética básica
+
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# Arithmetic is just syntactic sugar
+# for calling a method on an object
+# Arithmetic é apenas açúcar semântico 
+# para chamar um métoddo de um objeto
+1.+(3) #=> 4
+10.* 5 #=> 50 
+
+# Special values are objects
+# Valores especiais são obejetos
+nil # Nothing to see here 
+nil # Nada para ver aqui
+true # truth
+true # verdadeiro
+false # falsehood
+false # falso
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Equality
+# Igualdade
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Inequality
+# Desigualdade
+1 != 1 #=> false
+2 != 1 #=> true
+!true  #=> false
+!false #=> true
+
+# apart from false itself, nil is the only other 'falsey' value
+# além de 'false', 'nil' é o único outro valor falso
+
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# More comparisons
+# Mais comparações
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Strings are objects
+# Strings são obejetos
+
+'I am a string'.class #=> String
+'Eu sou uma string'.class #=> String
+"I am a string too".class #=> String
+"Eu também sou uma string".class #=> String
+
+placeholder = "use string interpolation"
+placeholder = "usar interpolação de string"
+"I can #{placeholder} when using double quoted strings"
+"Eu posso #{placeholder} quando estiver usando aspas duplas"
+#=> "I can use string interpolation when using double quoted strings"
+#=> "Eu posso usar insterpolação de string quando estiver usando aspas duplas"
+
+
+# print to the output
+# imprime para output (saida)
+puts "I'm printing!"
+puts "Estou imprimindo"
+
+# Variables
+# Variáveis
+x = 25 #=> 25
+x #=> 25
+
+# Note that assignment returns the value assigned
+# Note que uma atribuição retorna o valor atribuido
+# This means you can do multiple assignment:
+# Isso significa que você pode fazer multiplas atribuições:
+
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# By convention, use snake_case for variable names
+# Por convenção, use snake_case para nomes de variáveis
+snake_case = true
+
+# Use descriptive variable names
+# Use nomes de variáveis descrivos
+path_to_project_root = '/good/name/'
+caminho_para_a_raiz_do_projeto = '/bom/nome/'
+path = '/bad/name/'
+caminho = '/nome/ruim/'
+
+# Symbols (are objects)
+# Simbolos (são objetos)
+# Symbols are immutable, reusable constants represented internally by an
+# Simbolos são imultáveis, são constantes reutilizáveis representadadas internamente por um
+# integer value. They're often used instead of strings to efficiently convey
+# valor inteiro. Eles são frequentemente usados no lugar de strings para transmitir com eficiência os valores
+# specific, meaningful values
+# específicos e significativos
+
+:pending.class #=> Symbol
+:pendente.class #=> Symbol
+
+status = :pending
+status = :pendente
+
+status == :pending #=> true
+status == :pendente #=> true
+
+status == 'pending' #=> false
+status == 'pendente' #=> false
+
+status == :approved #=> false
+status == :aprovado #=> false
+
+# Arrays
+
+# This is an array
+# Isso é um array
+[1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Arrays can contain different types of items
+# Arrays podem conter diferentes tipos de itens
+
+array = [1, "hello", false] #=> => [1, "hello", false]
+array = [1, "Oi", false] #=> => [1, "Oi", false]
+
+# Arrays can be indexed
+# Arrays podem ser indexados
+# From the front
+# a partir do começo
+array[0] #=> 1
+array[12] #=> nil
+
+# Like arithmetic, [var] access
+# Como aritimetica, o acesso via [var]
+# is just syntactic sugar
+# é apenas açúcar sintático
+# for calling a method [] on an object
+# para chamar o método [] de um objeto
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# From the end
+# a partir do final
+array[-1] #=> 5
+
+# With a start and end index
+# Com um índice de começo e fim 
+array[2, 4] #=> [3, 4, 5]
+
+# Or with a range
+# Ou com um intervalo de valores
+array[1..3] #=> [2, 3, 4]
+
+# Add to an array like this
+# Adicionar a um array como este
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+
+# Hashes are Ruby's primary dictionary with keys/value pairs.
+# Hashes são dicionário com um par de chave(key)/valor(value)
+# Hashes are denoted with curly braces:
+# Hashes são simbolizados com chaves "{}"
+hash = {'color' => 'green', 'number' => 5}
+hash = {'cor' => 'verde', 'numero' => 5}
+
+hash.keys #=> ['cor', 'numero']
+
+# Hashes can be quickly looked up by key:
+# Hashes podem ser rapidamente pesquisado pela chave (key)
+hash['cor'] #=> 'verde'
+hash['numero'] #=> 5
+
+# Asking a hash for a key that doesn't exist returns nil:
+# Procurar em um hash por uma chave que não existe retorna nil:
+hash['nothing here'] #=> nil
+hash['nada aqui'] #=> nil
+
+# Iterate over hashes with the #each method:
+# Interar sobre hashes com o método #each:
+hash.each do |k, v|
+  puts "#{k} is #{v}"
+end
+
+hash.each do |k, v|
+  puts "#{k} é #{v}"
+end
+
+# Since Ruby 1.9, there's a special syntax when using symbols as keys:
+# Desde o Ruby 1.9, temos uma sintaxe especial quando usamos simbolos como chaves (keys)
+
+new_hash = { defcon: 3, action: true}
+novo_hash = { defcon: 3, acao: true}
+
+new_hash.keys #=> [:defcon, :action]
+novo_hash.keys #=> [:defcon, :acao]
+
+# Tip: Both Arrays and Hashes are Enumerable
+# Dica: Tanto Arrays quanto Hashes são Enumerable
+# They share a lot of useful methods such as each, map, count, and more
+# Eles compartilham um monte de métodos úteis como each, map, count e mais
+
+# Control structures
+# Estruturas de controle
+
+if true
+  "if statement"
+elsif false
+ "else if, optional"
+else
+ "else, also optional"
+end
+
+if true
+  "Se verdadeiro"
+elsif false
+ "else if, opicional"
+else
+ "else, também é opicional"
+end
+
+for counter in 1..5
+  puts "iteration #{counter}"
+end
+
+for contador in 1..5
+  puts "interação #{contador}"
+end
+#=> contador 1
+#=> contador 2
+#=> contador 3
+#=> contador 4
+#=> contador 5
+
+# HOWEVER
+# PORÉM
+# No-one uses for loops
+# Ninguém usa para loops
+# Use `each` instead, like this:
+# Use "each" em vez, dessa forma:
+
+(1..5).each do |counter|
+  puts "iteration #{counter}"
+end
+
+(1..5).each do |contador|
+  puts "interação #{contador}"
+end
+#=> contador 1
+#=> contador 2
+#=> contador 3
+#=> contador 4
+#=> contador 5
+
+counter = 1
+while counter <= 5 do
+  puts "iteration #{counter}"
+  counter += 1
+end
+
+contador = 1
+while contador <= 5 do
+  puts "interação #{contador}"
+  contador += 1
+end
+#=> contador 1
+#=> contador 2
+#=> contador 3
+#=> contador 4
+#=> contador 5
+
+grade = 'B'
+
+case grade
+when 'A'
+  puts "Way to go kiddo"
+when 'B'
+  puts "Better luck next time"
+when 'C'
+  puts "You can do better"
+when 'D'
+  puts "Scraping through"
+when 'F'
+  puts "You failed!"
+else 
+  puts "Alternative grading system, eh?"
+end
+
+grau = 'B'
+
+case grau
+when 'A'
+  puts "Um longo caminho a percorrer pequeno gafanhoto"
+when 'B'
+  puts "Melhor sorte da próxima vez"
+when 'C'
+  puts "Você pode fazer melhor"
+when 'D'
+  puts "Scraping through"
+when 'F'
+  puts "Você falhou"
+else 
+  puts "Alternative grading system, eh?"
+end
+
+# Functions
+# Funções
+
+def dobrar(x)
+  x * 2
+end
+
+# Functions (and all blocks) implcitly return the value of the last statement
+# Funções (e todos os blocos) retornam implicitamente o valor da última linha
+double(2) #=> 4
+dobrar(2) #=> 4
+
+# Parentheses are optional where the result is unambiguous
+# Parênteses são opicionais onde o resultado é claro
+double 3 #=> 6
+dobrar 3 #=> 6
+
+double double 3 #=> 12
+dobrar dobrar 3 #=> 12
+
+def sum(x,y)
+  x + y
+end
+
+def somar(x,y)
+  x + y
+end
+
+# Method arguments are separated by a comma
+# Argumentos de métodos são separados por uma virgula
+sum 3, 4 #=> 7
+somar 3, 4 #=> 7
+
+somar somar(3,4), 5 #=> 12
+
+# yield
+# All methods have an implicit, optional block parameter
+# Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco 
+# it can be called with the 'yield' keyword
+# ele pode ser chamado com a palavra chave 'yield'
+
+def surround
+  puts "{"
+  yield
+  puts "}"
+end
+
+surround { puts 'hello world' }
+
+
+def ao_redor
+  puts "{"
+  yield
+  puts "}"
+end
+
+ao_redor { puts 'Olá mundo' }
+
+# {
+# Olá mundo
+# }
+
+
+# Define a class with the class keyword
+# Define uma classe com a palavra chave 'class'
+class Human
+
+  # A class variable. It is shared by all instances of this class.
+  @@species = "H. sapiens"
+
+  # Basic initializer
+  def initialize(name, age=0)
+    # Assign the argument to the "name" instance variable for the instance
+    @name = name
+    # If no age given, we will fall back to the default in the arguments list.
+    @age = age
+  end
+
+  # Basic setter method
+  def name=(name)
+    @name = name
+  end
+
+  # Basic getter method
+  def name
+    @name
+  end
+
+  # A class method uses self to distinguish from instance methods.
+  # It can only be called on the class, not an instance.
+  def self.say(msg)
+    puts "#{msg}"
+  end
+
+  def species
+    @@species
+  end
+
+end
+
+
+class Humano
+
+  # Uma variavel de classe. Ela é compartilhada por todas as instancias dessa classe
+  @@especies = "H. sapiens"
+
+  # Inicialização básica (contructor)
+  def initialize(nome, idade=0)
+    # Atribui o argumento para a variavel de instacia "nome" do objeto
+    @nome = nome
+    # Se a idade não for passada, nós definimos um valor padrão na lista de argumentos
+    @idade = idade
+  end
+
+  # Método básico para atribuir valor
+  def nome=(nome)
+    @nome = nome
+  end
+
+  # Método básico de resgatar valor
+  def nome
+    @nome
+  end
+
+  # Um método de classe usa a palavra chave self para se defenciar dos métodos de instancia.
+  # Ele só pode ser chamado na classe, não na instancia
+  def self.diz(msg)
+    puts "#{msg}"
+  end
+
+  def especies
+    @@especies
+  end
+
+end
+
+
+# Instantiate a class
+# Instaciando uma classe
+jim = Human.new("Jim Halpert")
+jim = Humano.new("Jim Halpert")
+
+dwight = Human.new("Dwight K. Schrute")
+dwight = Humano.new("Dwight K. Schrute")
+
+# Let's call a couple of methods
+# Vamos chamar um par de métodos
+jim.species #=> "H. sapiens"
+jim.especies #=> "H. sapiens"
+
+jim.name #=> "Jim Halpert"
+jim.nome #=> "Jim Halpert"
+
+jim.name = "Jim Halpert II" #=> "Jim Halpert II"
+jim.nome = "Jim Halpert II" #=> "Jim Halpert II"
+
+jim.name #=> "Jim Halpert II"
+jim.nome #=> "Jim Halpert II"
+
+dwight.species #=> "H. sapiens"
+dwight.especies #=> "H. sapiens"
+
+dwight.name #=> "Dwight K. Schrute"
+dwight.nome #=> "Dwight K. Schrute"
+
+# Call the class method
+# Chamar o método de classe
+Human.say("Hi") #=> "Hi"
+Humano.diz("Oi") #=> "Oi"
+
+# Class also is object in ruby. So class can have instance variables.
+# Uma classe também é objeto em Ruby. Então uma classe pode possuir um variavel de instancia
+# Class variable is shared among the class and all of its descendants.
+# Variavies de classe são compartilhadas entre a classe e todos os seus descendentes.
+
+# base class
+class Human
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+
+# Classe base
+class Humano
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+#  classe filha
+class Trabalhador < Humano
+end
+
+Human.foo # 0
+Humano.foo # 0
+Worker.foo # 0
+Trabalhador.foo # 0
+
+Human.foo = 2 # 2
+Humano.foo = 2 # 2
+Worker.foo # 2
+Trabalhador.foo # 2
+
+# Class instance variable is not shared by the class's descendants.
+# Uma variavel de instancia não é compartilhada por suas classes decendentes.
+
+class Human
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(value)
+    @bar = value
+  end
+end
+
+class Humano
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(value)
+    @bar = value
+  end
+end
+
+class Doctor < Human
+end
+
+class Doutor < Humano
+end
+
+Humano.bar # 0
+Doutor.bar # nil
+
+```
-- 
cgit v1.2.3


From 49cca911886480d10b071ced3a91c325ec3516f9 Mon Sep 17 00:00:00 2001
From: Lucas Tadeu Teixeira <lucas.tadeuteixeira@gmail.com>
Date: Tue, 13 Aug 2013 16:28:48 -0300
Subject: Add brazilian portuguese translation for elisp tutorial.

---
 pt-br/elisp-pt.html.markdown | 359 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 359 insertions(+)
 create mode 100644 pt-br/elisp-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/elisp-pt.html.markdown b/pt-br/elisp-pt.html.markdown
new file mode 100644
index 00000000..9031cad9
--- /dev/null
+++ b/pt-br/elisp-pt.html.markdown
@@ -0,0 +1,359 @@
+---
+language: elisp
+contributors:
+    - ["Bastien Guerry", "http://bzg.fr"]
+translators:
+    - ["Lucas Tadeu Teixeira", "http://ltt.me"]
+lang: pt-br    
+filename: learn-emacs-lisp-pt.el
+---
+
+```scheme
+;; Introdução ao Emacs Lisp em 15 minutos (v0.2d)
+;;
+;; Autor: Bastien / @bzg2 / http://bzg.fr
+;;
+;; Antes de começar, leia este texto escrito Peter Norvig:
+;; http://norvig.com/21-days.html
+;;
+;; Agora instale GNU Emacs 24.3:
+;;
+;; Debian: apt-get install emacs (ou veja as instruções da sua distribuição)
+;; OSX: http://emacsformacosx.com/emacs-builds/Emacs-24.3-universal-10.6.8.dmg
+;; Windows: http://ftp.gnu.org/gnu/windows/emacs/emacs-24.3-bin-i386.zip
+;;
+;; Informações mais gerais podem ser encontradas em:
+;; http://www.gnu.org/software/emacs/#Obtaining
+
+;; Aviso importante:
+;;
+;; Realizar este tutorial não danificará seu computador, a menos
+;; que você fique tão irritado a ponto de jogá-lo no chão. Neste caso,
+;; me abstenho de qualquer responsabilidade. Divirta-se!
+ 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 
+;; Abra o Emacs.
+;;
+;; Aperte a tecla `q' para ocultar a mensagem de boas vindas.
+;;
+;; Agora olhe para a linha cinza na parte inferior da janela:
+;;
+;; "*scratch*" é o nome do espaço de edição em que você se encontra.
+;; Este espaço de edição é chamado "buffer".
+;;
+;; O buffer de rascunho (i.e., "scratch") é o buffer padrão quando
+;; o Emacs é aberto. Você nunca está editando arquivos: você está
+;; editando buffers que você pode salvar em um arquivo.
+;; 
+;; "Lisp interaction" refere-se a um conjunto de comandos disponíveis aqui.
+;; 
+;; O Emacs possui um conjunto de comandos embutidos (disponíveis em 
+;; qualquer buffer) e vários subconjuntos de comandos disponíveis 
+;; quando você ativa um modo específico. Aqui nós utilizamos
+;; `lisp-interaction-mode', que possui comandos para interpretar e navegar
+;; em código Elisp.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Pontos e vírgulas iniciam comentários em qualquer parte de uma linha.
+;;
+;; Programas codificados em Elisp são compostos por expressões simbólicas
+;; (conhecidas também por "sexps"):
+(+ 2 2)
+
+;; Esta expressão simbólica significa "Some 2 e 2".
+
+;; "Sexps" são envoltas em parêntese, possivelmente aninhados:
+(+ 2 (+ 1 1))
+
+;; Uma expressão simbólica contém átomos ou outras expressões
+;; simbólicas. Nos exemplos acima, 1 e 2 são átomos;
+;; (+ 2 (+ 1 1)) e (+ 1 1) são expressões simbólicas.
+
+;; No modo `lisp-interaction-mode' você pode interpretar "sexps".
+;; Posicione o cursor logo após o parêntese de fechamento e,
+;; então, segure apertado Ctrl e aperte a tecla j ("C-j", em resumo).
+
+(+ 3 (+ 1 2))
+;;           ^ posicione o cursor aqui
+;; `C-j' => 6
+
+;; `C-j' insere o resultado da interpretação da expressão no buffer.
+
+;; `C-xC-e' exibe o mesmo resultado na linha inferior do Emacs,
+;; chamada de "mini-buffer".  Nós geralmente utilizaremos `C-xC-e',
+;; já que não queremos poluir o buffer com texto desnecessário.
+
+;; `setq' armazena um valor em uma variável:
+(setq my-name "Bastien")
+;; `C-xC-e' => "Bastien" (texto exibido no mini-buffer)
+
+;; `insert' insere "Hello!" na posição em que se encontra seu cursor:
+(insert "Hello!")
+;; `C-xC-e' => "Hello!"
+
+;; Nós executamos `insert' com apenas um argumento ("Hello!"), mas
+;; mais argumentos podem ser passados --  aqui utilizamos dois:
+
+(insert "Hello" " world!")
+;; `C-xC-e' => "Hello world!"
+
+;; Você pode utilizar variávies no lugar de strings:
+(insert "Hello, I am " my-name)
+;; `C-xC-e' => "Hello, I am Bastien"
+
+;; Você pode combinar "sexps" em funções:
+(defun hello () (insert "Hello, I am " my-name))
+;; `C-xC-e' => hello
+
+;; Você pode interpretar chamadas de funções:
+(hello)
+;; `C-xC-e' => Hello, I am Bastien
+
+;; Os parêntesis vazios na definição da função significam que ela
+;; não aceita argumentos. Mas sempre utilizar `my-name' é um tédio!
+;; Vamos dizer à função para aceitar um argumento (o argumento é
+;; chamado "name"):
+
+(defun hello (name) (insert "Hello " name))
+;; `C-xC-e' => hello
+
+;; Agora vamos executar a função com a string "you" como o valor
+;; para seu único parâmetro:
+(hello "you")
+;; `C-xC-e' => "Hello you"
+
+;; Aí sim!
+
+;; Respire um pouco.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Agora mude para um novo buffer chamado "*test*":
+
+(switch-to-buffer-other-window "*test*")
+;; `C-xC-e'
+;; => [a tela exibirá duas janelas e o cursor estará no buffer *test*]
+
+;; Posicione o mouse sobre a janela superior e clique com o botão
+;; esquerdo para voltar. Ou você pode utilizar `C-xo' (i.e. segure 
+;; ctrl-x e aperte o) para voltar para a outra janela, de forma interativa.
+
+;; Você pode combinar várias "sexps" com `progn':
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (hello "you"))
+;; `C-xC-e'
+;; => [A tela exibirá duas janelas e o cursor estará no buffer *test*]
+
+;; Agora, se você não se importar, pararei de pedir que você aperte
+;; `C-xC-e': faça isso para cada "sexp" que escrevermos.
+
+;; Sempre volte para o buffer *scratch* com o mouse ou `C-xo'.
+
+;; Frequentemente, é útil apagar o conteúdo do buffer:
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello "there"))
+
+;; Ou voltar para a outra janela:
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello "you")
+  (other-window 1))
+
+;; Você pode armazenar um valor em uma variável local utilizando `let':
+(let ((local-name "you"))
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello local-name)
+  (other-window 1))
+
+;; Neste caso, não é necessário utilizar `progn' já que `let' combina
+;; várias "sexps".
+
+;; Vamos formatar uma string:
+(format "Hello %s!\n" "visitor")
+
+;; %s é um espaço reservado para uma string, substituído por "visitor".
+;; \n é um caractere de nova linha.
+
+;; Vamos refinar nossa função utilizando `format':
+(defun hello (name)
+  (insert (format "Hello %s!\n" name)))
+
+(hello "you")
+
+;; Vamos criar outra função que utilize `let':
+(defun greeting (name)
+  (let ((your-name "Bastien"))
+    (insert (format "Hello %s!\n\nI am %s."
+                    name       ; the argument of the function
+                    your-name  ; the let-bound variable "Bastien"
+                    ))))
+
+;; E executá-la:
+(greeting "you")
+
+;; Algumas funções são interativas:
+(read-from-minibuffer "Enter your name: ")
+
+;; Ao ser interpretada, esta função retorna o que você digitou no prompt.
+
+;; Vamos fazer nossa função `greeting' pedir pelo seu nome:
+(defun greeting (from-name)
+  (let ((your-name (read-from-minibuffer "Enter your name: ")))
+    (insert (format "Hello!\n\nI am %s and you are %s."
+                    from-name ; the argument of the function
+                    your-name ; the let-bound var, entered at prompt
+                    ))))
+
+(greeting "Bastien")
+
+;; Vamos finalizá-la fazendo-a exibir os resultados em outra janela:
+(defun greeting (from-name)
+  (let ((your-name (read-from-minibuffer "Enter your name: ")))
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    (insert (format "Hello %s!\n\nI am %s." your-name from-name))
+    (other-window 1)))
+
+;; Agora teste-a:
+(greeting "Bastien")
+
+;; Respire um pouco.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Vamos armazenar uma lista de nomes:
+(setq list-of-names '("Sarah" "Chloe" "Mathilde"))
+
+;; Pegue o primeiro elemento desta lista utilizando `car':
+(car list-of-names)
+
+;; Pegue uma lista de todos os elementos, exceto o primeiro, utilizando
+;; `cdr':
+(cdr list-of-names)
+
+;; Adicione um elemento ao início da lista com `push':
+(push "Stephanie" list-of-names)
+
+;; NOTA: `car' e `cdr' não modificam a lista, `push' sim.
+;; Esta é uma diferença importante: algumas funções não têm qualquer
+;; efeito colateral (como `car'), enquanto outras sim (como `push').
+
+;; Vamos executar `hello' para cada elemento em `list-of-names':
+(mapcar 'hello list-of-names)
+
+;; Refine `greeting' para saudar todos os nomes em `list-of-names':
+(defun greeting ()
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    (mapcar 'hello list-of-names)
+    (other-window 1))
+
+(greeting)
+
+;; Você se lembra da função `hello' que nós definimos lá em cima? Ela
+;; recebe um argumento, um nome. `mapcar' executa `hello', sucessivamente,
+;; utilizando cada elemento de `list-of-names' como argumento para `hello'.
+
+;; Agora vamos arrumar, um pouco, o que nós temos escrito no buffer:
+
+(defun replace-hello-by-bonjour ()
+    (switch-to-buffer-other-window "*test*")
+    (goto-char (point-min))
+    (while (search-forward "Hello")
+      (replace-match "Bonjour"))
+    (other-window 1))
+
+;; (goto-char (point-min)) vai para o início do buffer.
+;; (search-forward "Hello") busca pela string "Hello".
+;; (while x y) interpreta a(s) sexp(s) y enquanto x retornar algo.
+;; Se x retornar `nil' (nada), nós saímos do laço.
+
+(replace-hello-by-bonjour)
+
+;; Você deveria ver todas as ocorrências de "Hello" no buffer *test*
+;; substituídas por "Bonjour".
+
+;; Você deveria, também, receber um erro: "Search failed: Hello".
+;;
+;; Para evitar este erro, você precisa dizer ao `search-forward' se ele
+;; deveria parar de buscar em algum ponto no buffer, e se ele deveria
+;; falhar de forma silenciosa quando nada fosse encontrado:
+
+;; (search-forward "Hello" nil t) dá conta do recado:
+
+;; O argumento `nil' diz: a busca não está limitada a uma posição.
+;; O argumento `t' diz: falhe silenciosamente quando nada for encontrado.
+
+;; Nós utilizamos esta "sexp" na função abaixo, que não gera um erro:
+
+(defun hello-to-bonjour ()
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    ;; Say hello to names in `list-of-names'
+    (mapcar 'hello list-of-names)
+    (goto-char (point-min))
+    ;; Replace "Hello" by "Bonjour"
+    (while (search-forward "Hello" nil t)
+      (replace-match "Bonjour"))
+    (other-window 1))
+
+(hello-to-bonjour)
+
+;; Vamos colorir os nomes:
+
+(defun boldify-names ()
+    (switch-to-buffer-other-window "*test*")
+    (goto-char (point-min))
+    (while (re-search-forward "Bonjour \\(.+\\)!" nil t)
+      (add-text-properties (match-beginning 1)
+                           (match-end 1)
+                           (list 'face 'bold)))
+    (other-window 1))
+
+;; Esta função introduz `re-search-forward': ao invés de buscar
+;; pela string "Bonjour", você busca por um padrão utilizando uma
+;; "expressão regular" (abreviada pelo prefixo "re-").
+
+;; A expressão regular é "Bonjour \\(.+\\)!" e lê-se:
+;; a string "Bonjour ", e
+;; um grupo de               | que é o \\( ... \\)
+;;   quaisquer caracteres    | que é o .
+;;   possivelmente repetidos | que é o +
+;; e a string "!".
+
+;; Preparado? Teste!
+
+(boldify-names)
+
+;; `add-text-properties' adiciona... propriedades de texto, como uma fonte.
+
+;; OK, terminamos por aqui. Feliz Hacking!
+
+;; Se você quiser saber mais sobre uma variável ou função:
+;;
+;; C-h v uma-variável RET
+;; C-h f uma-função RET
+;;
+;; Para ler o manual de Emacs Lisp que vem com o Emacs:
+;;
+;; C-h i m elisp RET
+;;
+;; Para ler uma introdução online ao Emacs Lisp:
+;; https://www.gnu.org/software/emacs/manual/html_node/eintr/index.html
+
+;; Agradecimentos a estas pessoas por seu feedback e sugestões:
+;; - Wes Hardaker
+;; - notbob
+;; - Kevin Montuori
+;; - Arne Babenhauserheide
+;; - Alan Schmitt
+;; - LinXitoW
+;; - Aaron Meurer
+```
-- 
cgit v1.2.3


From cf3149c4bde261aa35cde0cba34432a2f0bf649a Mon Sep 17 00:00:00 2001
From: Lucas Tadeu Teixeira <lucas.tadeuteixeira@gmail.com>
Date: Tue, 13 Aug 2013 16:29:33 -0300
Subject: Fix typo on 'lang' tag.

---
 pt-br/python-pt.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'pt-br')

diff --git a/pt-br/python-pt.html.markdown b/pt-br/python-pt.html.markdown
index e08bb5a8..5afd46d0 100644
--- a/pt-br/python-pt.html.markdown
+++ b/pt-br/python-pt.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
 translators:
     - ["Vilson Vieira", "http://automata.cc"]
-lang: pt-bf
+lang: pt-br
 filename: learnpython-pt.py
 ---
 
-- 
cgit v1.2.3


From 4d705abd99dbe13fbdb50b5d5e74d6fe8c18f559 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Tue, 13 Aug 2013 19:59:19 -0700
Subject: Piddly things

---
 pt-br/elisp-pt.html.markdown | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/elisp-pt.html.markdown b/pt-br/elisp-pt.html.markdown
index 9031cad9..fc2d1e40 100644
--- a/pt-br/elisp-pt.html.markdown
+++ b/pt-br/elisp-pt.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ["Bastien Guerry", "http://bzg.fr"]
 translators:
     - ["Lucas Tadeu Teixeira", "http://ltt.me"]
-lang: pt-br    
+lang: pt-br
 filename: learn-emacs-lisp-pt.el
 ---
 
@@ -30,9 +30,9 @@ filename: learn-emacs-lisp-pt.el
 ;; Realizar este tutorial não danificará seu computador, a menos
 ;; que você fique tão irritado a ponto de jogá-lo no chão. Neste caso,
 ;; me abstenho de qualquer responsabilidade. Divirta-se!
- 
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 
+;;
 ;; Abra o Emacs.
 ;;
 ;; Aperte a tecla `q' para ocultar a mensagem de boas vindas.
@@ -45,11 +45,11 @@ filename: learn-emacs-lisp-pt.el
 ;; O buffer de rascunho (i.e., "scratch") é o buffer padrão quando
 ;; o Emacs é aberto. Você nunca está editando arquivos: você está
 ;; editando buffers que você pode salvar em um arquivo.
-;; 
+;;
 ;; "Lisp interaction" refere-se a um conjunto de comandos disponíveis aqui.
-;; 
-;; O Emacs possui um conjunto de comandos embutidos (disponíveis em 
-;; qualquer buffer) e vários subconjuntos de comandos disponíveis 
+;;
+;; O Emacs possui um conjunto de comandos embutidos (disponíveis em
+;; qualquer buffer) e vários subconjuntos de comandos disponíveis
 ;; quando você ativa um modo específico. Aqui nós utilizamos
 ;; `lisp-interaction-mode', que possui comandos para interpretar e navegar
 ;; em código Elisp.
@@ -137,7 +137,7 @@ filename: learn-emacs-lisp-pt.el
 ;; => [a tela exibirá duas janelas e o cursor estará no buffer *test*]
 
 ;; Posicione o mouse sobre a janela superior e clique com o botão
-;; esquerdo para voltar. Ou você pode utilizar `C-xo' (i.e. segure 
+;; esquerdo para voltar. Ou você pode utilizar `C-xo' (i.e. segure
 ;; ctrl-x e aperte o) para voltar para a outra janela, de forma interativa.
 
 ;; Você pode combinar várias "sexps" com `progn':
-- 
cgit v1.2.3


From 89821fd235560bdfddd61fb4ac52aafc4772ee14 Mon Sep 17 00:00:00 2001
From: Katyanna Moura <amelie.kn@gmail.com>
Date: Wed, 14 Aug 2013 11:56:14 -0300
Subject: =?UTF-8?q?revis=C3=A3o?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 pt-br/ruby-pt.html.markdown  |  79 +-----
 pt-br/ruby-pt.html.markdown~ | 598 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 607 insertions(+), 70 deletions(-)
 create mode 100644 pt-br/ruby-pt.html.markdown~

(limited to 'pt-br')

diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown
index cedd2db1..732d06a4 100644
--- a/pt-br/ruby-pt.html.markdown
+++ b/pt-br/ruby-pt.html.markdown
@@ -9,19 +9,13 @@ contributors:
 # Isso é um comentario
 
 =begin
-This is a multiline comment
-No-one uses them
-You shouldn't either
-
-Isso é um comentario multilinha
+Isso é um comentário multilinha
 Ninguém os usa
-
+Você não deve usar também
 =end
 
-# First and foremost: Everything is an object.
 # Primeiro e principal: Tudo é um objeto.
 
-# Numbers are objects
 # Números são objetos
 
 3.class #=> Fixnum
@@ -29,8 +23,7 @@ Ninguém os usa
 3.to_s #=> "3"
 
 
-# Some basic arithmetic
-# Aritmética básica
+# Um pouco de aritmética básica
 
 1 + 1 #=> 2
 8 - 1 #=> 7
@@ -44,7 +37,6 @@ Ninguém os usa
 1.+(3) #=> 4
 10.* 5 #=> 50 
 
-# Special values are objects
 # Valores especiais são obejetos
 nil # Nothing to see here 
 nil # Nada para ver aqui
@@ -57,26 +49,22 @@ nil.class #=> NilClass
 true.class #=> TrueClass
 false.class #=> FalseClass
 
-# Equality
 # Igualdade
 1 == 1 #=> true
 2 == 1 #=> false
 
-# Inequality
 # Desigualdade
 1 != 1 #=> false
 2 != 1 #=> true
 !true  #=> false
 !false #=> true
 
-# apart from false itself, nil is the only other 'falsey' value
 # além de 'false', 'nil' é o único outro valor falso
 
 !nil   #=> true
 !false #=> true
 !0     #=> false
 
-# More comparisons
 # Mais comparações
 1 < 10 #=> true
 1 > 10 #=> false
@@ -84,7 +72,6 @@ false.class #=> FalseClass
 2 >= 2 #=> true
 
 # Strings are objects
-# Strings são obejetos
 
 'I am a string'.class #=> String
 'Eu sou uma string'.class #=> String
@@ -95,47 +82,35 @@ placeholder = "use string interpolation"
 placeholder = "usar interpolação de string"
 "I can #{placeholder} when using double quoted strings"
 "Eu posso #{placeholder} quando estiver usando aspas duplas"
-#=> "I can use string interpolation when using double quoted strings"
 #=> "Eu posso usar insterpolação de string quando estiver usando aspas duplas"
 
-
-# print to the output
-# imprime para output (saida)
+# imprime para output (saída)
 puts "I'm printing!"
 puts "Estou imprimindo"
 
-# Variables
 # Variáveis
 x = 25 #=> 25
 x #=> 25
 
-# Note that assignment returns the value assigned
 # Note que uma atribuição retorna o valor atribuido
-# This means you can do multiple assignment:
-# Isso significa que você pode fazer multiplas atribuições:
+# Isso significa que você pode fazer múltiplas atribuições:
 
 x = y = 10 #=> 10
 x #=> 10
 y #=> 10
 
-# By convention, use snake_case for variable names
 # Por convenção, use snake_case para nomes de variáveis
 snake_case = true
 
-# Use descriptive variable names
 # Use nomes de variáveis descrivos
 path_to_project_root = '/good/name/'
 caminho_para_a_raiz_do_projeto = '/bom/nome/'
 path = '/bad/name/'
 caminho = '/nome/ruim/'
 
-# Symbols (are objects)
 # Simbolos (são objetos)
-# Symbols are immutable, reusable constants represented internally by an
 # Simbolos são imultáveis, são constantes reutilizáveis representadadas internamente por um
-# integer value. They're often used instead of strings to efficiently convey
 # valor inteiro. Eles são frequentemente usados no lugar de strings para transmitir com eficiência os valores
-# specific, meaningful values
 # específicos e significativos
 
 :pending.class #=> Symbol
@@ -155,68 +130,52 @@ status == :aprovado #=> false
 
 # Arrays
 
-# This is an array
 # Isso é um array
 [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
 
-# Arrays can contain different types of items
 # Arrays podem conter diferentes tipos de itens
 
 array = [1, "hello", false] #=> => [1, "hello", false]
 array = [1, "Oi", false] #=> => [1, "Oi", false]
 
-# Arrays can be indexed
 # Arrays podem ser indexados
-# From the front
 # a partir do começo
 array[0] #=> 1
 array[12] #=> nil
 
-# Like arithmetic, [var] access
 # Como aritimetica, o acesso via [var]
-# is just syntactic sugar
 # é apenas açúcar sintático
-# for calling a method [] on an object
 # para chamar o método [] de um objeto
 array.[] 0 #=> 1
 array.[] 12 #=> nil
 
-# From the end
 # a partir do final
 array[-1] #=> 5
 
-# With a start and end index
 # Com um índice de começo e fim 
 array[2, 4] #=> [3, 4, 5]
 
-# Or with a range
 # Ou com um intervalo de valores
 array[1..3] #=> [2, 3, 4]
 
-# Add to an array like this
 # Adicionar a um array como este
 array << 6 #=> [1, 2, 3, 4, 5, 6]
 
-# Hashes are Ruby's primary dictionary with keys/value pairs.
-# Hashes são dicionário com um par de chave(key)/valor(value)
-# Hashes are denoted with curly braces:
+# Hashes são o principal dicionário de Ruby com pares de chaves(keys)/valor(value).
 # Hashes são simbolizados com chaves "{}"
 hash = {'color' => 'green', 'number' => 5}
 hash = {'cor' => 'verde', 'numero' => 5}
 
 hash.keys #=> ['cor', 'numero']
 
-# Hashes can be quickly looked up by key:
 # Hashes podem ser rapidamente pesquisado pela chave (key)
 hash['cor'] #=> 'verde'
 hash['numero'] #=> 5
 
-# Asking a hash for a key that doesn't exist returns nil:
 # Procurar em um hash por uma chave que não existe retorna nil:
 hash['nothing here'] #=> nil
 hash['nada aqui'] #=> nil
 
-# Iterate over hashes with the #each method:
 # Interar sobre hashes com o método #each:
 hash.each do |k, v|
   puts "#{k} is #{v}"
@@ -226,7 +185,6 @@ hash.each do |k, v|
   puts "#{k} é #{v}"
 end
 
-# Since Ruby 1.9, there's a special syntax when using symbols as keys:
 # Desde o Ruby 1.9, temos uma sintaxe especial quando usamos simbolos como chaves (keys)
 
 new_hash = { defcon: 3, action: true}
@@ -235,12 +193,9 @@ novo_hash = { defcon: 3, acao: true}
 new_hash.keys #=> [:defcon, :action]
 novo_hash.keys #=> [:defcon, :acao]
 
-# Tip: Both Arrays and Hashes are Enumerable
 # Dica: Tanto Arrays quanto Hashes são Enumerable
-# They share a lot of useful methods such as each, map, count, and more
 # Eles compartilham um monte de métodos úteis como each, map, count e mais
 
-# Control structures
 # Estruturas de controle
 
 if true
@@ -272,11 +227,8 @@ end
 #=> contador 4
 #=> contador 5
 
-# HOWEVER
 # PORÉM
-# No-one uses for loops
 # Ninguém usa para loops
-# Use `each` instead, like this:
 # Use "each" em vez, dessa forma:
 
 (1..5).each do |counter|
@@ -343,19 +295,16 @@ else
   puts "Alternative grading system, eh?"
 end
 
-# Functions
 # Funções
 
 def dobrar(x)
   x * 2
 end
 
-# Functions (and all blocks) implcitly return the value of the last statement
 # Funções (e todos os blocos) retornam implicitamente o valor da última linha
 double(2) #=> 4
 dobrar(2) #=> 4
 
-# Parentheses are optional where the result is unambiguous
 # Parênteses são opicionais onde o resultado é claro
 double 3 #=> 6
 dobrar 3 #=> 6
@@ -371,7 +320,6 @@ def somar(x,y)
   x + y
 end
 
-# Method arguments are separated by a comma
 # Argumentos de métodos são separados por uma virgula
 sum 3, 4 #=> 7
 somar 3, 4 #=> 7
@@ -379,9 +327,7 @@ somar 3, 4 #=> 7
 somar somar(3,4), 5 #=> 12
 
 # yield
-# All methods have an implicit, optional block parameter
 # Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco 
-# it can be called with the 'yield' keyword
 # ele pode ser chamado com a palavra chave 'yield'
 
 def surround
@@ -406,7 +352,6 @@ ao_redor { puts 'Olá mundo' }
 # }
 
 
-# Define a class with the class keyword
 # Define uma classe com a palavra chave 'class'
 class Human
 
@@ -480,7 +425,6 @@ class Humano
 end
 
 
-# Instantiate a class
 # Instaciando uma classe
 jim = Human.new("Jim Halpert")
 jim = Humano.new("Jim Halpert")
@@ -488,7 +432,6 @@ jim = Humano.new("Jim Halpert")
 dwight = Human.new("Dwight K. Schrute")
 dwight = Humano.new("Dwight K. Schrute")
 
-# Let's call a couple of methods
 # Vamos chamar um par de métodos
 jim.species #=> "H. sapiens"
 jim.especies #=> "H. sapiens"
@@ -508,15 +451,12 @@ dwight.especies #=> "H. sapiens"
 dwight.name #=> "Dwight K. Schrute"
 dwight.nome #=> "Dwight K. Schrute"
 
-# Call the class method
 # Chamar o método de classe
 Human.say("Hi") #=> "Hi"
 Humano.diz("Oi") #=> "Oi"
 
-# Class also is object in ruby. So class can have instance variables.
-# Uma classe também é objeto em Ruby. Então uma classe pode possuir um variavel de instancia
-# Class variable is shared among the class and all of its descendants.
-# Variavies de classe são compartilhadas entre a classe e todos os seus descendentes.
+# Uma classe também é objeto em Ruby. Então uma classe pode possuir variável de instância
+# Variáveis de classe são compartilhadas entre a classe e todos os seus descendentes.
 
 # base class
 class Human
@@ -559,8 +499,7 @@ Humano.foo = 2 # 2
 Worker.foo # 2
 Trabalhador.foo # 2
 
-# Class instance variable is not shared by the class's descendants.
-# Uma variavel de instancia não é compartilhada por suas classes decendentes.
+# Uma variável de instância não é compartilhada por suas classes decendentes.
 
 class Human
   @bar = 0
diff --git a/pt-br/ruby-pt.html.markdown~ b/pt-br/ruby-pt.html.markdown~
new file mode 100644
index 00000000..cedd2db1
--- /dev/null
+++ b/pt-br/ruby-pt.html.markdown~
@@ -0,0 +1,598 @@
+---
+language: ruby
+filename: learnruby.rb
+contributors:
+  - ["Bruno Henrique - Garu", "http://garulab.com"]
+---
+
+```ruby
+# Isso é um comentario
+
+=begin
+This is a multiline comment
+No-one uses them
+You shouldn't either
+
+Isso é um comentario multilinha
+Ninguém os usa
+
+=end
+
+# First and foremost: Everything is an object.
+# Primeiro e principal: Tudo é um objeto.
+
+# Numbers are objects
+# Números são objetos
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Some basic arithmetic
+# Aritmética básica
+
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# Arithmetic is just syntactic sugar
+# for calling a method on an object
+# Arithmetic é apenas açúcar semântico 
+# para chamar um métoddo de um objeto
+1.+(3) #=> 4
+10.* 5 #=> 50 
+
+# Special values are objects
+# Valores especiais são obejetos
+nil # Nothing to see here 
+nil # Nada para ver aqui
+true # truth
+true # verdadeiro
+false # falsehood
+false # falso
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Equality
+# Igualdade
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Inequality
+# Desigualdade
+1 != 1 #=> false
+2 != 1 #=> true
+!true  #=> false
+!false #=> true
+
+# apart from false itself, nil is the only other 'falsey' value
+# além de 'false', 'nil' é o único outro valor falso
+
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# More comparisons
+# Mais comparações
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Strings are objects
+# Strings são obejetos
+
+'I am a string'.class #=> String
+'Eu sou uma string'.class #=> String
+"I am a string too".class #=> String
+"Eu também sou uma string".class #=> String
+
+placeholder = "use string interpolation"
+placeholder = "usar interpolação de string"
+"I can #{placeholder} when using double quoted strings"
+"Eu posso #{placeholder} quando estiver usando aspas duplas"
+#=> "I can use string interpolation when using double quoted strings"
+#=> "Eu posso usar insterpolação de string quando estiver usando aspas duplas"
+
+
+# print to the output
+# imprime para output (saida)
+puts "I'm printing!"
+puts "Estou imprimindo"
+
+# Variables
+# Variáveis
+x = 25 #=> 25
+x #=> 25
+
+# Note that assignment returns the value assigned
+# Note que uma atribuição retorna o valor atribuido
+# This means you can do multiple assignment:
+# Isso significa que você pode fazer multiplas atribuições:
+
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# By convention, use snake_case for variable names
+# Por convenção, use snake_case para nomes de variáveis
+snake_case = true
+
+# Use descriptive variable names
+# Use nomes de variáveis descrivos
+path_to_project_root = '/good/name/'
+caminho_para_a_raiz_do_projeto = '/bom/nome/'
+path = '/bad/name/'
+caminho = '/nome/ruim/'
+
+# Symbols (are objects)
+# Simbolos (são objetos)
+# Symbols are immutable, reusable constants represented internally by an
+# Simbolos são imultáveis, são constantes reutilizáveis representadadas internamente por um
+# integer value. They're often used instead of strings to efficiently convey
+# valor inteiro. Eles são frequentemente usados no lugar de strings para transmitir com eficiência os valores
+# specific, meaningful values
+# específicos e significativos
+
+:pending.class #=> Symbol
+:pendente.class #=> Symbol
+
+status = :pending
+status = :pendente
+
+status == :pending #=> true
+status == :pendente #=> true
+
+status == 'pending' #=> false
+status == 'pendente' #=> false
+
+status == :approved #=> false
+status == :aprovado #=> false
+
+# Arrays
+
+# This is an array
+# Isso é um array
+[1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Arrays can contain different types of items
+# Arrays podem conter diferentes tipos de itens
+
+array = [1, "hello", false] #=> => [1, "hello", false]
+array = [1, "Oi", false] #=> => [1, "Oi", false]
+
+# Arrays can be indexed
+# Arrays podem ser indexados
+# From the front
+# a partir do começo
+array[0] #=> 1
+array[12] #=> nil
+
+# Like arithmetic, [var] access
+# Como aritimetica, o acesso via [var]
+# is just syntactic sugar
+# é apenas açúcar sintático
+# for calling a method [] on an object
+# para chamar o método [] de um objeto
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# From the end
+# a partir do final
+array[-1] #=> 5
+
+# With a start and end index
+# Com um índice de começo e fim 
+array[2, 4] #=> [3, 4, 5]
+
+# Or with a range
+# Ou com um intervalo de valores
+array[1..3] #=> [2, 3, 4]
+
+# Add to an array like this
+# Adicionar a um array como este
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+
+# Hashes are Ruby's primary dictionary with keys/value pairs.
+# Hashes são dicionário com um par de chave(key)/valor(value)
+# Hashes are denoted with curly braces:
+# Hashes são simbolizados com chaves "{}"
+hash = {'color' => 'green', 'number' => 5}
+hash = {'cor' => 'verde', 'numero' => 5}
+
+hash.keys #=> ['cor', 'numero']
+
+# Hashes can be quickly looked up by key:
+# Hashes podem ser rapidamente pesquisado pela chave (key)
+hash['cor'] #=> 'verde'
+hash['numero'] #=> 5
+
+# Asking a hash for a key that doesn't exist returns nil:
+# Procurar em um hash por uma chave que não existe retorna nil:
+hash['nothing here'] #=> nil
+hash['nada aqui'] #=> nil
+
+# Iterate over hashes with the #each method:
+# Interar sobre hashes com o método #each:
+hash.each do |k, v|
+  puts "#{k} is #{v}"
+end
+
+hash.each do |k, v|
+  puts "#{k} é #{v}"
+end
+
+# Since Ruby 1.9, there's a special syntax when using symbols as keys:
+# Desde o Ruby 1.9, temos uma sintaxe especial quando usamos simbolos como chaves (keys)
+
+new_hash = { defcon: 3, action: true}
+novo_hash = { defcon: 3, acao: true}
+
+new_hash.keys #=> [:defcon, :action]
+novo_hash.keys #=> [:defcon, :acao]
+
+# Tip: Both Arrays and Hashes are Enumerable
+# Dica: Tanto Arrays quanto Hashes são Enumerable
+# They share a lot of useful methods such as each, map, count, and more
+# Eles compartilham um monte de métodos úteis como each, map, count e mais
+
+# Control structures
+# Estruturas de controle
+
+if true
+  "if statement"
+elsif false
+ "else if, optional"
+else
+ "else, also optional"
+end
+
+if true
+  "Se verdadeiro"
+elsif false
+ "else if, opicional"
+else
+ "else, também é opicional"
+end
+
+for counter in 1..5
+  puts "iteration #{counter}"
+end
+
+for contador in 1..5
+  puts "interação #{contador}"
+end
+#=> contador 1
+#=> contador 2
+#=> contador 3
+#=> contador 4
+#=> contador 5
+
+# HOWEVER
+# PORÉM
+# No-one uses for loops
+# Ninguém usa para loops
+# Use `each` instead, like this:
+# Use "each" em vez, dessa forma:
+
+(1..5).each do |counter|
+  puts "iteration #{counter}"
+end
+
+(1..5).each do |contador|
+  puts "interação #{contador}"
+end
+#=> contador 1
+#=> contador 2
+#=> contador 3
+#=> contador 4
+#=> contador 5
+
+counter = 1
+while counter <= 5 do
+  puts "iteration #{counter}"
+  counter += 1
+end
+
+contador = 1
+while contador <= 5 do
+  puts "interação #{contador}"
+  contador += 1
+end
+#=> contador 1
+#=> contador 2
+#=> contador 3
+#=> contador 4
+#=> contador 5
+
+grade = 'B'
+
+case grade
+when 'A'
+  puts "Way to go kiddo"
+when 'B'
+  puts "Better luck next time"
+when 'C'
+  puts "You can do better"
+when 'D'
+  puts "Scraping through"
+when 'F'
+  puts "You failed!"
+else 
+  puts "Alternative grading system, eh?"
+end
+
+grau = 'B'
+
+case grau
+when 'A'
+  puts "Um longo caminho a percorrer pequeno gafanhoto"
+when 'B'
+  puts "Melhor sorte da próxima vez"
+when 'C'
+  puts "Você pode fazer melhor"
+when 'D'
+  puts "Scraping through"
+when 'F'
+  puts "Você falhou"
+else 
+  puts "Alternative grading system, eh?"
+end
+
+# Functions
+# Funções
+
+def dobrar(x)
+  x * 2
+end
+
+# Functions (and all blocks) implcitly return the value of the last statement
+# Funções (e todos os blocos) retornam implicitamente o valor da última linha
+double(2) #=> 4
+dobrar(2) #=> 4
+
+# Parentheses are optional where the result is unambiguous
+# Parênteses são opicionais onde o resultado é claro
+double 3 #=> 6
+dobrar 3 #=> 6
+
+double double 3 #=> 12
+dobrar dobrar 3 #=> 12
+
+def sum(x,y)
+  x + y
+end
+
+def somar(x,y)
+  x + y
+end
+
+# Method arguments are separated by a comma
+# Argumentos de métodos são separados por uma virgula
+sum 3, 4 #=> 7
+somar 3, 4 #=> 7
+
+somar somar(3,4), 5 #=> 12
+
+# yield
+# All methods have an implicit, optional block parameter
+# Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco 
+# it can be called with the 'yield' keyword
+# ele pode ser chamado com a palavra chave 'yield'
+
+def surround
+  puts "{"
+  yield
+  puts "}"
+end
+
+surround { puts 'hello world' }
+
+
+def ao_redor
+  puts "{"
+  yield
+  puts "}"
+end
+
+ao_redor { puts 'Olá mundo' }
+
+# {
+# Olá mundo
+# }
+
+
+# Define a class with the class keyword
+# Define uma classe com a palavra chave 'class'
+class Human
+
+  # A class variable. It is shared by all instances of this class.
+  @@species = "H. sapiens"
+
+  # Basic initializer
+  def initialize(name, age=0)
+    # Assign the argument to the "name" instance variable for the instance
+    @name = name
+    # If no age given, we will fall back to the default in the arguments list.
+    @age = age
+  end
+
+  # Basic setter method
+  def name=(name)
+    @name = name
+  end
+
+  # Basic getter method
+  def name
+    @name
+  end
+
+  # A class method uses self to distinguish from instance methods.
+  # It can only be called on the class, not an instance.
+  def self.say(msg)
+    puts "#{msg}"
+  end
+
+  def species
+    @@species
+  end
+
+end
+
+
+class Humano
+
+  # Uma variavel de classe. Ela é compartilhada por todas as instancias dessa classe
+  @@especies = "H. sapiens"
+
+  # Inicialização básica (contructor)
+  def initialize(nome, idade=0)
+    # Atribui o argumento para a variavel de instacia "nome" do objeto
+    @nome = nome
+    # Se a idade não for passada, nós definimos um valor padrão na lista de argumentos
+    @idade = idade
+  end
+
+  # Método básico para atribuir valor
+  def nome=(nome)
+    @nome = nome
+  end
+
+  # Método básico de resgatar valor
+  def nome
+    @nome
+  end
+
+  # Um método de classe usa a palavra chave self para se defenciar dos métodos de instancia.
+  # Ele só pode ser chamado na classe, não na instancia
+  def self.diz(msg)
+    puts "#{msg}"
+  end
+
+  def especies
+    @@especies
+  end
+
+end
+
+
+# Instantiate a class
+# Instaciando uma classe
+jim = Human.new("Jim Halpert")
+jim = Humano.new("Jim Halpert")
+
+dwight = Human.new("Dwight K. Schrute")
+dwight = Humano.new("Dwight K. Schrute")
+
+# Let's call a couple of methods
+# Vamos chamar um par de métodos
+jim.species #=> "H. sapiens"
+jim.especies #=> "H. sapiens"
+
+jim.name #=> "Jim Halpert"
+jim.nome #=> "Jim Halpert"
+
+jim.name = "Jim Halpert II" #=> "Jim Halpert II"
+jim.nome = "Jim Halpert II" #=> "Jim Halpert II"
+
+jim.name #=> "Jim Halpert II"
+jim.nome #=> "Jim Halpert II"
+
+dwight.species #=> "H. sapiens"
+dwight.especies #=> "H. sapiens"
+
+dwight.name #=> "Dwight K. Schrute"
+dwight.nome #=> "Dwight K. Schrute"
+
+# Call the class method
+# Chamar o método de classe
+Human.say("Hi") #=> "Hi"
+Humano.diz("Oi") #=> "Oi"
+
+# Class also is object in ruby. So class can have instance variables.
+# Uma classe também é objeto em Ruby. Então uma classe pode possuir um variavel de instancia
+# Class variable is shared among the class and all of its descendants.
+# Variavies de classe são compartilhadas entre a classe e todos os seus descendentes.
+
+# base class
+class Human
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+
+# Classe base
+class Humano
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+#  classe filha
+class Trabalhador < Humano
+end
+
+Human.foo # 0
+Humano.foo # 0
+Worker.foo # 0
+Trabalhador.foo # 0
+
+Human.foo = 2 # 2
+Humano.foo = 2 # 2
+Worker.foo # 2
+Trabalhador.foo # 2
+
+# Class instance variable is not shared by the class's descendants.
+# Uma variavel de instancia não é compartilhada por suas classes decendentes.
+
+class Human
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(value)
+    @bar = value
+  end
+end
+
+class Humano
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(value)
+    @bar = value
+  end
+end
+
+class Doctor < Human
+end
+
+class Doutor < Humano
+end
+
+Humano.bar # 0
+Doutor.bar # nil
+
+```
-- 
cgit v1.2.3


From a2432ef31727c56fcfb2528523804da6ad21c4a0 Mon Sep 17 00:00:00 2001
From: Katyanna Moura <amelie.kn@gmail.com>
Date: Wed, 14 Aug 2013 12:01:30 -0300
Subject: =?UTF-8?q?revis=C3=A3o?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 pt-br/ruby-pt.html.markdown~ | 598 -------------------------------------------
 1 file changed, 598 deletions(-)
 delete mode 100644 pt-br/ruby-pt.html.markdown~

(limited to 'pt-br')

diff --git a/pt-br/ruby-pt.html.markdown~ b/pt-br/ruby-pt.html.markdown~
deleted file mode 100644
index cedd2db1..00000000
--- a/pt-br/ruby-pt.html.markdown~
+++ /dev/null
@@ -1,598 +0,0 @@
----
-language: ruby
-filename: learnruby.rb
-contributors:
-  - ["Bruno Henrique - Garu", "http://garulab.com"]
----
-
-```ruby
-# Isso é um comentario
-
-=begin
-This is a multiline comment
-No-one uses them
-You shouldn't either
-
-Isso é um comentario multilinha
-Ninguém os usa
-
-=end
-
-# First and foremost: Everything is an object.
-# Primeiro e principal: Tudo é um objeto.
-
-# Numbers are objects
-# Números são objetos
-
-3.class #=> Fixnum
-
-3.to_s #=> "3"
-
-
-# Some basic arithmetic
-# Aritmética básica
-
-1 + 1 #=> 2
-8 - 1 #=> 7
-10 * 2 #=> 20
-35 / 5 #=> 7
-
-# Arithmetic is just syntactic sugar
-# for calling a method on an object
-# Arithmetic é apenas açúcar semântico 
-# para chamar um métoddo de um objeto
-1.+(3) #=> 4
-10.* 5 #=> 50 
-
-# Special values are objects
-# Valores especiais são obejetos
-nil # Nothing to see here 
-nil # Nada para ver aqui
-true # truth
-true # verdadeiro
-false # falsehood
-false # falso
-
-nil.class #=> NilClass
-true.class #=> TrueClass
-false.class #=> FalseClass
-
-# Equality
-# Igualdade
-1 == 1 #=> true
-2 == 1 #=> false
-
-# Inequality
-# Desigualdade
-1 != 1 #=> false
-2 != 1 #=> true
-!true  #=> false
-!false #=> true
-
-# apart from false itself, nil is the only other 'falsey' value
-# além de 'false', 'nil' é o único outro valor falso
-
-!nil   #=> true
-!false #=> true
-!0     #=> false
-
-# More comparisons
-# Mais comparações
-1 < 10 #=> true
-1 > 10 #=> false
-2 <= 2 #=> true
-2 >= 2 #=> true
-
-# Strings are objects
-# Strings são obejetos
-
-'I am a string'.class #=> String
-'Eu sou uma string'.class #=> String
-"I am a string too".class #=> String
-"Eu também sou uma string".class #=> String
-
-placeholder = "use string interpolation"
-placeholder = "usar interpolação de string"
-"I can #{placeholder} when using double quoted strings"
-"Eu posso #{placeholder} quando estiver usando aspas duplas"
-#=> "I can use string interpolation when using double quoted strings"
-#=> "Eu posso usar insterpolação de string quando estiver usando aspas duplas"
-
-
-# print to the output
-# imprime para output (saida)
-puts "I'm printing!"
-puts "Estou imprimindo"
-
-# Variables
-# Variáveis
-x = 25 #=> 25
-x #=> 25
-
-# Note that assignment returns the value assigned
-# Note que uma atribuição retorna o valor atribuido
-# This means you can do multiple assignment:
-# Isso significa que você pode fazer multiplas atribuições:
-
-x = y = 10 #=> 10
-x #=> 10
-y #=> 10
-
-# By convention, use snake_case for variable names
-# Por convenção, use snake_case para nomes de variáveis
-snake_case = true
-
-# Use descriptive variable names
-# Use nomes de variáveis descrivos
-path_to_project_root = '/good/name/'
-caminho_para_a_raiz_do_projeto = '/bom/nome/'
-path = '/bad/name/'
-caminho = '/nome/ruim/'
-
-# Symbols (are objects)
-# Simbolos (são objetos)
-# Symbols are immutable, reusable constants represented internally by an
-# Simbolos são imultáveis, são constantes reutilizáveis representadadas internamente por um
-# integer value. They're often used instead of strings to efficiently convey
-# valor inteiro. Eles são frequentemente usados no lugar de strings para transmitir com eficiência os valores
-# specific, meaningful values
-# específicos e significativos
-
-:pending.class #=> Symbol
-:pendente.class #=> Symbol
-
-status = :pending
-status = :pendente
-
-status == :pending #=> true
-status == :pendente #=> true
-
-status == 'pending' #=> false
-status == 'pendente' #=> false
-
-status == :approved #=> false
-status == :aprovado #=> false
-
-# Arrays
-
-# This is an array
-# Isso é um array
-[1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
-
-# Arrays can contain different types of items
-# Arrays podem conter diferentes tipos de itens
-
-array = [1, "hello", false] #=> => [1, "hello", false]
-array = [1, "Oi", false] #=> => [1, "Oi", false]
-
-# Arrays can be indexed
-# Arrays podem ser indexados
-# From the front
-# a partir do começo
-array[0] #=> 1
-array[12] #=> nil
-
-# Like arithmetic, [var] access
-# Como aritimetica, o acesso via [var]
-# is just syntactic sugar
-# é apenas açúcar sintático
-# for calling a method [] on an object
-# para chamar o método [] de um objeto
-array.[] 0 #=> 1
-array.[] 12 #=> nil
-
-# From the end
-# a partir do final
-array[-1] #=> 5
-
-# With a start and end index
-# Com um índice de começo e fim 
-array[2, 4] #=> [3, 4, 5]
-
-# Or with a range
-# Ou com um intervalo de valores
-array[1..3] #=> [2, 3, 4]
-
-# Add to an array like this
-# Adicionar a um array como este
-array << 6 #=> [1, 2, 3, 4, 5, 6]
-
-# Hashes are Ruby's primary dictionary with keys/value pairs.
-# Hashes são dicionário com um par de chave(key)/valor(value)
-# Hashes are denoted with curly braces:
-# Hashes são simbolizados com chaves "{}"
-hash = {'color' => 'green', 'number' => 5}
-hash = {'cor' => 'verde', 'numero' => 5}
-
-hash.keys #=> ['cor', 'numero']
-
-# Hashes can be quickly looked up by key:
-# Hashes podem ser rapidamente pesquisado pela chave (key)
-hash['cor'] #=> 'verde'
-hash['numero'] #=> 5
-
-# Asking a hash for a key that doesn't exist returns nil:
-# Procurar em um hash por uma chave que não existe retorna nil:
-hash['nothing here'] #=> nil
-hash['nada aqui'] #=> nil
-
-# Iterate over hashes with the #each method:
-# Interar sobre hashes com o método #each:
-hash.each do |k, v|
-  puts "#{k} is #{v}"
-end
-
-hash.each do |k, v|
-  puts "#{k} é #{v}"
-end
-
-# Since Ruby 1.9, there's a special syntax when using symbols as keys:
-# Desde o Ruby 1.9, temos uma sintaxe especial quando usamos simbolos como chaves (keys)
-
-new_hash = { defcon: 3, action: true}
-novo_hash = { defcon: 3, acao: true}
-
-new_hash.keys #=> [:defcon, :action]
-novo_hash.keys #=> [:defcon, :acao]
-
-# Tip: Both Arrays and Hashes are Enumerable
-# Dica: Tanto Arrays quanto Hashes são Enumerable
-# They share a lot of useful methods such as each, map, count, and more
-# Eles compartilham um monte de métodos úteis como each, map, count e mais
-
-# Control structures
-# Estruturas de controle
-
-if true
-  "if statement"
-elsif false
- "else if, optional"
-else
- "else, also optional"
-end
-
-if true
-  "Se verdadeiro"
-elsif false
- "else if, opicional"
-else
- "else, também é opicional"
-end
-
-for counter in 1..5
-  puts "iteration #{counter}"
-end
-
-for contador in 1..5
-  puts "interação #{contador}"
-end
-#=> contador 1
-#=> contador 2
-#=> contador 3
-#=> contador 4
-#=> contador 5
-
-# HOWEVER
-# PORÉM
-# No-one uses for loops
-# Ninguém usa para loops
-# Use `each` instead, like this:
-# Use "each" em vez, dessa forma:
-
-(1..5).each do |counter|
-  puts "iteration #{counter}"
-end
-
-(1..5).each do |contador|
-  puts "interação #{contador}"
-end
-#=> contador 1
-#=> contador 2
-#=> contador 3
-#=> contador 4
-#=> contador 5
-
-counter = 1
-while counter <= 5 do
-  puts "iteration #{counter}"
-  counter += 1
-end
-
-contador = 1
-while contador <= 5 do
-  puts "interação #{contador}"
-  contador += 1
-end
-#=> contador 1
-#=> contador 2
-#=> contador 3
-#=> contador 4
-#=> contador 5
-
-grade = 'B'
-
-case grade
-when 'A'
-  puts "Way to go kiddo"
-when 'B'
-  puts "Better luck next time"
-when 'C'
-  puts "You can do better"
-when 'D'
-  puts "Scraping through"
-when 'F'
-  puts "You failed!"
-else 
-  puts "Alternative grading system, eh?"
-end
-
-grau = 'B'
-
-case grau
-when 'A'
-  puts "Um longo caminho a percorrer pequeno gafanhoto"
-when 'B'
-  puts "Melhor sorte da próxima vez"
-when 'C'
-  puts "Você pode fazer melhor"
-when 'D'
-  puts "Scraping through"
-when 'F'
-  puts "Você falhou"
-else 
-  puts "Alternative grading system, eh?"
-end
-
-# Functions
-# Funções
-
-def dobrar(x)
-  x * 2
-end
-
-# Functions (and all blocks) implcitly return the value of the last statement
-# Funções (e todos os blocos) retornam implicitamente o valor da última linha
-double(2) #=> 4
-dobrar(2) #=> 4
-
-# Parentheses are optional where the result is unambiguous
-# Parênteses são opicionais onde o resultado é claro
-double 3 #=> 6
-dobrar 3 #=> 6
-
-double double 3 #=> 12
-dobrar dobrar 3 #=> 12
-
-def sum(x,y)
-  x + y
-end
-
-def somar(x,y)
-  x + y
-end
-
-# Method arguments are separated by a comma
-# Argumentos de métodos são separados por uma virgula
-sum 3, 4 #=> 7
-somar 3, 4 #=> 7
-
-somar somar(3,4), 5 #=> 12
-
-# yield
-# All methods have an implicit, optional block parameter
-# Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco 
-# it can be called with the 'yield' keyword
-# ele pode ser chamado com a palavra chave 'yield'
-
-def surround
-  puts "{"
-  yield
-  puts "}"
-end
-
-surround { puts 'hello world' }
-
-
-def ao_redor
-  puts "{"
-  yield
-  puts "}"
-end
-
-ao_redor { puts 'Olá mundo' }
-
-# {
-# Olá mundo
-# }
-
-
-# Define a class with the class keyword
-# Define uma classe com a palavra chave 'class'
-class Human
-
-  # A class variable. It is shared by all instances of this class.
-  @@species = "H. sapiens"
-
-  # Basic initializer
-  def initialize(name, age=0)
-    # Assign the argument to the "name" instance variable for the instance
-    @name = name
-    # If no age given, we will fall back to the default in the arguments list.
-    @age = age
-  end
-
-  # Basic setter method
-  def name=(name)
-    @name = name
-  end
-
-  # Basic getter method
-  def name
-    @name
-  end
-
-  # A class method uses self to distinguish from instance methods.
-  # It can only be called on the class, not an instance.
-  def self.say(msg)
-    puts "#{msg}"
-  end
-
-  def species
-    @@species
-  end
-
-end
-
-
-class Humano
-
-  # Uma variavel de classe. Ela é compartilhada por todas as instancias dessa classe
-  @@especies = "H. sapiens"
-
-  # Inicialização básica (contructor)
-  def initialize(nome, idade=0)
-    # Atribui o argumento para a variavel de instacia "nome" do objeto
-    @nome = nome
-    # Se a idade não for passada, nós definimos um valor padrão na lista de argumentos
-    @idade = idade
-  end
-
-  # Método básico para atribuir valor
-  def nome=(nome)
-    @nome = nome
-  end
-
-  # Método básico de resgatar valor
-  def nome
-    @nome
-  end
-
-  # Um método de classe usa a palavra chave self para se defenciar dos métodos de instancia.
-  # Ele só pode ser chamado na classe, não na instancia
-  def self.diz(msg)
-    puts "#{msg}"
-  end
-
-  def especies
-    @@especies
-  end
-
-end
-
-
-# Instantiate a class
-# Instaciando uma classe
-jim = Human.new("Jim Halpert")
-jim = Humano.new("Jim Halpert")
-
-dwight = Human.new("Dwight K. Schrute")
-dwight = Humano.new("Dwight K. Schrute")
-
-# Let's call a couple of methods
-# Vamos chamar um par de métodos
-jim.species #=> "H. sapiens"
-jim.especies #=> "H. sapiens"
-
-jim.name #=> "Jim Halpert"
-jim.nome #=> "Jim Halpert"
-
-jim.name = "Jim Halpert II" #=> "Jim Halpert II"
-jim.nome = "Jim Halpert II" #=> "Jim Halpert II"
-
-jim.name #=> "Jim Halpert II"
-jim.nome #=> "Jim Halpert II"
-
-dwight.species #=> "H. sapiens"
-dwight.especies #=> "H. sapiens"
-
-dwight.name #=> "Dwight K. Schrute"
-dwight.nome #=> "Dwight K. Schrute"
-
-# Call the class method
-# Chamar o método de classe
-Human.say("Hi") #=> "Hi"
-Humano.diz("Oi") #=> "Oi"
-
-# Class also is object in ruby. So class can have instance variables.
-# Uma classe também é objeto em Ruby. Então uma classe pode possuir um variavel de instancia
-# Class variable is shared among the class and all of its descendants.
-# Variavies de classe são compartilhadas entre a classe e todos os seus descendentes.
-
-# base class
-class Human
-  @@foo = 0
-
-  def self.foo
-    @@foo
-  end
-
-  def self.foo=(value)
-    @@foo = value
-  end
-end
-
-
-# Classe base
-class Humano
-  @@foo = 0
-
-  def self.foo
-    @@foo
-  end
-
-  def self.foo=(value)
-    @@foo = value
-  end
-end
-
-#  classe filha
-class Trabalhador < Humano
-end
-
-Human.foo # 0
-Humano.foo # 0
-Worker.foo # 0
-Trabalhador.foo # 0
-
-Human.foo = 2 # 2
-Humano.foo = 2 # 2
-Worker.foo # 2
-Trabalhador.foo # 2
-
-# Class instance variable is not shared by the class's descendants.
-# Uma variavel de instancia não é compartilhada por suas classes decendentes.
-
-class Human
-  @bar = 0
-
-  def self.bar
-    @bar
-  end
-
-  def self.bar=(value)
-    @bar = value
-  end
-end
-
-class Humano
-  @bar = 0
-
-  def self.bar
-    @bar
-  end
-
-  def self.bar=(value)
-    @bar = value
-  end
-end
-
-class Doctor < Human
-end
-
-class Doutor < Humano
-end
-
-Humano.bar # 0
-Doutor.bar # nil
-
-```
-- 
cgit v1.2.3


From d9a27d3aa497dd1bb360c24566130fa3b154cb34 Mon Sep 17 00:00:00 2001
From: Katyanna Moura <amelie.kn@gmail.com>
Date: Wed, 14 Aug 2013 12:52:39 -0300
Subject: adding name and removing lines in English

---
 pt-br/ruby-pt.html.markdown | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown
index 732d06a4..a3e60043 100644
--- a/pt-br/ruby-pt.html.markdown
+++ b/pt-br/ruby-pt.html.markdown
@@ -3,6 +3,7 @@ language: ruby
 filename: learnruby.rb
 contributors:
   - ["Bruno Henrique - Garu", "http://garulab.com"]
+  - ["Katyanna Moura"]
 ---
 
 ```ruby
@@ -30,14 +31,12 @@ Você não deve usar também
 10 * 2 #=> 20
 35 / 5 #=> 7
 
-# Arithmetic is just syntactic sugar
-# for calling a method on an object
-# Arithmetic é apenas açúcar semântico 
-# para chamar um métoddo de um objeto
+# Aritimética é apenas açúcar sintático
+# para chamar um método de um objeto
 1.+(3) #=> 4
 10.* 5 #=> 50 
 
-# Valores especiais são obejetos
+# Valores especiais são objetos
 nil # Nothing to see here 
 nil # Nada para ver aqui
 true # truth
@@ -71,7 +70,7 @@ false.class #=> FalseClass
 2 <= 2 #=> true
 2 >= 2 #=> true
 
-# Strings are objects
+# Strings são objects
 
 'I am a string'.class #=> String
 'Eu sou uma string'.class #=> String
@@ -102,14 +101,14 @@ y #=> 10
 # Por convenção, use snake_case para nomes de variáveis
 snake_case = true
 
-# Use nomes de variáveis descrivos
+# Use nomes de variáveis descritivos
 path_to_project_root = '/good/name/'
 caminho_para_a_raiz_do_projeto = '/bom/nome/'
 path = '/bad/name/'
 caminho = '/nome/ruim/'
 
-# Simbolos (são objetos)
-# Simbolos são imultáveis, são constantes reutilizáveis representadadas internamente por um
+# Símbolos (são objetos)
+# Símbolos são imutáveis, são constantes reutilizáveis representadadas internamente por um
 # valor inteiro. Eles são frequentemente usados no lugar de strings para transmitir com eficiência os valores
 # específicos e significativos
 
@@ -143,7 +142,7 @@ array = [1, "Oi", false] #=> => [1, "Oi", false]
 array[0] #=> 1
 array[12] #=> nil
 
-# Como aritimetica, o acesso via [var]
+# Como aritimética, o acesso via [var]
 # é apenas açúcar sintático
 # para chamar o método [] de um objeto
 array.[] 0 #=> 1
@@ -168,7 +167,7 @@ hash = {'cor' => 'verde', 'numero' => 5}
 
 hash.keys #=> ['cor', 'numero']
 
-# Hashes podem ser rapidamente pesquisado pela chave (key)
+# Hashes podem ser rapidamente pesquisados pela chave (key)
 hash['cor'] #=> 'verde'
 hash['numero'] #=> 5
 
@@ -185,7 +184,7 @@ hash.each do |k, v|
   puts "#{k} é #{v}"
 end
 
-# Desde o Ruby 1.9, temos uma sintaxe especial quando usamos simbolos como chaves (keys)
+# Desde o Ruby 1.9, temos uma sintaxe especial quando usamos símbolos como chaves (keys)
 
 new_hash = { defcon: 3, action: true}
 novo_hash = { defcon: 3, acao: true}
@@ -193,7 +192,7 @@ novo_hash = { defcon: 3, acao: true}
 new_hash.keys #=> [:defcon, :action]
 novo_hash.keys #=> [:defcon, :acao]
 
-# Dica: Tanto Arrays quanto Hashes são Enumerable
+# Dica: Tanto Arrays quanto Hashes são Enumerable.
 # Eles compartilham um monte de métodos úteis como each, map, count e mais
 
 # Estruturas de controle
@@ -320,7 +319,7 @@ def somar(x,y)
   x + y
 end
 
-# Argumentos de métodos são separados por uma virgula
+# Argumentos de métodos são separados por uma vírgula
 sum 3, 4 #=> 7
 somar 3, 4 #=> 7
 
@@ -425,7 +424,7 @@ class Humano
 end
 
 
-# Instaciando uma classe
+# Instanciando uma classe
 jim = Human.new("Jim Halpert")
 jim = Humano.new("Jim Halpert")
 
-- 
cgit v1.2.3


From c1b08624fb7b4fa36cb55ad7fcefe98e073ab32c Mon Sep 17 00:00:00 2001
From: Katyanna Moura <amelie.kn@gmail.com>
Date: Wed, 14 Aug 2013 13:20:47 -0300
Subject: removing lines of code in english

---
 pt-br/ruby-pt.html.markdown | 162 ++------------------------------------------
 1 file changed, 5 insertions(+), 157 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown
index a3e60043..a6021b06 100644
--- a/pt-br/ruby-pt.html.markdown
+++ b/pt-br/ruby-pt.html.markdown
@@ -7,7 +7,7 @@ contributors:
 ---
 
 ```ruby
-# Isso é um comentario
+# Isso é um comentário
 
 =begin
 Isso é um comentário multilinha
@@ -37,11 +37,8 @@ Você não deve usar também
 10.* 5 #=> 50 
 
 # Valores especiais são objetos
-nil # Nothing to see here 
 nil # Nada para ver aqui
-true # truth
 true # verdadeiro
-false # falsehood
 false # falso
 
 nil.class #=> NilClass
@@ -72,19 +69,14 @@ false.class #=> FalseClass
 
 # Strings são objects
 
-'I am a string'.class #=> String
 'Eu sou uma string'.class #=> String
-"I am a string too".class #=> String
 "Eu também sou uma string".class #=> String
 
-placeholder = "use string interpolation"
 placeholder = "usar interpolação de string"
-"I can #{placeholder} when using double quoted strings"
 "Eu posso #{placeholder} quando estiver usando aspas duplas"
 #=> "Eu posso usar insterpolação de string quando estiver usando aspas duplas"
 
 # imprime para output (saída)
-puts "I'm printing!"
 puts "Estou imprimindo"
 
 # Variáveis
@@ -102,9 +94,7 @@ y #=> 10
 snake_case = true
 
 # Use nomes de variáveis descritivos
-path_to_project_root = '/good/name/'
 caminho_para_a_raiz_do_projeto = '/bom/nome/'
-path = '/bad/name/'
 caminho = '/nome/ruim/'
 
 # Símbolos (são objetos)
@@ -112,19 +102,14 @@ caminho = '/nome/ruim/'
 # valor inteiro. Eles são frequentemente usados no lugar de strings para transmitir com eficiência os valores
 # específicos e significativos
 
-:pending.class #=> Symbol
 :pendente.class #=> Symbol
 
-status = :pending
 status = :pendente
 
-status == :pending #=> true
 status == :pendente #=> true
 
-status == 'pending' #=> false
 status == 'pendente' #=> false
 
-status == :approved #=> false
 status == :aprovado #=> false
 
 # Arrays
@@ -134,7 +119,6 @@ status == :aprovado #=> false
 
 # Arrays podem conter diferentes tipos de itens
 
-array = [1, "hello", false] #=> => [1, "hello", false]
 array = [1, "Oi", false] #=> => [1, "Oi", false]
 
 # Arrays podem ser indexados
@@ -162,7 +146,6 @@ array << 6 #=> [1, 2, 3, 4, 5, 6]
 
 # Hashes são o principal dicionário de Ruby com pares de chaves(keys)/valor(value).
 # Hashes são simbolizados com chaves "{}"
-hash = {'color' => 'green', 'number' => 5}
 hash = {'cor' => 'verde', 'numero' => 5}
 
 hash.keys #=> ['cor', 'numero']
@@ -172,7 +155,6 @@ hash['cor'] #=> 'verde'
 hash['numero'] #=> 5
 
 # Procurar em um hash por uma chave que não existe retorna nil:
-hash['nothing here'] #=> nil
 hash['nada aqui'] #=> nil
 
 # Interar sobre hashes com o método #each:
@@ -186,10 +168,8 @@ end
 
 # Desde o Ruby 1.9, temos uma sintaxe especial quando usamos símbolos como chaves (keys)
 
-new_hash = { defcon: 3, action: true}
 novo_hash = { defcon: 3, acao: true}
 
-new_hash.keys #=> [:defcon, :action]
 novo_hash.keys #=> [:defcon, :acao]
 
 # Dica: Tanto Arrays quanto Hashes são Enumerable.
@@ -197,14 +177,6 @@ novo_hash.keys #=> [:defcon, :acao]
 
 # Estruturas de controle
 
-if true
-  "if statement"
-elsif false
- "else if, optional"
-else
- "else, also optional"
-end
-
 if true
   "Se verdadeiro"
 elsif false
@@ -213,10 +185,6 @@ else
  "else, também é opicional"
 end
 
-for counter in 1..5
-  puts "iteration #{counter}"
-end
-
 for contador in 1..5
   puts "interação #{contador}"
 end
@@ -230,10 +198,6 @@ end
 # Ninguém usa para loops
 # Use "each" em vez, dessa forma:
 
-(1..5).each do |counter|
-  puts "iteration #{counter}"
-end
-
 (1..5).each do |contador|
   puts "interação #{contador}"
 end
@@ -243,12 +207,6 @@ end
 #=> contador 4
 #=> contador 5
 
-counter = 1
-while counter <= 5 do
-  puts "iteration #{counter}"
-  counter += 1
-end
-
 contador = 1
 while contador <= 5 do
   puts "interação #{contador}"
@@ -260,28 +218,11 @@ end
 #=> contador 4
 #=> contador 5
 
-grade = 'B'
-
-case grade
-when 'A'
-  puts "Way to go kiddo"
-when 'B'
-  puts "Better luck next time"
-when 'C'
-  puts "You can do better"
-when 'D'
-  puts "Scraping through"
-when 'F'
-  puts "You failed!"
-else 
-  puts "Alternative grading system, eh?"
-end
-
 grau = 'B'
 
 case grau
 when 'A'
-  puts "Um longo caminho a percorrer pequeno gafanhoto"
+  puts "Um longo caminho a percorrer, pequeno gafanhoto"
 when 'B'
   puts "Melhor sorte da próxima vez"
 when 'C'
@@ -301,26 +242,18 @@ def dobrar(x)
 end
 
 # Funções (e todos os blocos) retornam implicitamente o valor da última linha
-double(2) #=> 4
 dobrar(2) #=> 4
 
 # Parênteses são opicionais onde o resultado é claro
-double 3 #=> 6
 dobrar 3 #=> 6
 
-double double 3 #=> 12
 dobrar dobrar 3 #=> 12
 
-def sum(x,y)
-  x + y
-end
-
 def somar(x,y)
   x + y
 end
 
 # Argumentos de métodos são separados por uma vírgula
-sum 3, 4 #=> 7
 somar 3, 4 #=> 7
 
 somar somar(3,4), 5 #=> 12
@@ -329,15 +262,6 @@ somar somar(3,4), 5 #=> 12
 # Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco 
 # ele pode ser chamado com a palavra chave 'yield'
 
-def surround
-  puts "{"
-  yield
-  puts "}"
-end
-
-surround { puts 'hello world' }
-
-
 def ao_redor
   puts "{"
   yield
@@ -352,50 +276,15 @@ ao_redor { puts 'Olá mundo' }
 
 
 # Define uma classe com a palavra chave 'class'
-class Human
-
-  # A class variable. It is shared by all instances of this class.
-  @@species = "H. sapiens"
-
-  # Basic initializer
-  def initialize(name, age=0)
-    # Assign the argument to the "name" instance variable for the instance
-    @name = name
-    # If no age given, we will fall back to the default in the arguments list.
-    @age = age
-  end
-
-  # Basic setter method
-  def name=(name)
-    @name = name
-  end
-
-  # Basic getter method
-  def name
-    @name
-  end
-
-  # A class method uses self to distinguish from instance methods.
-  # It can only be called on the class, not an instance.
-  def self.say(msg)
-    puts "#{msg}"
-  end
-
-  def species
-    @@species
-  end
-
-end
-
 
 class Humano
 
-  # Uma variavel de classe. Ela é compartilhada por todas as instancias dessa classe
+  # Uma variável de classe. Ela é compartilhada por todas as instâncias dessa classe
   @@especies = "H. sapiens"
 
   # Inicialização básica (contructor)
   def initialize(nome, idade=0)
-    # Atribui o argumento para a variavel de instacia "nome" do objeto
+    # Atribui o argumento para a variável de instancia "nome" do objeto
     @nome = nome
     # Se a idade não for passada, nós definimos um valor padrão na lista de argumentos
     @idade = idade
@@ -411,7 +300,7 @@ class Humano
     @nome
   end
 
-  # Um método de classe usa a palavra chave self para se defenciar dos métodos de instancia.
+  # Um método de classe usa a palavra chave self para se defenciar dos métodos de instância.
   # Ele só pode ser chamado na classe, não na instancia
   def self.diz(msg)
     puts "#{msg}"
@@ -425,51 +314,29 @@ end
 
 
 # Instanciando uma classe
-jim = Human.new("Jim Halpert")
 jim = Humano.new("Jim Halpert")
 
-dwight = Human.new("Dwight K. Schrute")
 dwight = Humano.new("Dwight K. Schrute")
 
 # Vamos chamar um par de métodos
-jim.species #=> "H. sapiens"
 jim.especies #=> "H. sapiens"
 
-jim.name #=> "Jim Halpert"
 jim.nome #=> "Jim Halpert"
 
-jim.name = "Jim Halpert II" #=> "Jim Halpert II"
 jim.nome = "Jim Halpert II" #=> "Jim Halpert II"
 
-jim.name #=> "Jim Halpert II"
 jim.nome #=> "Jim Halpert II"
 
-dwight.species #=> "H. sapiens"
 dwight.especies #=> "H. sapiens"
 
-dwight.name #=> "Dwight K. Schrute"
 dwight.nome #=> "Dwight K. Schrute"
 
 # Chamar o método de classe
-Human.say("Hi") #=> "Hi"
 Humano.diz("Oi") #=> "Oi"
 
 # Uma classe também é objeto em Ruby. Então uma classe pode possuir variável de instância
 # Variáveis de classe são compartilhadas entre a classe e todos os seus descendentes.
 
-# base class
-class Human
-  @@foo = 0
-
-  def self.foo
-    @@foo
-  end
-
-  def self.foo=(value)
-    @@foo = value
-  end
-end
-
 
 # Classe base
 class Humano
@@ -488,30 +355,14 @@ end
 class Trabalhador < Humano
 end
 
-Human.foo # 0
 Humano.foo # 0
-Worker.foo # 0
 Trabalhador.foo # 0
 
-Human.foo = 2 # 2
 Humano.foo = 2 # 2
-Worker.foo # 2
 Trabalhador.foo # 2
 
 # Uma variável de instância não é compartilhada por suas classes decendentes.
 
-class Human
-  @bar = 0
-
-  def self.bar
-    @bar
-  end
-
-  def self.bar=(value)
-    @bar = value
-  end
-end
-
 class Humano
   @bar = 0
 
@@ -524,9 +375,6 @@ class Humano
   end
 end
 
-class Doctor < Human
-end
-
 class Doutor < Humano
 end
 
-- 
cgit v1.2.3


From c0d84572021330c404fb689241369878cff200e4 Mon Sep 17 00:00:00 2001
From: Bruno Henrique - Garu <squall.bruno@gmail.com>
Date: Wed, 14 Aug 2013 13:34:10 -0300
Subject: Add link to contributor

---
 pt-br/ruby-pt.html.markdown | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown
index a6021b06..8e8ce6a8 100644
--- a/pt-br/ruby-pt.html.markdown
+++ b/pt-br/ruby-pt.html.markdown
@@ -3,7 +3,7 @@ language: ruby
 filename: learnruby.rb
 contributors:
   - ["Bruno Henrique - Garu", "http://garulab.com"]
-  - ["Katyanna Moura"]
+  - ["Katyanna Moura", "https://twitter.com/amelie_kn"]
 ---
 
 ```ruby
@@ -34,7 +34,7 @@ Você não deve usar também
 # Aritimética é apenas açúcar sintático
 # para chamar um método de um objeto
 1.+(3) #=> 4
-10.* 5 #=> 50 
+10.* 5 #=> 50
 
 # Valores especiais são objetos
 nil # Nada para ver aqui
@@ -135,7 +135,7 @@ array.[] 12 #=> nil
 # a partir do final
 array[-1] #=> 5
 
-# Com um índice de começo e fim 
+# Com um índice de começo e fim
 array[2, 4] #=> [3, 4, 5]
 
 # Ou com um intervalo de valores
@@ -231,7 +231,7 @@ when 'D'
   puts "Scraping through"
 when 'F'
   puts "Você falhou"
-else 
+else
   puts "Alternative grading system, eh?"
 end
 
@@ -259,7 +259,7 @@ somar 3, 4 #=> 7
 somar somar(3,4), 5 #=> 12
 
 # yield
-# Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco 
+# Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco
 # ele pode ser chamado com a palavra chave 'yield'
 
 def ao_redor
-- 
cgit v1.2.3


From 8aa0ab6068a13491ec9cba59bce32911ab9f8061 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Fri, 16 Aug 2013 09:44:22 -0700
Subject: Edits

---
 pt-br/ruby-pt.html.markdown | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown
index 8e8ce6a8..484bb0dd 100644
--- a/pt-br/ruby-pt.html.markdown
+++ b/pt-br/ruby-pt.html.markdown
@@ -1,5 +1,6 @@
 ---
 language: ruby
+lang: br-pt
 filename: learnruby.rb
 contributors:
   - ["Bruno Henrique - Garu", "http://garulab.com"]
@@ -98,9 +99,10 @@ caminho_para_a_raiz_do_projeto = '/bom/nome/'
 caminho = '/nome/ruim/'
 
 # Símbolos (são objetos)
-# Símbolos são imutáveis, são constantes reutilizáveis representadadas internamente por um
-# valor inteiro. Eles são frequentemente usados no lugar de strings para transmitir com eficiência os valores
-# específicos e significativos
+# Símbolos são imutáveis, são constantes reutilizáveis representadadas
+# internamente por um valor inteiro. Eles são frequentemente usados no
+# lugar de strings para transmitir com eficiência os valores específicos
+# e significativos
 
 :pendente.class #=> Symbol
 
-- 
cgit v1.2.3