SlideShare uma empresa Scribd logo
RR-71
Desenvolvimento Ágil para Web
        2.0 com Ruby on Rails
A Caelum atua no mercado com consultoria, desenvolvimento e ensino em computação. Sua equipe
participou do desenvolvimento de projetos em vários clientes e, após apresentar os cursos de verão de Java
na Universidade de São Paulo, passou a oferecer treinamentos para o mercado. Toda a equipe tem uma
forte presença na comunidade através de eventos, artigos em diversas revistas, participação em muitos
projetos open source como o VRaptor e o Stella e atuação nos fóruns e listas de discussão como o GUJ.

    Com uma equipe de mais de 60 profissionais altamente qualificados e de destaque do mercado, oferece
treinamentos em Java, Ruby on Rails e Scrum em suas três unidades - São Paulo, Rio de Janeiro e
Brasília. Mais de 8 mil alunos já buscaram qualificação nos treinamentos da Caelum tanto em nas unidades
como nas próprias empresas com os cursos incompany.

   O compromisso da Caelum é oferecer um treinamento de qualidade, com material constantemente
atualizado, uma metodologia de ensino cuidadosamente desenvolvida e instrutores capacitados
tecnicamente e didaticamente. E oferecer ainda serviços de consultoria ágil, mentoring e desenvolvimento
de projetos sob medida para empresas.




                                          Comunidade

                 Nossa equipe escreve constantemente artigos no Blog da Caelum que já conta
                 com 150 artigos sobre vários assuntos de Java, Rails e computação em geral.
                 Visite-nos e assine nosso RSS:
                 ➡ blog.caelum.com.br



                 Acompanhe também a equipe Caelum no Twitter:
                 ➡ twitter.com/caelumdev/equipe



                 O GUJ é maior fórum de Java em língua portuguesa, com 700 mil posts e 70 mil
                 usuários. As pessoas da Caelum participam ativamente, participe também:
                 ➡ www.guj.com.br



                 Assine também nossa Newsletter para receber as novidades e destaques dos
                 eventos, artigos e promoções da Caelum:
                 ➡ www.caelum.com.br/newsletter


                 No site da Caelum há algumas de nossas Apostilas disponíveis gratuitamente
                 para download e alguns dos artigos de destaque que escrevemos:
                 ➡ www.caelum.com.br/apostilas
                 ➡ www.caelum.com.br/artigos
Conheça alguns de nossos cursos

             FJ-11:                             FJ-25:
             Java e Orientação a                Persistência com JPA2 e
             objetos                            Hibernate



             FJ-16:                             FJ-26:
             Laboratório Java com Testes,       Laboratório Web com JSF2 e
             XML e Design Patterns              CDI



             FJ-19:                             FJ-31:
             Preparatório para Certificação     Java EE avançado e
             de Programador Java                Web Services



             FJ-21:                             FJ-91:
             Java para Desenvolvimento          Arquitetura e Design de
             Web                                Projetos Java



             RR-71:                             RR-75:
             Desenvolvimento Ágil para Web      Ruby e Rails avançados: lidando
             2.0 com Ruby on Rails              com problemas do dia a dia



Para mais informações e outros cursos, visite: caelum.com.br/cursos


  ✓   Mais de 8000 alunos treinados;
  ✓   Reconhecida nacionalmente;
  ✓   Conteúdos atualizados para o mercado e para sua carreira;
  ✓   Aulas com metodologia e didática cuidadosamente preparadas;
  ✓   Ativa participação nas comunidades Java, Rails e Scrum;
  ✓   Salas de aula bem equipadas;
  ✓   Instrutores qualificados e experientes;
  ✓   Apostilas disponíveis no site.
Sobre esta apostila
   Esta apostila da Caelum visa ensinar de uma maneira elegante, mostrando apenas o que é necessário e
quando é necessário, no momento certo, poupando o leitor de assuntos que não costumam ser de seu interesse
em determinadas fases do aprendizado.

   A Caelum espera que você aproveite esse material. Todos os comentários, críticas e sugestões serão muito
bem-vindos.

    Essa apostila é constantemente atualizada e disponibilizada no site da Caelum. Sempre consulte o site para
novas versões e, ao invés de anexar o PDF para enviar a um amigo, indique o site para que ele possa sempre
baixar as últimas versões. Você pode conferir o código de versão da apostila logo no final do índice.

   Baixe sempre a versão mais nova em: www.caelum.com.br/apostilas

    Esse material é parte integrante do treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails
e distribuído gratuitamente exclusivamente pelo site da Caelum. Todos os direitos são reservados à Caelum.
A distribuição, cópia, revenda e utilização para ministrar treinamentos são absolutamente vedadas. Para uso
comercial deste material, por favor, consulte a Caelum previamente.


                                                                                          www.caelum.com.br




                                                      1
Índice


1 Agilidade na Web                                                                                                  1

  1.1 A agilidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   1

  1.2 A comunidade Rails . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .      1

  1.3 Bibliografia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   2

  1.4 Tirando dúvidas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     3

  1.5 Para onde ir depois? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .      3


2 A linguagem Ruby                                                                                                  4

  2.1 A história do Ruby e suas características . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .       4

  2.2 Instalação do interpretador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     4

  2.3 Outras implementações de interpretadores Ruby . . . . . . . . . . . . . . . . . . . . . . . . . . .           6

  2.4 Ruby Enterprise Edition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     7

  2.5 Interactive Ruby: ruby no terminal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .      8


3 Classes, objetos e métodos                                                                                        9

  3.1 Váriáveis, Strings e Comentários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .      9

  3.2 Exercícios - Variáveis, Atribuições . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

  3.3 Tipos e operações básicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

  3.4 Exercícios - Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

  3.5 Estruturas de controle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

  3.6 Exercícios - Estruturas de controle e Regexp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

  3.7 Desafios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15




                                                         i
4 Mais Ruby: classes, objetos e métodos                                                                           16

  4.1 Mundo orientado a objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

  4.2 Métodos comuns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

  4.3 Definição de métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

  4.4 Exercícios - Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

  4.5 Discussão: Enviando mensagens aos objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

  4.6 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

  4.7 Exercícios - Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

  4.8 Desafio: Classes abertas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

  4.9 self . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

  4.10 Desafio: self e o método puts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

  4.11 Atributos e propriedades: acessores e modificadores . . . . . . . . . . . . . . . . . . . . . . . . . 20

  4.12 Syntax Sugar: facilitando a sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

  4.13 Exercícios - Atributos e propriedades     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

  4.14 Coleções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

  4.15 Exemplo: múltiplos parâmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

  4.16 Hashes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

  4.17 Exercícios - Arrays e Hashes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

  4.18 Blocos e Programação Funcional        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

  4.19 Exercícios - Blocos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

  4.20 Para saber mais: Mais sobre blocos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

  4.21 Desafio: Usando blocos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

  4.22 Manipulando erros e exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

  4.23 Exercício: Manipulando exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

  4.24 Arquivos com código fonte ruby      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

  4.25 Para saber mais: um pouco de IO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37


5 Metaprogramação e Padrões de Projeto                                                                            39

  5.1 Métodos de Classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

  5.2 Para saber mais: Singleton Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

  5.3 Exercícios - Ruby Object Model       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

  5.4 Design Patterns: Singleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42


                                                         ii
5.5 Exercicio: Design Pattern - Singleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

  5.6 Convenções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

  5.7 Polimorfirmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

  5.8 Exercícios - Duck Typing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

  5.9 Design Patterns: Template Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

  5.10 Exercicio Opcional: Design Pattern - Template Method . . . . . . . . . . . . . . . . . . . . . . . . 47

  5.11 Modulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

  5.12 Design Patterns: Observer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

  5.13 Desafio: Design Pattern - Observer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

  5.14 Metaprogramação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

  5.15 Exercícios - Metaprogramação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53


6 Ruby on Rails                                                                                                    55

  6.1 Ruby On Rails . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

  6.2 Aprender Ruby? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

  6.3 IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

  6.4 Criando um novo projeto rails . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

  6.5 Exercícios: Iniciando o Projeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

  6.6 Estrutura dos diretórios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

  6.7 Carregando as dependências          . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

  6.8 O Banco de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

  6.9 Exercícios: Criando o banco de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

  6.10 A base da construção: scaffold (andaime) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

  6.11 Exercícios: Scaffold . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

  6.12 Gerar as tabelas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

  6.13 Versão do Banco de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

  6.14 Exercícios: Migrar tabela . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

  6.15 Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

  6.16 Exercícios: Iniciando o servidor    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

  6.17 Documentação do Rails . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

  6.18 Exercício Opcional: Utilizando a documentação . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69




                                                         iii
7 Active Record                                                                                                   70

  7.1 Motivação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

  7.2 Exercícios: Controle de Restaurantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

  7.3 Modelo - O “M” do MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

  7.4 ActiveRecord . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

  7.5 Rake . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

  7.6 Criando Modelos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

  7.7 Migrations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

  7.8 Exercícios: Criando os modelos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

  7.9 Manipulando nossos modelos pelo console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

  7.10 Exercícios: Manipulando registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

  7.11 Exercícios Opcionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

  7.12 Finders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

  7.13 Exercícios: Buscas dinâmicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

  7.14 Validações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

  7.15 Exercícios: Validações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

  7.16 Exercícios - Completando nosso modelo         . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

  7.17 O Modelo Qualificação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

  7.18 Exercícios - Criando o Modelo de Qualificação . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

  7.19 Relacionamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

  7.20 Para Saber Mais: Auto-relacionamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

  7.21 Para Saber Mais: Cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

  7.22 Exercícios - Relacionamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

  7.23 Para Saber Mais - Eager Loading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

  7.24 Para Saber Mais - Named Scopes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

  7.25 Para Saber Mais - Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99


8 Controllers e Views                                                                                           100

  8.1 O “V” e o “C” do MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

  8.2 Hello World . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

  8.3 Exercícios: Criando o controlador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

  8.4 Redirecionamento de Action e Action padrão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103


                                                        iv
8.5 Trabalhando com a View: O ERB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

  8.6 Entendendo melhor o CRUD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

  8.7 Exercícios: Controlador do Restaurante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

  8.8 Helper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

  8.9 Exercícios: Utilizando helpers para criar as views . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

  8.10 Partial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

  8.11 Exercícios: Customizando o cabeçalho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

  8.12 Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

  8.13 Exercícios: Criando o header . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

  8.14 Outras formas de gerar a View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

  8.15 Filtros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117


9 Rotas e Rack                                                                                                    119

  9.1 Rack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

  9.2 Exercícios - Testando o Rack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

  9.3 routes.rb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

  9.4 Pretty URLs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

  9.5 Named Routes        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

  9.6 REST - resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

  9.7 Actions extras em Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

  9.8 Diversas Representações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

  9.9 Para Saber Mais - Nested Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

  9.10 Rails e o Rack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

  9.11 Exercícios - Criando um rota para uma aplicação Rack . . . . . . . . . . . . . . . . . . . . . . . . 127


10 Completando o Sistema                                                                                          128

  10.1 Um pouco mais sobre o Scaffold . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

  10.2 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

  10.3 Selecionando Clientes e Restaurante no form de Qualificações . . . . . . . . . . . . . . . . . . . 132

  10.4 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

  10.5 Exercícios Opcionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

  10.6 Mais sobre os controllers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140



                                                         v
11 Calculations                                                                                                   143

   11.1 Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

   11.2 Média . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

   11.3 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144


12 Associações Polimórficas                                                                                        145

   12.1 Nosso problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

   12.2 Alterando o banco de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

   12.3 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147


13 Ajax com Rails                                                                                                 151

   13.1 Adicionando comentários nas views . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151

   13.2 Instalando manualmente o JQuery no projeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151

   13.3 Instalando o JQuery no projeto usando a gem jquery-rails . . . . . . . . . . . . . . . . . . . . . . 153

   13.4 Criando as chamadas AJAX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

   13.5 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156

   13.6 Adicionando comentários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

   13.7 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162


14 Alguns Plugins e Gems Importantes                                                                              166

   14.1 Paginação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166

   14.2 Exercícios - Título . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167

   14.3 Hpricot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167

   14.4 Exercícios - Testando o Hpricot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

   14.5 File Uploads: Paperclip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

   14.6 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169


15 Testes                                                                                                         171

   15.1 O Porquê dos testes? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

   15.2 Test::Unit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

   15.3 Exercícios - Teste do modelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

   15.4 Exercícios - Teste do controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174

   15.5 RSpec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

   15.6 Cucumber, o novo Story Runner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

                                                          vi
16 Apêndice B - Integrando Java e Ruby                                                                             182

   16.1 O Projeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

   16.2 Testando o JRuby . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

   16.3 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

   16.4 Compilando ruby para .class com Jruby . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183

   16.5 Rodando o .class do ruby na JVM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183

   16.6 Importando um bytecode(.class) criado pelo jruby . . . . . . . . . . . . . . . . . . . . . . . . . . . 184

   16.7 Importando classes do Java para sua aplicação JRuby . . . . . . . . . . . . . . . . . . . . . . . . 184

   16.8 Testando o JRuby com Swing        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185


17 Apêndice C - Deployment                                                                                         187

   17.1 Webrick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

   17.2 CGI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

   17.3 FCGI - FastCGI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

   17.4 Lighttpd e Litespeed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

   17.5 Mongrel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

   17.6 Proxies Reversos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

   17.7 Phusion Passenger (mod_rails)       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189

   17.8 Ruby Enterprise Edition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189

   17.9 Exercícios: Deploy com Apache e Passenger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190


18 Apêndice D - Instalação                                                                                         192

   18.1 Ruby - Ubuntu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

   18.2 Ruby - Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

   18.3 Rails . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

   18.4 JDK    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

   18.5 Aptana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

   18.6 Mongrel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

   18.7 MySQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

   18.8 SVN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
                                                Versão: 13.8.8




                                                         vii
C APÍTULO     1

Agilidade na Web
        “Não são os milagres que inclinam o realista para a fé. O verdadeiro realista, caso não creia, sempre
   encontrará em si força e capacidade para não acreditar no milagre, e se o milagre se apresenta diante dele
                             como fato irrefutável, é mais fácil ele descrer de seus sentidos que admitir o fato”
                                                                        – Fiodór Dostoievski, em Irmãos Karamazov


 1.1 - A agilidade
   Quais são os problemas mais frequentes no desenvolvimento web? Seriam os problemas com AJAX?
Escrever SQL? Tempo demais para gerar os CRUDs básicos?

    Com tudo isso em mente, David Heinemeier Hansson, trabalhando na 37Signals, começou a procurar uma
linguagem de programação que pudesse utilizar para desenvolver os projetos de sua empresa. Mais ainda,
criou um framework web para essa linguagem, que permitiria a ele escrever uma aplicação web de maneira
simples e elegante.

   Em agosto de 2010 foi lançada a versão final do Rails 3 e a Caelum ministra turmas com o material atualizado
para esta versão desde então.

    O que possibilita toda essa simplicidade do Rails são os recursos poderosos que Ruby oferece e que deram
toda a simplicidade ao Rails. Esses recursos proporcionados pela linguagem Ruby são fundamentais de serem
compreendidos por todos que desejam se tornar bons desenvolvedores Rails e por isso o começo desse curso
foca bastante em apresentar as características da linguagem e seus diferenciais.

   Um exemplo clássico da importância de conhecer mais a fundo a linguagem Ruby está em desvendar a
“magia negra” por trás do Rails. Conceitos como meta programação, onde código é criado dinamicamente,
são essenciais para o entendimento de qualquer sistema desenvolvido em Rails. É a meta programação que
permite, por exemplo, que tenhamos classes extremamente enxutas e que garante o relacionamento entre as
tabelas do banco de dados com nossas classes de modelo sem a necessidade de nenhuma linha de código,
apenas usando de convenções.

   Esse curso apresenta ainda os conceitos de programação funcional, uso de blocos, duck typing, enfim, tudo
o que é necessário para a formação da base de conceitos que serão utilizados ao longo do curso e da vida
como um desenvolvedor Rails.


 1.2 - A comunidade Rails
   A comunidade Rails é hoje uma das mais ativas e unidas do Brasil. Cerca de 10 eventos acontecem anual-
mente com o único propósito de difundir conhecimento e unir os desenvolvedores. Um exemplo dessa força é o
Ruby Conf, maior evento de Ruby da America Latina, com presença dos maiores nomes nacionais e internaci-
onais de Ruby on Rails, e a presença de uma track dedicada ao Ruby na QCon São Paulo.



                                                       1
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    Além dos eventos, diversos blogs sobre Rails tem ajudado diversos programadores a desvendar esse novo
universo:

   • http://blog.caelum.com.br/ - Blog da Caelum

   • http://andersonleite.com.br/ - Anderson Leite

   • http://agilenomundoreal.com.br/ - Guilherme Silveira

   • http://davidpaniz.com/ - David Paniz

   • http://yehudakatz.com/ - Yehuda Katz

   • http://fabiokung.com/ - Fabio Kung

   • http://akitaonrails.com/ - Fábio Akita

   • http://blog.plataformatec.com.br/ - José Valim

   • http://www.nomedojogo.com/ - Carlos Brando

   • http://caueguerra.com - Cauê Guerra

   • http://railsenvy.com/ - Rails Envy

   • http://www.rubyinside.com.br/ - RubyInside Brasil

   • http://rubyflow.com/ - Rubyflow

   A Caelum aposta no Rails desde 2007, quando criamos o primeiro curso a respeito. E o ano de 2009 marcou
o Ruby on Rails no Brasil, ano em que ele foi adotado por diversas empresas grandes e até mesmo orgãos do
governo, como mencionado num post em nosso blog no começo do mesmo ano:

   http://blog.caelum.com.br/2009/01/19/2009-ano-do-ruby-on-rails-no-brasil/


 1.3 - Bibliografia

   • Agile Web Development with Rails - Sam Ruby, Dave Thomas, David Heinemeier Hansson
     Esse é o livro referência no aprendizado de Ruby on Rails, criado pelo autor do framework. Aqui, ele
     mostra através de um projeto, os principais conceitos e passos no desenvolvimento de uma aplicação
     completa. Existe uma versão em andamento para Rails 3.

   • Programming Ruby: The Pragmatic Programmers’ Guide - Dave Thomas, Chad Fowler, Andy Hunt
     Conhecido como “Pickaxe”, esse livro pode ser considerado a bíblia do programador Ruby. Cobre toda a
     especificação da linguagem e procura desvendar toda a “magia” do Ruby.

   • The Pragmatic Programmer: From Journeyman to Master - Andrew Hunt, David Thomas
     As melhores práticas para ser um bom desenvolvedor: desde o uso de versionamento, ao bom uso do
     logging, debug, nomenclaturas, como consertar bugs, etc.
     Existe ainda um post no blog da Caelum sobre livros que todo desenvolvedor Rails deve ler: http://blog.
     caelum.com.br/2009/08/25/a-trinca-de-ases-do-programador-rails/



                                                                Capítulo 1 - Agilidade na Web - Bibliografia - Página 2
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 1.4 - Tirando dúvidas
  Para tirar dúvidas dos exercícios, ou de Ruby e Rails em geral, recomendamos se inscrever na lista do
GURU-SP (http://groups.google.com/group/ruby-sp), onde sua dúvida será respondida prontamente.

   Também recomendamos duas outras listas:

   • http://groups.google.com/group/rubyonrails-talk

   • http://groups.google.com/group/rails-br

   Fora isso, sinta-se à vontade para entrar em contato com seu instrutor e tirar todas as dúvidas que tiver
durante o curso.

   O fórum do GUJ.com.br, conceituado em java, possui também um subfórum de Rails:

   http://www.guj.com.br/


 1.5 - Para onde ir depois?
    Além de fazer nossos cursos de Rails, você deve participar ativamente da comunidade. Ela é muito viva e
ativa, e as novidades aparecem rapidamente. Se você ainda não tinha hábito de participar de fóruns, listas e
blogs, essa é uma grande oportunidade.

    Há ainda a possibilidade de participar de projetos opensource, e de você criar gems e plugins pro rails que
sejam úteis a toda comunidade.




                                                              Capítulo 1 - Agilidade na Web - Tirando dúvidas - Página 3
C APÍTULO      2

A linguagem Ruby
                                                                              “Rails is the killer app for Ruby.”
                                                               – Yukihiro Matsumoto, Criador da linguagem Ruby


   Neste capítulo, conheceremos a poderosa linguagem de programação Ruby, base para completo entendi-
mento do framework Ruby on Rails. Uma linguagem dinâmica e poderosa como o Ruby vai se mostrar útil não
apenas para o uso no Rails, como também para outras tarefas e scripts do dia a dia.

   Veremos a história, o contexto, suas versões e interpretadores e uma iniciação a sintaxe da linguagem.


 2.1 - A história do Ruby e suas características
    Ruby foi apresentada ao público pela primeira vez em 1995, pelo seu criador: Yukihiro Matsumoto, mun-
dialmente conhecido como Matz. É uma linguagem orientada a objetos, com tipagem forte e dinâmica. Cu-
riosamente é uma das únicas linguagens nascidas fora do eixo EUA - Europa que atingiram enorme sucesso
comercial.

   Uma de suas principais características é a expressividade que possui. Teve-se como objetivo desde o início
que fosse uma linguagem muito simples de ler e ser entendida, para facilitar o desenvolvimento e manutenção
de sistemas escritos com ela.

    Ruby é uma linguagem interpretada e, como tal, necessita da instalação de um interpretador em sua má-
quina antes de executar algum programa.


             Orientação a objetos pura
            Entre as linguagens de programação orientada a objetos, muito se discute se são puramente orien-
            tadas a objeto ou não, já que grande parte possui recursos que não se comportam como objetos.
            Os tipos primitivos de Java são um exemplo desta contradição, já que não são objetos de verdade.
            Ruby é considerada uma linguagem puramente orientada a objetos, já que tudo em Ruby é um
            objeto (inclusive as classes, como veremos).


 2.2 - Instalação do interpretador
   Antes da linguagem Ruby se tornar popular, existia apenas um interpretador disponível: o escrito pelo
próprio Matz, em C. É um interpretador simples, sem nenhum gerenciamento de memória muito complexo, nem
características modernas de interpretadores como a compilação em tempo de execução (conhecida como JIT).

   Este interpretador é conhecido como Matz’s Ruby Interpreter (MRI), ou CRuby (já que é escrito em C) e é
também considerado a implementação de referência para a linguagem Ruby.



                                                     4
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    A última versão estável é a 1.9.x, também conhecida como YARV e deve ser usada em produção, apesar de
ser uma versão de transição até o Ruby 2.0 onde serão inclusas diversas mudanças e novas funcionalidades.
Como a versão 1.9.x é recente, vários projetos ainda estão utilizando a versão 1.8.x.

    A maioria das distribuições Linux possuem o pacote de uma das última versões estáveis pronto para ser
instalado. O exemplo mais comum de instalação é para o Ubuntu:


sudo apt-get install ruby1.8 ruby1.8-dev


   O interpretador ruby (MRI) já vem instalado no Mac OS X.

    Apesar de existirem soluções prontas para a instalação do Ruby em diversas plataformas (one-click-
installers), sempre é possível baixá-lo pelo site oficial:

   http://ruby-lang.org
   Após a instalação, não deixe de conferir se o interpretador está disponível na sua variável de ambiente
PATH:


$ ruby --version
ruby 1.8.6 (2007-09-24 patchlevel 111) [i486-linux]




   A saída pode ser um pouco diferente, dependendo do sistema operacional e da versão instalada. Nesta
apostila existe um apêndice sobre a instalação e detalhes do Ruby, caso você esteja enfrentando problemas.

   Ruby possui um gerenciador de pacotes e dependências bastante avançado, flexível e eficiente: Ruby-
Gems. Os gems podem ser vistos como bibliotecas reutilizáveis de código Ruby, que podem até conter algum
código nativo (em C, Java, .Net). São análogos aos jars no ambiente Java, ou os assemblies do mundo .Net.
RubyGems é um sistema gerenciador de pacotes comparável a qualquer um do mundo *NIX, como os .debs do
apt-get, o MacPorts (BSD Ports), os rpms com yum, entre outros.

   Portanto, para sermos capazes de instalar e utilizar as centenas de gems disponíveis, precisamos instalar
além do interpretador Ruby, o Rubygems. Basta baixá-lo no endereço abaixo e executar o script de instalação
contido no pacote:

   http://www.rubygems.org/

cd rubygems-1.x.x
ruby setup.rb



                                                   Capítulo 2 - A linguagem Ruby - Instalação do interpretador - Página 5
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 2.3 - Outras implementações de interpretadores Ruby
    Com a popularização da linguagem Ruby (iniciada pelo Ruby on Rails), implementações alternativas da
linguagem começaram a ficar em evidência. A maioria delas segue uma tendência natural de serem baseados
em uma Máquina Virtual ao invés de serem simples interpretadores. Algumas implementações possuem até
compiladores completos, que transformam o código Ruby em alguma linguagem intermediária a ser interpretada
por uma máquina virtual. Vale a pena conhecer algumas das principais opções do mercado.
   O próprio Ruby 1.9 de referência (YARV), evolução do MRI, é baseado em uma máquina virtual: Yet Another
Ruby VM.
   A principal vantagem das máquinas virtuais é facilitar o suporte em diferentes plataformas. Além disso, ter
código intermediário permite otimização do código em tempo de execução, feito através da JIT.
    JRuby foi a primeira implementação completa da versão 1.8.6 do Ruby. O JRuby é a principal implemen-
tação em Java da linguagem Ruby e é hoje considerada por muitos como a implementação mais rápida da
linguagem.
   Não é um simples interpretador, já que também opera nos modos AOT - compilação Ahead Of Time e JIT -
Just In Time compilation, além do modo interpretador tradicional (Tree Walker ).
   Teremos um capítulo exclusivo sobre JRuby, mas uma de suas principais vantagens é a interoperabilidade
com código Java existente, além de aproveitar todas as vantagens de uma das plataformas de execução de
código mais maduras (GC, JIT, Threads nativas, entre outras).
   Além disso, a própria Oracle e a Sun Microsystems apostam no projeto, já que alguns de seus principais
desenvolvedores, Charles Nutter (líder técnico do projeto), Tomas Enebo e Nick Sieger já trabalharam para a
Sun. O JRuby também suporta o Rails 3.
    A comunidade .Net também não ignora o sucesso da linguagem e patrocina o projeto IronRuby, mantido
pela própria Microsoft. IronRuby foi um dos primeiros projetos verdadeiramente de código aberto dentro da
Microsoft.
    Ruby.NET é outro projeto que tem como objetivo possibilitar código Ruby ser executado na plataforma .Net.
Originalmente conhecido como Gardens Point Ruby.NET Compiler, procura ser um compilador de código Ruby
para a CLR do mundo .Net.
    Criada por Evan Phoenix, Rubinius é um dos projetos que tem recebido mais atenção pela comunidade
Ruby, por ter o objetivo de criar a implementação de Ruby com a maior parte possível do código em Ruby. Além
disso, trouxe idéias de máquinas virtuais do SmallTalk, possuindo um conjunto de instruções (bytecode) próprio
e implementada em C/C++.
   http://rubini.us
    O projeto Rubinius possui uma quantidade de testes enorme, escritos em Ruby. O que incentivou a iniciativa
de especificar a linguagem Ruby. O projeto RubySpec (http://rubyspec.org/) é um acordo entre os vários im-
plementadores da linguagem Ruby para especificar as características da linguagem Ruby e seu comportamento,
através de código executável, que funciona como um TCK (Test Compatibility Kit).
   RubySpec tem origem na suíte de testes de unidade do projeto Rubinius, escritos com uma versão mínima
do RSpec, conhecida como MSpec. O RSpec é um framework para descrição de especificações no estilo
pregado pelo Behavior Driven Development. Veremos mais sobre isso no capítulo de testes.
    Avi Bryant é um programador Ruby conhecido, que mudou para Smalltalk e hoje é um defensor fervoroso
da linguagem; além de ser um dos criadores do principal framework web em SmallTalk: Seaside. Durante seu
keynote na RailsConf de 2007, lançou um desafio à comunidade:

                                  Capítulo 2 - A linguagem Ruby - Outras implementações de interpretadores Ruby - Página 6
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    “I’m from the future, I know how this story ends. All the people who are saying you can’t implement Ruby on
a fast virtual machine are wrong. That machine already exists today, it’s called Gemstone, and it could certainly
be adapted to Ruby. It runs Smalltalk, and Ruby essentially is Smalltalk. So adapting it to run Ruby is absolutely
within the realm of the possible.”

   Ruby e Smalltalk são parecidos demais. Avi basicamente pergunta: por que não criar máquinas virtuais
para Ruby, aproveitando toda a tecnologia de máquinas virtuais para SmallTalk, que já têm bastante maturidade
e estão no mercado a tantos anos?

  Integrantes da empresa Gemstone, que possui uma das máquinas virtuais para SmallTalk mais famosas -
Gemstone/S, estavam na platéia e chamaram o Avi Bryant para provar que isto era possível.

   Na RailsConf de 2008, o resultado foi que a Gemstone apresentou o produto que estão desenvolvendo,
conhecido como Maglev. É uma máquina virtual para Ruby, baseada na existente para Smalltalk. As linguagens
são tão parecidas que apenas poucas instruções novas tiveram de ser inseridas na nova máquina virtual.

   Os números apresentados são surpreendentes. Com tão pouco tempo de desenvolvimento, conseguiram
apresentar um ganho de até 30x de performance em alguns micro benchmarks.

    Apesar de ter feito bastante barulho durante a RailsConf 2008, a Gemstone anda bastante quieta sobre o
Maglev e não mostrou mais nada desde então. Muitos criticam esta postura da empresa de ter falado sobre
algo tão antes de poderem mostrar, além de terem exibido números que não podem provar.

    Antonio Cangiano teve acesso a uma versão preliminar do Maglev e publicou um famoso comparativo de
performance (benchmark ) em seu blog, conhecido como “The Great Ruby Shootout”, em que o Maglev se
mostra em média 1.8x mais rápido que a MRI. Sendo muito mais rápido em alguns benchmarks e muito mais
lento em alguns outros.

    http://antoniocangiano.com/2008/12/09/the-great-ruby-shootout-december-2008/


 2.4 - Ruby Enterprise Edition
   Para melhorar a performance de aplicações Rails e diminuir a quantidade de memória utilizada, Ninh Bui,
Hongli Lai e Tinco Andringa (da Phusion) modificaram o interpretador Ruby e lançaram com o nome de Ruby
Enterprise Edition.

    As principais modificações no REE foram no comportamento do Garbage Collector, fazendo com que fun-
cione com o recurso de Copy on Write disponível na maioria dos sistemas operacionais baseados em UNIX
(Linux, Solaris, ...).

   Outra importante modificação foi na alocação de memória do interpretador, com o uso de bibliotecas famo-
sas como tcmalloc.

    Os desenvolvedores da Phusion já ofereceram as modificações (patches) para entrar na implementação
oficial, MRI. É ainda um mistério para a comunidade o porquê de tais modificações importantes ainda não terem
entrado para a versão oficial do interpretador.

    http://izumi.plan99.net/blog/index.php/2008/08/17/          _making-ruby’s-garbage-collector-copy-on-write-
friendly-part-8/


              Copy on Write? tcmalloc?
             Mais detalhes sobre estes assuntos estão no capítulo sobre Deployment.



                                                        Capítulo 2 - A linguagem Ruby - Ruby Enterprise Edition - Página 7
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   No capítulo sobre deployment, veremos mais sobre o outro produto da empresa Phusion, o Phusion Pas-
senger - também conhecido como mod_rails. Hoje, é o produto recomendado para rodar aplicações Rails em
produção.


 2.5 - Interactive Ruby: ruby no terminal
    O IRB é um dos principais recursos disponíveis aos programadores Ruby. Funciona como um con-
sole/terminal, e os comandos vão sendo interpretados ao mesmo tempo em que vão sendo inseridos, de forma
interativa. O irb avalia cada linha inserida e já mostra o resultado imediatamente.

   Todos os comandos apresentados neste capítulo podem ser executados dentro do irb, ou em arquivos .rb.
Por exemplo, poderíamos criar um arquivo chamado teste.rb e executá-lo com o seguinte comando:


ruby teste.rb




                                           Capítulo 2 - A linguagem Ruby - Interactive Ruby: ruby no terminal - Página 8
C APÍTULO    3

Classes, objetos e métodos
                                    “Pensa como pensam os sábios, mas fala como falam as pessoas simples”
                                                                                              – Aristóteles


 3.1 - Váriáveis, Strings e Comentários
   Ao aprender uma nova linguagem de programação sempre nos deparamos com o famoso “Olá Mundo”.
Podemos imprimir uma mensagem com ruby utilizando pelo menos 3 opções: puts, print e p.

puts "Olá Mundo"

   Comentários em Ruby podem ser de uma linha apenas:

# Imprime uma mensagem
puts "Olá mundo"

   Ou comentários de blocos:

=begin
    Imprime uma mensagem
=end
    puts "Olá mundo"

             Comentários de bloco
           Nos comentários de bloco, tanto o “=begin” quanto o “=end” devem ficar no início da linha, tota-
           lemnte a esquerda. Os comentários de blocos não costumam ser muito usádos Ruby, a própria
           documentação do Rails usa apenas comentários de linha.


   Um outro tipo importante nos programas Ruby são os objetos do tipo String. As Strings literais em Ruby
podem ser delimitadas por aspas simples ou aspas duplas (e outras formas especiais que veremos mais adi-
ante).

   A principal característica das Strings em Ruby é que são mutáveis, diferente de Java, por exemplo.

>> mensagem = "Bom dia, "
=> "Bom dia,"
>> mensagem << " tudo bem?"
=> "Bom dia, tudo bem?"
>> puts(mensagem)
Bom dia, tudo bem?
=> nil

    A concatenação de Strings (operador +) gera novas Strings, é o mesmo comportamento do Java. O operador
“<<” é usado para a operação append de Strings.

                                                     9
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   Uma alternativa mais interessante para criar Strings com valor dinâmico é a interpolação:

resultado = 6 * 5
texto = "O resultado é #{resultado}. Algo maior seria #{resultado + 240}"

    Qualquer expressão (código Ruby) pode ser interpolada em uma String. Porém, apenas Strings delimitadas
por aspas duplas aceitam interpolação.

   Prefira sempre a interpolação ao invés da concatenação (+), ou do append (<<). É mais limpo e mais rápido.


 3.2 - Exercícios - Variáveis, Atribuições

1) Vamos fazer alguns testes com o Ruby, escrevendo o código e executando no terminal. O arquivo utlizado
   se chamará restaurante, pois nossa futura aplicação web será um sistema de qualificação de restaurantes.

     • Crie um diretório no desktop com o nome ruby
     • Dentro deste diretório crie o arquivo restaurante_basico.rb

   Ao final de cada exercício voce pode rodar o arquivo no terminal com o comando ruby restau-
   rante_basico.rb.

2) Imprimir uma mensagem de “Olá Mundo” em Ruby é bem simples. No arquivo restaurante.rb programe o
   código abaixo.

   # ’Olá Mundo’ em ruby
         print "Ola mundo com print"
         puts "Ola mundo com puts"
     p "Ola mundo com p"
   Qual a diferença entre cada um? Escreva suas conclusões nos comentários.

3) Variáveis em ruby são tipadas implicitamente. Vamos criar algumas variáveis e imprimir usando interpola-
   ção.

   nome = "Fazano"
   puts "O nome do restaurante é #{nome}"
   puts nome.class

4) Em ruby, no geral, as variáveis possuem comportamento mutável, mas para isso normalmente usamos o
   método com nome terminado com o operador “!"(bang).

   puts nome # Fazano

   # comportamento imutável sem !
   nome.upcase
   puts nome # Fazano

   # comportamento mutável
   nome.upcase!
   puts nome # FAZANO




                                     Capítulo 3 - Classes, objetos e métodos - Exercícios - Variáveis, Atribuições - Página 10
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 3.3 - Tipos e operações básicas
     Ruby permite avaliar expressões aritméticas tradicionais:

>> 3*(2+5)/8
=> 2




     Estão disponíveis os operadores tradicionais: +, -, /, *, ** (potência) e % (resto da divisão inteira).

     Os valores podem ainda ser atribuídos a variáveis:

>>   resultado = 4 ** 2
=>   16
>>   puts(resultado)
16
=>   nil

     puts é o método usado para imprimir valores na saída padrão (stdout) e nil é o objeto nulo do Ruby.

    Ruby fornece uma maneira de trabalharmos com sequências de uma forma bem simples: (1..3) # range
representando números de 1 a 3. (‘a’..’z’) # range representando letras minúsculas do alfabeto (0...5) # range
representando números de 1 a 4.


               Palavras Reservadas
              alias and BEGIN begin break case class def defined do else elsif END end ensure false for if in
              module next nil not or redo rescue retry return self super then true undef unless until when while
              yield


   Símbolos também são texto, como as Strings. Só que devem ser precedidos do caracter ’:’, ao invés de
aspas e pertencem à classe Symbol:

>> puts :simbolo
simbolo
=> nil
>> :simbolo.class
=> Symbol

     As principais diferenças são:

     • São imutáveis. Uma vez criado, um símbolo não pode ser alterado. Se precisarmos de um novo valor,
       precisa criar um novo objeto símbolo.

                                               Capítulo 3 - Classes, objetos e métodos - Tipos e operações básicas - Página 11
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




     • São compartilhados. Símbolos com o mesmo valor, mesmo que em locais diferentes do código, compar-
       tilham do mesmo objeto. Isto é, qualquer lugar da aplicação que contenha, por exemplo, :writable, se
       referem a um mesmo objeto do tipo Symbol.

   Por causa destas características, símbolos são análogos às Strings do Java. As Strings do Ruby estão mais
para o StringBuilder do Java. Por serem imutáveis e compartilhados, objetos Symbol geralmente são usados
como identificadores e para nomenclatura (labels). Durante o curso usaremos muito este recurso.


 3.4 - Exercícios - Tipos

1) Em Ruby tudo é objeto. Vamos fazer alguns testes curiosos e descobrir os tipos:

     # Tipos
     3.times{
         puts "O 3 é um objeto!"
     }
     puts 3.class
     puts 33333333333333333333333.class

2) Podemos fazer as operações básicas em ruby de forma simples:

     # imprime conta
     puts 3*(2+5)/8

3) Vamos testar o recurso de ranges do ruby imprimindo uma sequência de números e letras. Obs: Utilizaremos
   uma notação avançada aqui, não se preocupe, ela será explicada logo adiante.

     # ranges
     puts (0..10).each { |x| puts x }
     puts (’a’..’z’).each { |x| puts x }


 3.5 - Estruturas de controle
   Para utilizar estruturas de controle em ruby, precisamos antes conhecer os operadores boobleanos, true e
false. Os operadores booleanos aceitam quaisquer expressões aritméticas:

>>   3 > 2
=>   true
>>   3+4-2 <= 3*2/4
=>   false

    Os operadores booleanos são: ==, >, <, >= e <=. Expressões booleanas podem ainda ser combinadas com
os operadores && (and) e || (or).

   O if do ruby aceita qualquer expressão booleana, no entanto, cada objeto em Ruby possui um “valor
booleano”. Os únicos objetos de valor booleano false são o próprio false e o nil. Portanto, qualquer valor
pode ser usado como argumento do if:

>> variavel = nil
=> nil
>> if(variavel)

                                                  Capítulo 3 - Classes, objetos e métodos - Exercícios - Tipos - Página 12
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




>>    puts("so iria imprimir se variavel != null")
>> end
=> nil
>> if(3 == 3)
>>    puts("3 é 3")
>> end
3 é 3
=> nil

     Teste também o switch:

def proucura_sede_copa_do_mundo( ano )
   case ano
   when 1895..1993
     "Não lembro... :)"
   when 1994
     "Estados Unidos"
   when 1998
     "França"
   end
end

puts proucura_sede_copa_do_mundo(1994)

     O código acima funciona como uma série de if/elsif :

if 1994 == ano
   "Estados Unidos"
 elsif 1998 == ano
   "França"
 elsif 1895..1993 == ano
     "Não lembro... :)"
 end

     Utilizar um laço de repetições pode poupar muito trabalho. Em ruby o código é bem direto:

for i in (1..3)
    x = i
end

     Ruby possui bom suporte a expressões regulares, fortemente influenciado pelo Perl. Expressões regulares
literais são delimitadas por / (barra).

>>   /rio/ =~ "são paulo"
=>   nil
>>   /paulo/ =~ "são paulo"
=>   4

   O operador =~ faz a função de match e retorna a posição da String onde o padrão foi encontrado, ou nil
caso a String não bata com a expressão regular. Expressões regulares aparecem com uma frequência maior
em linguagens dinâmicas, e, também por sua sintaxe facilitada no Ruby, utilizaremos bastante.




                                                Capítulo 3 - Classes, objetos e métodos - Estruturas de controle - Página 13
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




             Rubular.com
            Um site muito interessante para testar Expressões Regulares é o http://rubular.com/


             MatchData
            Há também o método match, que retorna um objeto do tipo MatchData, ao invés da posição do
            match. O objeto retornado pelo método match contém diversas informações úteis sobre o resultado
            da expressão regular, como o valor de agrupamentos (captures) e posições (offset) em que a
            expressão regular bateu.



             Operador ou igual
            O operador ||= atribui um valor apenas a variável esteja vazia. é muito utilizado para carregar
            valores de maneira “lazy”.

            nome ||= "anonimo"
            Nesse caso, se nome é nulo, ele será preenchido com "anonimo
            .



 3.6 - Exercícios - Estruturas de controle e Regexp

1) Nosso restaurante pode ter notas boas se a mesma for superior a 7, ou ruim caso contrário.

   # estruturas de controle: if
   nota = 10

   if nota > 7
       puts "Boa nota!"
   else
       puts "Nota ruim!"
   end
   Teste com notas diferentes e verifique as saídas no terminal.

2) Implemente um for em ruby:

   # estruturas de controle: for
   for i in (1..3)
     x = i
   end
   puts x

3) Teste o operado de expressões regulares “”

   puts /rio/ =~ "são paulo" # nil
   puts /paulo/ =~ "são paulo" # 3
   Abra o site http://rubular.com/ e teste outras expressões regulares!

4) O operador “||=” é considerado uma forma elegande de fazer um if. Verifique se uma variável já foi preen-
   chinda, caso não estiver, vamos atribuir um valor a ela.

                            Capítulo 3 - Classes, objetos e métodos - Exercícios - Estruturas de controle e Regexp - Página 14
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   restaurante ||= "Fogo de Chao"
   puts restaurante


 3.7 - Desafios

1) Sem tentar executar o código abaixo, responda: Ele funciona? Por que?

   resultado = 10 + 4
   texto = "O valor é " + resultado
   puts(texto)

2) E o código abaixo, deveria funcionar? Por que?

   puts(1+2)

3) Baseado na sua resposta da primeira questão, por que o código abaixo funciona?

   resultado = 10 + 3
   texto = "O valor é: #{resultado}"

4) Qual a saída deste código?

   resultado = 10 ** 2
   puts(’o resultado é: #{resultado}’)

5) (Para Casa) Pesquise sobre outras maneiras de criar Strings literais em Ruby.

6) Por que a comparação entre símbolos é muito mais rápida que entre Strings?

   simbolo1 = :abc
   simbolo2 = :abc
   simbolo1 == simbolo2
   # => true

   texto1 = "abc"
   texto2 = "abc"
   texto1 == texto2
   # => true




                                                         Capítulo 3 - Classes, objetos e métodos - Desafios - Página 15
C APÍTULO    4

Mais Ruby: classes, objetos e métodos
                                                                   “Uma imagem vale mais que mil palavras”
                                                                                     – Napoleão Bonaparte


 4.1 - Mundo orientado a objetos
   Ruby é uma linguagem puramente orientada a objetos, bastante influenciada pelo Smalltalk. Desta forma,
tudo em Ruby é um objeto, até mesmo os tipos básicos que vimos até agora.

   Uma maneira simples de visualizar isso é através da chamada de um método em qualquer um dos objetos:

"strings são objetos".upcase()
:um_simbolo.object_id()

   Até os números inteiros são objetos, da classe Fixnum:

10.class()


 4.2 - Métodos comuns
    Uma das funcionalidades comuns a diversas linguagens orientadas a objeto está na capacidade de, dado um
objeto, descobrir de que tipo ele é. No ruby, existe um método chamado class(), que retorna o tipo do objeto,
enquanto object_id(), retorna o número da referência, ou identificador único do objeto dentro da memória
heap.

   Outro método comum a essas linguagens, é aquele que “transforma” um objeto em uma String, geralmente
usado para log. O Ruby também disponibiliza esse método, através da chamada ao to_s().

   Adicionalmente aos tipos básicos, podemos criar nossos próprios objetos, que já vem com esses métodos
que todo objeto possui (class, object_id).

    Para criar um objeto em Ruby, basta invocar o método new na classe que desejamos instanciar. O exemplo
a seguir mostra como instanciar um objeto:

# criando um objeto
objeto = Object.new()


 4.3 - Definição de métodos
   def é uma palavra chave do Ruby para a definição (criação) de métodos, que podem, claro, receber parâ-
metros:




                                                     16
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




def pessoa.vai(lugar)
  puts "indo para " + lugar
end

    Mas, e o retorno de um método? Como funciona? Para diminuir o excesso de código que as linguagens
costumam introduzir (chamado de ruído sintático), o Ruby optou por retornar o resultado da execução da última
instrução executada no método. O exemplo a seguir mostra um método que devolve uma String:

def pessoa.vai(lugar)
  "indo para " + lugar
end

   Para visualizar esse retorno funcionando, podemos acessar o método e imprimir o retorno do mesmo:

puts pessoa.vai("casa")

   Podemos ainda refatorar o nosso método para usar interpolação:

def pessoa.vai(lugar)
  "indo para #{lugar}"
end

   Para receber vários argumentos em um método, basta separá-los por vírgula:

def pessoa.troca(roupa, lugar)
    "trocando de #{roupa} no #{lugar}"
end

   A invocação desses métodos é feita da maneira tradicional:

pessoa.troca(’camiseta’, ’banheiro’)

   Alguns podem até ter um valor padrão, fazendo com que sejam opcionais:

def pessoa.troca(roupa, lugar=’banheiro’)
  "trocando de #{roupa} no #{lugar}"
end

# invocacao sem o parametro:
pessoa.troca("camiseta")

# invocacao com o parametro:
pessoa.troca("camiseta", "sala")


 4.4 - Exercícios - Métodos

1) Métodos são uma das formas com que os objetos se comunicam. Vamos utilizar os conceitos vistos no
   capítulo anterior porém indo um pouco mais além na orientação a objetos agora.

     • Crie mais um arquivo no seu diretório ruby chamado restaurante_avancado.

   Ao final de cada exercício voce pode rodar o arquivo no terminal com o comando ruby restau-
   rante_avancado.rb.



                                      Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exercícios - Métodos - Página 17
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




2) Vamos simular um método que atribui uma nota a um restaurante.

   # declaração do método
   def qualifica(nota)
       puts "A nota do restaurante foi #{nota}"
   end

   # chamada do método
   qualifica(10)

3) Podemos ter parametros opcionais em ruby utilizando um valor padrão.

   def qualifica(nota, msg="Obrigado")
       puts "A nota do restaurante foi #{nota}. #{msg}"
   end

   # chamadas com parametros opcionais
   qualifica(10)
   qualifica(1, "Comida ruim.")


 4.5 - Discussão: Enviando mensagens aos objetos

1) Na orientação a objetos a chamada de um método é análoga ao envio de uma mensagem ao objeto. Cada
   objeto pode reagir de uma forma diferente à mesma mensagem, ao mesmo estímulo. Isso é o polimorfismo.
   Seguindo a idéia de envio de mensagens, uma maneira alternativa de chamar um método é usar o método
   send(), que todo objeto em Ruby possui.

   pessoa.send(:fala)
   O método send recebe como argumento o nome do método a ser invocado, que pode ser um símbolo ou
   uma string. De acordo com a orientação a objetos é como se estivéssemos enviando a mensagem “fala”
   ao objeto pessoa.
   Além da motivação teórica, você consegue enxergar um outro grande benefício dessa forma de invocar
   métodos, através do send()? Qual?


 4.6 - Classes
   Para não precisar adicionar sempre todos os métodos em todo objeto que criamos, Ruby possui classes,
que atuam como fábricas (molde) de objetos. Classes possibilitam a criação de objetos já incluindo alguns
métodos.

class Pessoa
  def fala
    puts "Sei Falar"
  end

  def troca(roupa, lugar="banheiro")
    "trocando de #{roupa} no #{lugar}"
  end
end

                  Capítulo 4 - Mais Ruby: classes, objetos e métodos - Discussão: Enviando mensagens aos objetos - Página 18
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




p = Pessoa.new
# o objeto apontado por p já nasce com os métodos fala e troca.

   Todo objeto em Ruby possui o método class, que retorna a classe que originou este objeto (note que os
parênteses podem ser omitidos na chamada e declaração de métodos):

p.class
# => Pessoa

  O diferencial de classes em Ruby é que são abertas. Ou seja, qualquer classe pode ser alterada a qualquer
momento na aplicação. Basta “reabrir” a classe e fazer as mudanças:

class Pessoa
  def novo_metodo
    # ...
  end
end

   Caso a classe Pessoa já exista estamos apenas reabrindo sua definição para adicionar mais código. Não
será criada uma nova classe e nem haverá um erro dizendo que a classe já existe.


 4.7 - Exercícios - Classes

1) Nosso método qualifica não pertence a nenhuma classe atualmente. Crie a classe Restaurante e instancie
   o objeto.

   class Restaurante
       def qualifica(nota, msg="Obrigado")
           puts "A nota do restaurante foi #{nota}. #{msg}"
       end
   end

2) Crie dois objetos, com chamadas diferentes.

   restaurante_um = Restaurante.new
   restaurante_dois = Restaurante.new

   restaurante_um.qualifica(10)
   restaurante_dois.qualifica(1, "Ruim!")


 4.8 - Desafio: Classes abertas

1) Qualquer classe em Ruby pode ser reaberta e qualquer método redefinido. Inclusive classes e métodos da
   biblioteca padrão, como Object e Fixnum.
   Podemos redefinir a soma de números reabrindo a classe Fixnum? Isto seria útil?

   class Fixnum
     def +(outro)
       self - outro # fazendo a soma subtrair

                                      Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exercícios - Classes - Página 19
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




     end
   end


 4.9 - self
   Um método pode invocar outro método do próprio objeto. Para isto, basta usar a referência especial self,
que aponta para o para o próprio objeto. É análogo ao this de outras linguagens como Java e C#.

   Todo método em Ruby é chamado em algum objeto, ou seja, um método é sempre uma mensagem enviada
a um objeto. Quando não especificado, o destino da mensagem é sempre self:

class Conta
  def transfere_para(destino, quantia)
    debita quantia
    # mesmo que self.debita(quantia)

    destino.deposita quantia
  end
end


 4.10 - Desafio: self e o método puts

1) Vimos que todo método é sempre chamado em um objeto. Quando não especificamos o objeto em que o
   método está sendo chamado, Ruby sempre assume que seja em self.
   Como tudo em Ruby é um objeto, todas as operações devem ser métodos. Em especial, puts não é uma
   operação, muito menos uma palavra reservada da linguagem.

   puts "ola!"
   Em qual objeto é chamado o método puts? Por que podemos chamar puts em qualquer lugar do programa?
   (dentro de classes, dentro de métodos, fora de tudo, ...)

2) Se podemos chamar puts em qualquer self, por que o código abaixo não funciona? (Teste!)

   obj = "uma string"
   obj.puts "todos os objetos possuem o método puts?"

3) (opcional) Pesquise onde (em que classe ou algo parecido) está definido o método puts. Uma boa dica é
   usar a documentação oficial da biblioteca padrão:
   http://ruby-doc.org


 4.11 - Atributos e propriedades: acessores e modificadores
    Atributos, também conhecidos como variáveis de instância, em Ruby são sempre privados e começam com
@. Não há como alterá-los de fora da classe; apenas os métodos de um objeto podem alterar os seus atributos
(encapsulamento!).

class Pessoa
  def muda_nome(novo_nome)
    @nome = novo_nome


                                                   Capítulo 4 - Mais Ruby: classes, objetos e métodos - self - Página 20
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




  end

  def diz_nome
    "meu nome é #{@nome}"
  end
end

p = Pessoa.new
p.muda_nome "João"
p.diz_nome

# => "João"

    Podemos fazer com que algum código seja executado na criação de um objeto. Para isso, todo objeto pode
ter um método especial, chamado de initialize:

class Pessoa
  def initialize
    puts "Criando nova Pessoa"
  end
end
Pessoa.new
# => "Criando nova Pessoa"

   Os initializers são métodos privados (não podem ser chamados de fora da classe) e podem receber parâ-
metros. Veremos mais sobre métodos privados adiante.

class Pessoa
  def initialize(nome)
    @nome = nome
  end
end

joao = Pessoa.new("João")

   Métodos acessores e modificadores são muito comuns e dão a idéia de propriedades. Existe uma convenção
para a definição destes métodos, que a maioria dos desenvolvedores Ruby segue (assim como Java tem a
convenção para getters e setters):

class Pessoa
  def nome # acessor
    @nome
  end

  def nome=(novo_nome)
    @nome = novo_nome
  end
end

pessoa = Pessoa.new
pessoa.nome=("José")
puts pessoa.nome


              Capítulo 4 - Mais Ruby: classes, objetos e métodos - Atributos e propriedades: acessores e modificadores - Página 21
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




# => "José"


 4.12 - Syntax Sugar: facilitando a sintaxe
    Desde o início, Matz teve como objetivo claro fazer com que Ruby fosse uma linguagem extremamente
legível. Portanto, sempre que houver oportunidade de deixar determinado código mais legível, Ruby o fará.

   Um exemplo importante é o modificador que acabamos de ver (nome=). Os parenteses na chamada de
métodos são quase sempre opcionais, desde que não haja ambiguidades:

pessoa.nome= "José"

   Para ficar bastante parecido com uma simples atribuição, bastaria colocar um espaço antes do ’=’. Priori-
zando a legibilidade, Ruby abre mão da rigidez sintática em alguns casos, como este:

pessoa.nome = "José"

    Apesar de parecer, a linha acima não é uma simples atribuição, já que na verdade o método nome= está
sendo chamado. Este recurso é conhecido como Syntax Sugar, já que o Ruby aceita algumas exceções na
sintaxe para que o código fique mais legível.

    A mesma regra se aplica às operações aritméticas que havíamos visto. Os números em Ruby também são
objetos! Experimente:

10.class
# => Fixnum

   Os operadores em Ruby são métodos comuns. Tudo em ruby é um objeto e todas as operações funcionam
como envio de mensagens.

10.+(3)

   Ruby tem Syntax Sugar para estes métodos operadores matemáticos. Para este conjunto especial de
métodos, podemos omitir o ponto e trocar por um espaço. Como com qualquer outro método, os parenteses
são opcionais.


 4.13 - Exercícios - Atributos e propriedades

1) Crie um initialize no Restaurante.

   class Restaurante
       def initialize
           puts "criando um novo restaurante"
       end
       # não apague o método ’qualifica’
   end
   Rode o exemplo e verifique a chamada ao ínitialize.

2) Cada restaurante da nossa aplicação precisa de um nome diferente.                    Vamos criar o atributo e suas
   propriedades de acesso.

   class Restaurante
       def initialize(nome)

                           Capítulo 4 - Mais Ruby: classes, objetos e métodos - Syntax Sugar: facilitando a sintaxe - Página 22
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




            puts "criando um novo restaurante: #{nome}"
        end
        # não apague o método ’qualifica’
  end

  # crie dois nomes diferentes
  restaurante_um = Restaurante.new("Fazano")
  restaurante_dois = Restaurante.new("Fogo de Chao")

3) Embora nossos objetos tenham agora recebido um nome, esse nome não foi guardado em nenhuma variável.

  class Restaurante
      def initialize(nome)
          puts "criando um novo restaurante: #{nome}"
          @nome = nome
      end

        # altere o método qualifica
        def qualifica(nota, msg="Obrigado")
            puts "A nota do #{@nome} foi #{nota}. #{msg}"
        end
  end

4) Repare que a váriável nome é uma variável de instância de Restaurante. Em ruby, o “@” definiu esse
   comportamento. Agora vamos fazer algo parecido com o atributo nota e suas propriedades de acesso.

  class Restaurante
      def initialize(nome)
          puts "criando um novo restaurante: #{nome}"
          @nome = nome
      end

        # altere o método qualifica
        def qualifica(msg="Obrigado")
            puts "A nota do #{@nome} foi #{@nota}. #{msg}"
        end

        # propriedades
        def nota=(nota)
            @nota = nota
        end

        def nota
            @nota
        end

  end

  restaurante_um = Restaurante.new("Fazano")
  restaurante_dois = Restaurante.new("Fogo de Chao")



                           Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exercícios - Atributos e propriedades - Página 23
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   restaurante_um.nota = 10
   restaurante_dois.nota = 1

   restaurante_um.qualifica
   restaurante_dois.qualifica("Comida ruim.")

5) Seria muito trabalhoso definir todas as propriedades de acesso a nossa variáveis. Refatore a classe
   Restaurante para utilizar o attr_accessor :nota Seu arquivo final deve ficar assim:

   class Restaurante
   attr_accessor :nota

         def initialize(nome)
             puts "criando um novo restaurante: #{nome}"
             @nome = nome
         end

         def qualifica(msg="Obrigado")
             puts "A nota do #{@nome} foi #{@nota}. #{msg}"
         end

   end

   restaurante_um = Restaurante.new("Fazano")
   restaurante_dois = Restaurante.new("Fogo de Chao")

   restaurante_um.nota = 10
   restaurante_dois.nota = 1

   restaurante_um.qualifica
   restaurante_dois.qualifica("Comida ruim.")


 4.14 - Coleções
   Arrays em Ruby são instâncias da classe Array, não sendo simplesmente uma estrutura de dados, mas
possuindo diversos métodos auxiliares que nos ajudam no dia-a-dia.

   Um exemplo simples e encontrado em objetos de tipo Array em várias linguagens é o que permite a inclusão
de elementos e size que nos retorna a quantidade de elementos lá dentro.

lista    = Array.new
lista    << "RR-71"
lista    << "RR-75"
lista    << "FJ-91"

puts lista.size
# => 3

   A tarefa mais comum ao iteragir com array é a de resgatar os elementos e para isso usamos [] passando
um índice como parametro:

puts lista[1]

                                               Capítulo 4 - Mais Ruby: classes, objetos e métodos - Coleções - Página 24
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




# => "RR-75"
puts lista[0]
# => "RR-71"

  Muitas vezes já sabemos de antemão o que desejamos colocar dentro da nossa array e o Ruby fornece uma
maneira literal de declará-la:

lista = [1, 2, "string", :simbolo, /$regex^/]
puts lista[2]
# => string

    Um exemplo que demonstra uma aparição de arrays é a chamada ao método methods, que retorna uma array
com os nomes de todos os métodos que o objeto sabe responder naquele instante. Esse método é definido na
classe Object então todos os objetos o possuem:

cliente = "Petrobras"

puts cliente.methods


 4.15 - Exemplo: múltiplos parâmetros
     Em alguns instantes desejamos receber um número arbitrário de argumentos em um método, por exemplo
a lista de produtos que estamos comprando em um serviço:

def compra(produto1, produto2, produto3, produtoN)
end

   Para receber um número qualquer de parâmetros usamos a sintaxe * do Ruby:

def compra(*produtos)
    # produtos é uma array
    puts produtos.size
end

  Note que nesse caso, em Ruby receber uma array ou um número indeterminado de argumentos resulta no
mesmo código interno ao método pois a variável produtos funciona como uma array.

   A mudança ocorre na sintaxe de chamada a esse método. Na versão mostrada acima, invocamos o método
compra com diversos parâmetros:

compra("Notebook", "Pendrive", "Cafeteira")

    Já no caso de definir o método recebendo uma array, somos obrigados a definir uma array no momento de
invocá-lo:

def compra(produtos)
    # produtos é uma array
    puts produtos.size
end
compra( ["Notebook", "Pendrive", "Cafeteira"] )

   O operador * é chamado de splat.




                             Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exemplo: múltiplos parâmetros - Página 25
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 4.16 - Hashes
    Mas nem sempre desejamos trabalhar com arrays cuja maneira de encontrar o que está lá dentro é através
de um número. Por exemplo, ao ler um arquivo de configuração de um servidor desejamos saber qual a porta e
se ele deve ativar o suporte ssh:

porta = 80
ssh = false
nome = Caelum.com.br

    Nesse caso não desejamos acessar uma array através de inteiros (Fixnum), mas sim o valor correspondente
as chaves “porta”, “ssh” e “nome”.

   Ruby também tem uma estrutura indexada por qualquer objeto, onde as chaves podem ser de qualquer tipo,
o que permite atingir nosso objetivo. A classe Hash é quem dá suporte a essa funcionalidade, sendo análoga
aos objetos HashMap, HashTable, arrays indexados por String e dicionários de outras linguagens.

config = Hash.new
    config["porta"] = 80
    config["ssh"] = false
    config["nome"] = "Caelum.com.br"

    puts config.size
    # => 3

    puts config["ssh"]
    # => false

    Por serem únicos e imutáveis, símbolos são ótimos candidatos a serem chaves em Hashes, portanto pode-
ríamos trabalhar com:

config = Hash.new
    config[:porta] = 80

   Ao invocar um método com um número maior de parâmetros, o código fica pouco legível, já que Ruby não
possui tipagem explícita, apesar de esta não ser a única causa.

   Imagine que tenho uma conta bancária em minhas mãos e desejo invocar o método de transferência, que
requer a conta destino, a data na qual o valor será transferido e o valor. Então tento invocar:

aluno = Conta.new
escola = Conta.new

# Time.now gera um objeto Time que representa "agora"
aluno.transfere(escola, Time.now, 50.00)

     No momento de executar o método descobrimos que a ordem dos parâmetros era incorreta, o valor deveria
vir antes da data, de acordo com a definição do método:

class Conta

    def transfere(destino, valor, data)
        # executa a transferencia
    end


                                                Capítulo 4 - Mais Ruby: classes, objetos e métodos - Hashes - Página 26
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




end

    Mas só descobrimos esse erro ao ler a definição do método na classe original, e para contornar esse
problema, existe um movimento que se tornou comum com a popularização do Rails 2, passando parâmetro
através de hash:

aluno.transfere( {:destino => escola, :data => Time.now, :valor => 50.00} )

      Note que o uso do Hash implicou em uma legibilidade maior apesar de uma proliferação de palavras:

def transfere(argumentos)
    destino = argumentos[:destino]
    data = argumentos[:data]
    valor = argumentos[:valor]
    # executa a transferência
end

   Isso acontece pois a semântica de cada parâmetro fica explícita para quem lê o código, sem precisar olhar
a definição do método para lembrar o que eram cada um dos parâmetros.


               Combinando Hashes e não Hashes
              Variações nos símbolos permitem melhorar ainda mais a legibilidade, por exemplo:

              class Conta
                  def transfere(valor, argumentos)
                      destino = argumentos[:para]
                      data = argumentos[:em]
                      # executa a transferência
                  end
              end

                      aluno.transfere(50.00, {:para => escola, :em => Time.now})
              Para quem utiliza Ruby 1.9, ao criar um Hash onde a chave é um símbolo, podemos
              utilizar uma outra sintaxe que por vezes se torna mais legível:

              aluno.transfere(50.00, {para: escola, em: Time.now})


   Além dos parênteses serem sempre opcionais, quando um Hash é o último parâmetro de um método, as
chaves podem ser omitidas (Syntax Sugar ).

aluno.transfere :destino => escola, :valor => 50.0, :data => Time.now


 4.17 - Exercícios - Arrays e Hashes

1) No seu diretório ruby crie mais um arquivo chamado listas.rb. Teste um array adicionando dois elementos.

   nomes = []

   nomes[0] = "Fazano"
   nomes << "Fogo de Chao"



                                 Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exercícios - Arrays e Hashes - Página 27
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




  for nome in nomes
    puts nome
  end

2) Vamos juntar os conhecimentos de classes e métodos para criar uma franquia onde podemos adicionar uma
   lista de restaurantes. Para isso teremos que criar na inicialização um array de restaurantes.

  class Franquia

     def initialize
       @restaurantes = []
     end

     def adiciona(restaurante)
       @restaurantes << restaurante
     end

     def mostra
       for restaurante in @restaurantes
         puts restaurante.nome
       end
     end

  end

  class Restaurante
    attr_accessor :nome
  end

  restaurante_um = Restaurante.new
  restaurante_um.nome = "Fazano"

  restaurante_dois = Restaurante.new
  restaurante_dois.nome = "Fogo de Chao"

  franquia = Franquia.new
  franquia.adiciona restaurante_um
  franquia.adiciona restaurante_dois

  franquia.mostra

3) O método adiciona recebe apenas um restaurante. Podemos usar a syntax com * e refatorar o método para
   permitir multiplos restaurantes como parâmentro.

  # refatore o método adiciona
    def adiciona(*restaurantes)
    for restaurante in restaurantes
      @restaurantes << restaurante
    end
  end



                              Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exercícios - Arrays e Hashes - Página 28
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




       # adicione ambos de uma só vez
       franquia.adiciona restaurante_um, restaurante_dois

4) Hashes são muito úteis para passar valores indentificados nos parâmentros. Na classe restaurante adicione
   o método fechar_compra e faça a chamada.

   def fechar_conta(dados)
               puts "Conta fechado no valor de #{dados[:valor]} e com nota #{dados[:nota]}.
   Comentário: #{dados[:comentario]}"
           end

              restaurante_um.fechar_conta :valor => 50, :nota => 9, :comentario => ’Gostei!’


 4.18 - Blocos e Programação Funcional
      Imagine o exemplo a seguir que soma o saldo das contas de um banco:

class Banco

      def initialize(contas)
          @contas = contas
      end

      def status
          saldo = 0
          for conta in @contas
              saldo += conta
          end
          saldo
      end

end

banco = Banco.new([200, 300, 400])
banco.status

   Esse processo é executado em diversos pontos da nossa aplicação e todos eles precisam exatamente desse
comportamento.

    Em um dia ensolarado, um ponto de nossa aplicação passa a necessitar da impressão dos saldos parciais,
isso é que cada soma seja impressa. Como fazer isso sem alterar os outros tantos pontos de execução e sem
duplicação de código?

   O primeiro passo é perceber a necessidade que temos de inserir um código novo, desejamos incluir o
seguinte código:

for conta in @contas
    saldo += conta
    puts saldo # essa linha é nova
end

      Então na chamada específica desse método, passemos esse código como “parâmetro":


                             Capítulo 4 - Mais Ruby: classes, objetos e métodos - Blocos e Programação Funcional - Página 29
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




banco.status do |saldo|
    puts saldo
end

    Isso não é um parâmetro, e sim um bloco de código, o código que desejamos executar. Note que esse bloco
recebe um parâmetro chamado *saldo* e que esse parâmetro é o saldo parcial que desejamos imprimir. Para
facilitar a leitura podemos renomea-lo para *saldo_parcial*:

banco.status do |saldo_parcial|
    puts saldo_parcial
end

    Imagine que o bloco funciona exatamente como a definição de uma função em ruby: ele pode receber
parâmetros e ser invocado. Falta invocá-lo no código do banco, para dar a chance de execução a cada chamada
do laço:

class Banco
    # initialize...
    def status(&block)
        saldo = 0
        for conta in @contas
            saldo += conta
            block.call(saldo)
        end
        saldo
    end
end

   Note que block é um objeto que ao ter o método call invocado, chamará o bloco que foi passado, concluindo
nosso primeiro objetivo: dar a chance de quem se interessar no saldo parcial, fazer algo com ele.

   Qualquer outro tipo de execução, como outros cálculos, que eu desejar fazer para cada saldo, posso fazê-lo
passando blocos distintos.

    Ainda faltou manter compatibilidade com aquelas chamadas que não possuem bloco. Para isso, basta
verificarmos se foi passado algum bloco como parâmetro para nossa função, e somente nesse caso invocá-lo.

      Isto é, se o bloco foi dado (block_given?), então invoque o bloco:

for conta in @contas
    saldo += conta

      if block_given?
          block.call(saldo)
      end

end


                Outra sintaxe de bloco
              Existe uma outra sintaxe que podemos utilizar para passar blocos que envolve o uso de chaves:

              banco.status { |saldo_parcial| puts saldo_parcial }



                               Capítulo 4 - Mais Ruby: classes, objetos e métodos - Blocos e Programação Funcional - Página 30
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    Como vimos até aqui, o método que recebe um bloco pode decidir se deve ou não chamá-lo. Para chamar
o bloco associado, existe uma outra abordagem com a palavra yield:

if block_given?
    yield(saldo)
end

   Nessa abordagem, não se faz necessário receber o argumento &block portanto o código do Banco seria:

class Banco
    # initialize...
    def status
        saldo = 0
        for conta in @contas
            saldo += conta
            if block_given?
                yield(saldo)
            end
        end
        saldo
    end
end

    Entender quando usar blocos costuma parecer complicado no início, não se preocupe . Você pode enxergá-
los como uma oportunidade do método delegar parte da responsabilidade a quem o chama, permitindo custo-
mizações em cada uma de suas chamadas (estratégias diferentes, ou callbacks).

    A biblioteca padrão do Ruby faz alguns usos muito interessantes de blocos. Podemos analizar a forma de
iterar em coleções, que é bastante influenciada por técnicas de programação funcional.

   Dizer que estamos passando uma função (pedaço de código) como parâmetro a outra função é o mesmo
que passar blocos na chamada de métodos.

   Para iterar em uma Array possuímos o método each, que chama o bloco de código associado para cada um
dos seus items, passando o item como parâmetro ao bloco:

lista = ["rails", "rake", "ruby", "rvm"]
lista.each do |programa|
  puts programa
end

    A construção acima não parece trazer muitos ganhos se comparada a forma tradicional e imperativa de
iterar em um array (for).

    Imagine agora uma situação onde queremos colocar o nome de todos os funcionários em maiúsculo, isto é,
aplicar uma função para todos os elementos de uma array, construindo uma array nova.

funcionarios = ["Guilherme", "Sergio", "David"]
nomes_maiusculos = []

for nome in funcionarios
    nomes_maiusculos << nome.upcase
end

   Poderíamos usar o método each:

                           Capítulo 4 - Mais Ruby: classes, objetos e métodos - Blocos e Programação Funcional - Página 31
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




funcionarios = ["Guilherme", "Sergio", "David"]
nomes_maiusculos = []

funcionarios.each do |nome|
    nomes_maiusculos << nome.upcase
end

   Mas as duas abordagens envolvem o conceito de dizer a linguagem que queremos adicionar um elemento
a uma lista existente: o trabalho é imperativo.

   Lembrando que o bloco, assim como uma função qualquer, possui retorno, seria muito mais compacto se
pudéssemos exprimir o desejo de criar a array diretamente:

funcionarios = ["Guilherme", "Sergio", "David"]

nomes_maiusculos = funcionarios.cria_uma_array

   O código dessa função deve iterar por cada elemento, adicionando eles dentro da nossa array, *exatamente*
como havíamos feito antes:

class Array
    def cria_uma_array
        array = []
        self.each do |elemento|
            array << elemento.upcase
        end
        array
    end
end

    Mas podemos reclamar que o método upcase nem sempre vai funcionar: a cada chamada de
cria_uma_array queremos executar um comportamento diferente. E essa é a dica para utilização de blocos:
passe um bloco que customiza o comportamento do método cria_uma_array:

nomes_maiusculos = funcionarios.cria_uma_array do |nome|
    nome.upcase
end

   E faça o cria_uma_array invocar esse bloco:

class Array
    def cria_uma_array
        array = []
        self.each do |elemento|
            array << yield(elemento)
        end
    end
end

   Esse método que criamos já existe e se chama map (ou collect), que coleta os retornos de tomas as
chamadas do bloco associado:

funcionarios = ["Guilherme", "Sergio", "David"]



                            Capítulo 4 - Mais Ruby: classes, objetos e métodos - Blocos e Programação Funcional - Página 32
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




nomes_maiusculos = funcionarios.map do |nome|
    nome.upcase
end

   Na programação imperativa tradicional precisamos de no mínimo mais duas linhas, para o array auxiliar e
para adicionar os items maiúsculos no novo array.

   Diversos outros métodos do módulo Enumerable seguem a mesma idéia: find, find_all, grep, sort, inject.
Não deixe de consultar a documentação, que pode ajudar a criar código mais compacto.

   Só tome cuidado pois código mais compacto nem sempre é mais legível e fácil de manter.


 4.19 - Exercícios - Blocos

1) Refatore o método mostra do Restaurante para iterar sobre os elementos usando blocos.

   def mostra
     @restaurantes.each do |r|
       puts r.nome
     end
   end

2) Crie um método relatorio que envia a lista de restaurantes da franquia. Repare que esse método não são
   o que ocorrerá com cada item da lista. Ele disponibiliza os itens e é o bloco passado que define o que fazer
   com eles.

   def relatorio
     @restaurantes.each do |r|
       yield r
     end
   end

     # chamada com blocos
     franquia.relatorio do |r|
       puts "Restaurante cadastrado: #{r.nome}"
     end


 4.20 - Para saber mais: Mais sobre blocos
   Analise e rode o código abaixo, olhe na documentação o método sort_by e teste o next.

caelum = [
   {:ruby => ’rr-71’, :java => ’fj-11’},
   {:ruby => ’rr-75’, :java => ’fj-21’}
 ]

caelum.sort_by { |curso| curso[:ruby] }.each do |curso|
   puts "Curso de RoR na Caelum: #{ curso[:ruby] }"
 end

caelum.sort_by { |curso| curso[:ruby] }.each do |curso|

                                        Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exercícios - Blocos - Página 33
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   next if curso[:ruby] == ’rr-71’
   puts "Curso de RoR na Caelum: #{ curso[:ruby] }"
end


 4.21 - Desafio: Usando blocos

1) Queremos imprimir o nome de todos os alunos de uma turma com o código a seguir:

   fj91 = Turma.new("Guilherme", "Paulo", "Paniz")

   fj91.each do |nome|
       puts nome
   end
   Crie a sua classe Turma que durante a invocação do método each, itera por todos os nomes passados em
   seu construtor.
   Tente lembrar dos conceitos de blocos e programação funcional para resolver.


   A biblioteca padrão do Ruby faz usos bastante interessante de módulos como mixins. Os principais exemplos
são os módulos Enumerable e Comparable.


 4.22 - Manipulando erros e exceptions
   Uma exception é um tipo especial de objeto que extende ou é uma instância da classe Exception. Lançar
uma exception significa que algo não esperado ou errado ocorreu no fluxo do programa. Raising é a palavra
usada em ruby para lançamento de exceptions. Para tratar uma exception é necessário criar um código a ser
executado caso o programa receba o erro. Para isso existe a palavra rescue.


Exceptions comuns

   A lista abaixo mostra as exceptions mais comuns em ruby e quando são lançadas, todas são filhas de
Exception. Nos testes seguintes você pode usar essas exceptions.


   • RuntimeError : É a exception padrão lançada pelo método raise.

   • NoMethodError : Quando um objeto recebe como paramêtro de uma mensagem um nome de método
     que não pode ser encontrado.

   • NameError : O interpretador não encontra uma variável ou método com o nome passado.

   • IOError : Causada ao ler um stream que foi fechado, tentar escrever em algo read-only e situações
     similares.

   • Errno::error : É a família dos erros de entrada e saída (IO).

   • TypeError : Um método recebe como argumento algo que não pode tratar.

   • ArgumentError : Causada por número incorreto de argumentos.



                                    Capítulo 4 - Mais Ruby: classes, objetos e métodos - Desafio: Usando blocos - Página 34
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 4.23 - Exercício: Manipulando exceptions

1) Em um arquivo ruby crie o código abaixo para testar exceptions. O método gets recupera o valor digitado.
   Teste também outros tipos de exceptions e digite um número inválido para testar a exception.

   print "Digite um número:"
   numero = gets.to_i

   begin
       resultado = 100 / numero
   rescue
       puts "Número digitado inválido!"
       exit
   end

   puts "100/#{numero} é #{resultado} "

2) (opcional) Exceptions podem ser lançadas com o comando raise. Crie um método que lança uma exception
   do tipo ArgumentError e capture-a com rescue.

   def verifica_idade(idade)
     unless idade > 18
         raise ArgumentError,
         "Você precisa ser maior de idade para jogar jogos violentos."
       end
   end

   verifica_idade(17)

3) (opcional) É possível utilizar sua própria exception criando uma classe e extendendo de Exception.

   class IdadeInsuficienteException < Exception
   end

   def verifica_idade(idade)
       raise IdadeInsuficienteException,
        "Você precisa ser maior de idade para jogar jogos violentos." unless idade > 18
   end
   Para testar o rescue dessa exception invoque o método com um valor inválido:

   begin
           verifica_idade(13)
   rescue IdadeInsuficienteException => e
       puts "Foi lançada a exception: #{e}"
   end




                           Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exercício: Manipulando exceptions - Página 35
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




               Throw e catch
              Ruby possui também throw e catch que podem ser utilizados com símbolos e a sintaxe lembra a
              de Erlang, onde catch é uma função que, se ocorrer algum throw com aquele label, retorna o valor
              do throw atrelado:

              def pesquisa_banco(nome)
                  if nome.size<10
                      throw :nome_invalido, "Nome invalido, digite novamente"
                  end
                  # executa a pesquisa
                  "cliente #{nome}"
              end

              def executa_pesquisa(nome)
                  catch :nome_invalido do
                      cliente = pesquisa_banco(nome)
                      return cliente
                  end
              end

              puts executa_pesquisa("ana")
              # => "Nome invalido, digite novamente"

              puts executa_pesquisa("guilherme silveira")
              # => cliente guilherme silveira



 4.24 - Arquivos com código fonte ruby
   Todos os arquivos fonte, contendo código Ruby devem ter a extensão .rb para que o interpretador seja capaz
de carregá-lo.

    Existem exceções onde a leitura dos arquivos é feita por outras bibliotecas e, nesses casos, o arquivo possui
outras extensões.

   Para organizar seu código, é natural dividi-lo em vários arquivos e diretórios, bastando usar o método
require para incluir o fonte de outro arquivo.

      Imagine o arquivo conta.rb:

class Conta

      attr_reader :saldo

      def initialize(saldo)
          @saldo = saldo
      end
end

      Agora podemos acessar uma conta bastando primeiro importar o arquivo que a define:

require ’conta’

puts Conta.new(500).saldo



                                Capítulo 4 - Mais Ruby: classes, objetos e métodos - Arquivos com código fonte ruby - Página 36
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    Caso a extensão .rb seja omitida, a extensão adequada será usada (.rb, .so, .class, .dll, etc). O Ruby procura
pelo arquivo em alguns diretórios predefinidos (Ruby Load Path), incluindo o diretório atual.

  Assim como qualquer outra linguagem isso resulta em um possível Load Hell, onde não sabemos exata-
mente de onde nossos arquivos estão sendo carregados. Tome bastante cuidado para a configuração de seu
ambiente.

   Caminhos relativos ou absolutos podem ser usados para incluir arquivos em outros diretórios, sendo que o
absoluto não é recomendado devido ao atrelamento claro com uma estrutura fixa que pode não ser encontrada
ao portar o código para outra máquina:

require ’modulo/funcionalidades/coisa_importante’
require ’/usr/local/lib/my/libs/ultra_parser’


             Constantes do sistema
            A constante $:, ou $LOAD_PATH contém diretórios do Load Path:

            $:
            # => ["/Library/Ruby/Site/1.8", ..., "."]
            Existem diversas outras constantes que começam com $, todas elas que são resquícios de
            PERL e que, em sua grande maioria dentro do ambiente Rails, possuem alternativas mais
            compreensíveis como LOAD_PATH.


   O comando require carrega o arquivo apenas uma vez. Para executar a interpretação do conteúdo do
arquivo diversas vezes, utilize o método load.

load ’conta.rb’
load ’conta.rb’
# executado duas vezes!

    Portanto no irb (e em Ruby em geral) para recarregar um arquivo que foi alterado é necessário executar um
load e não um require - que não faria nada.


 4.25 - Para saber mais: um pouco de IO
    Para manipular arquivos de texto existe a classe File, que permite manipula-los de maneira bastante sim-
ples, utilizando blocos:

print "Escreva um texto: "
texto = gets
File.open( "caelum.txt", "w" ) do |f|
  f << texto
end

   E para imprimir seu conteúdo:

Dir[’caelum.txt’].each do |file_name|
   idea = File.read( file_name )
   puts idea
end

    Podemos lidar de maneira similar com requisições HTTP utilizando o código abaixo e imprimir o conteúdo
do resultado de uma requisição:

                             Capítulo 4 - Mais Ruby: classes, objetos e métodos - Para saber mais: um pouco de IO - Página 37
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




require ’net/http’
Net::HTTP.start( ’www.caelum.com.br’, 80 ) do |http|
    print( http.get( ’/’ ).body )
end




                         Capítulo 4 - Mais Ruby: classes, objetos e métodos - Para saber mais: um pouco de IO - Página 38
C APÍTULO    5

Metaprogramação e Padrões de Projeto
                                                 “A ciência nunca resolve um problema sem criar mais dez”
                                                                                    – George Bernard Shaw


 5.1 - Métodos de Classe
   Classes em Ruby também são objetos:

Pessoa.class
# => Class

c = Class.new
instancia = c.new

    Variáveis com letra maiúscula representam constantes em Ruby, que até podem ser modificadas, mas o
interpretador gera um warning. Portanto, Pessoa é apenas uma constante que aponta para um objeto do tipo
Class.

   Se classes são objetos, podemos definir métodos de classe como em qualquer outro objeto:

class Pessoa
  # ...
end

def Pessoa.pessoas_no_mundo
  100
end

Pessoa.pessoas_no_mundo
# => 100

   Há um idiomismo para definir os métodos de classe dentro da própria definição da classe, onde self aponta
para o próprio objeto classe.

class Pessoa
  def self.pessoas_no_mundo
    100
  end

  # ...
end




                                                   39
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 5.2 - Para saber mais: Singleton Classes
   A definição class << object define as chamadas singleton classes em ruby. Por exemplo, uma classe normal
em ruby poderia ser:

class Pessoa
  def fala
        puts ’oi’
    end
end

   Podemos instanciar e invocar o método normalmente:

p = Pessoa.new
p.fala   # imprime ’oi’

    Entretanto, também é possível definir métodos apenas para esse objeto “p”, pois tudo em ruby, até mesmo
as classes, são objetos, fazendo :

class Pessoa
    def p.anda
        puts ’andando’
    end
end

   O método “anda” é chamado de singleton method do objeto “p”.

   Um singleton method “vive” em uma singleton class. Todo objeto em ruby possui 2 classes:

   • a classe a qual foi instanciado

   • sua singleton class

   A singleton class é exclusiva para guardar os métodos desse objeto, sem compartilhar com outras instâncias
da mesma classe.

   Existe uma notação especial para definir uma singleton class:

class << Pessoa
    def anda
        puts ’andando’
    end
end

   Definindo o código dessa forma temos o mesmo que no exemplo anterior, porém definindo o método anda
explicitamente na singleton class.É possível ainda definir tudo na mesma classe:

class Pessoa
    class << self
        def anda
            puts ’andando’
        end
    end
end

                           Capítulo 5 - Metaprogramação e Padrões de Projeto - Para saber mais: Singleton Classes - Página 40
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   Mais uma vez o método foi definido apenas para um obejto, no caso , o objeto “Pessoa”, podendo ser
executado com:

Pessoa.anda


 5.3 - Exercícios - Ruby Object Model

1) Crie um novo arquivo chamado metaprogramacao.rb. Independente da instância seria interessante saber
   o número total de restaurantes criados. Na mesma classe restaurante, crie uma variável de classe chamada
   total.

   class Restaurante
       def initialize(nome)
           puts "criando um novo restaurante: #{nome}"
           @@total ||= 0
           @@total = @@total + 1
           puts "Restaurantes criados: #{@@total}"
           @nome = nome
       end
   end
   Execute novamente e analise o resultado.

2) Crie um método self chamado relatorio que mostra a quantidade total de restaurantes instanciados.
   (Opcional: Com esse método, você pode limpar um pouco o initialize).

   def self.relatorio
     puts "Foram criados #{@@total} restaurantes"
   end

       # Faça mais uma chamada
       Restaurante.relatorio

              Método de Classe é diferente de static do Java
           Se você trabalha com java pode confundir o self com o static. Cuidado! O método definido como
           self roda apenas na classe, não funciona nas instâncias. Voce pode testar fazendo:

           Restaurante.relatorio
           restaurante_um.relatorio
           A invocação na instância dará um: NoMethodError: undefined method ‘relatorio’ for #<Restau-
           rante:0x100137b48 @nome="Fazano”, @nota=10>


3) Caso sua classe possua muitos métodos de classe, é recomendado agrupá-los. Muitos códigos ruby
   utilizaram essa técnica, inclusive no próprio Rails Sua classe ficará então assim:

   class Restaurante
      # initialize, qualifica ...

   class << self
     def relatorio


                              Capítulo 5 - Metaprogramação e Padrões de Projeto - Exercícios - Ruby Object Model - Página 41
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




       puts "Foram criados #{@@total} restaurantes"
     end
   end

   end
   Execute e veja que o comportamento é o mesmo.


 5.4 - Design Patterns: Singleton
    Como criar uma classe com a garantia de ser instanciada apenas uma vez ? Essa classe deveria ser capaz
de verificar se alguma vez já foi instânciada e saber devolver sempre a mesma referência.

    Como visto anteriormente, em ruby, variáveis com @ são de instância e variáveis com @@ são variáveis de
classe.

    Utilizando a idéia acima podemos criar uma classe simples de relatório, onde desejamos que apenas uma
seja de fato criada.

class Relatorio
    @@instance = Relatorio.new

      def self.instance
          return @@instance
      end
end

    Dessa forma conseguimos criar o relatório apenas uma vez. Mas a implementação ainda apresenta pro-
blemas. Ainda é possível instanciar o Relatório mais de uma vez. Para resolver esse problema e implentar a
classe Relatório como um Singleton realmente, precisamos tornar privado o new da nossa classe. Dessa forma,
apenas será possível acessar o Relatorio a partir do método instance.

class Relatorio
    @@instance = Relatorio.new

      def self.instance
          return @@instance
      end

      private_class_method :new
end

# ambos relatorios referenciam o mesmo objeto
relatorio1 = Relatorio.instance
relatorio2 = Relatorio.instance

   Existe ainda uma maneira mais otimizada e produtiva de chegar no mesmo resultado. O ruby já vem com
um módulo chamado Singleton. Basta inclui-lo na classe para ter o mesmo resultado. Você verá mais sobre
módulos no decorrer do curso.

require ’singleton’
class Relatorio



                                  Capítulo 5 - Metaprogramação e Padrões de Projeto - Design Patterns: Singleton - Página 42
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




      include Singleton
end


 5.5 - Exercicio: Design Pattern - Singleton

1) Crie o Relatório de forma a retornar sempre a mesma instância:

   class Relatorio
       @@instance = Relatorio.new

         def self.instance
             return @@instance
         end

         private_class_method :new
   end

   # ambos relatorios referenciam o mesmo objeto
   relatorio1 = Relatorio.instance
   relatorio2 = Relatorio.instance

   puts relatorio1 == relatorio2

2) Faça o mesmo teste, mas conhecendo agora o módulo Singleton do ruby:

   require ’singleton’
   class Relatorio
       include Singleton
   end

   # ambos relatorios referenciam o mesmo objeto
   relatorio1 = Relatorio.instance
   relatorio2 = Relatorio.instance

   puts relatorio1 == relatorio2


 5.6 - Convenções
      Métodos que retornam booleanos costumam terminar com ?, para que pareçam perguntas aos objetos:

texto = "nao sou vazio"
texto.empty? # => false

      Já vimos esta convenção no método respond_to?.

    Métodos que tem efeito colateral (alteram o estado do objeto, ou que costumem lançar exceções) geralmente
terminam com ! (bang):

conta.cancela!




                          Capítulo 5 - Metaprogramação e Padrões de Projeto - Exercicio: Design Pattern - Singleton - Página 43
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    A comparação entre objetos é feita através do método == (sim, é um método!). A versão original do método
apenas verifica se as referências são iguais, ou seja, se apontam para os mesmos objetos. Podemos reescrever
este comportamento e dizer como comparar dois objetos:

class Pessoa
  def ==(outra)
    self.cpf == outra.cpf
  end
end

   Na definição de métodos, procure sempre usar os parênteses. Para a chamada de métodos, não há con-
venção. Prefira o que for mais legível.

   Nomes de variável e métodos em Ruby são sempre minúsculos e separados por ’_’ (underscore). Variáveis
com nomes maiúsculo são sempre constantes. Para nomes de classes, utilize as regras de CamelCase, afinal
nomes de classes são apenas constantes.


 5.7 - Polimorfirmo
   Ruby também tem suporte a herança simples de classes:

class Animal
  def come
    "comendo"
  end
end

class Pato < Animal
  def quack
    "Quack!"
  end
end

pato = Pato.new
pato.come # => "comendo"

   Classes filhas herdam todos os métodos definidos na classe mãe.

    A tipagem em Ruby não é explícita, por isso não precisamos declarar quais são os tipos dos atributos. Veja
este exemplo:

class PatoNormal
  def faz_quack
    "Quack!"
  end
end

class PatoEstranho
  def faz_quack
    "Queck!"
  end
end


                                             Capítulo 5 - Metaprogramação e Padrões de Projeto - Polimorfirmo - Página 44
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




class CriadorDePatos
  def castiga(pato)
    pato.faz_quack
  end
end

pato1 = PatoNormal.new
pato2 = PatoEstranho.new
c = CriadorDePatos.new
c.castiga(pato1) # => "Quack!"
c.castiga(pato2) # => "Queck!"

    Para o criador de patos, não interessa que objeto será passado como parâmetro. Para ele basta que o
objeto saiba fazer quack. Esta característica da linguagem Ruby é conhecida como Duck Typing.

   “If it walks like a duck and quacks like a duck, I would call it a duck.”


 5.8 - Exercícios - Duck Typing

1) Para fazer alguns testes de herança e polimorfismo abra o diretório ruby e crie um novo arquivo chamado
   duck_typing.rb. Nesse arquivo faça o teste do restaurante herdando um método da classe Franquia.

   class Franquia
       def info
           puts "Restaurante faz parte da franquia"
       end
   end

   class Restaurante < Franquia
   end

   restaurante = Restaurante.new
   restaurante.info
   Execute o arquivo no terminal e verifique a utilização do método herdado.

2) Podemos em ruby fazer a sobreescrita do método e invocar o método da classe mãe.

   class Franquia
       def info
           puts "Restaurante faz parte da franquia"
       end
   end

   class Restaurante < Franquia
       def info
           super
           puts "Restaurante Fazano"
       end
   end

                                     Capítulo 5 - Metaprogramação e Padrões de Projeto - Exercícios - Duck Typing - Página 45
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   restaurante = Restaurante.new
   restaurante.info

3) Como a linguagem ruby é implicitamente tipada, não temos a cgarantia de receber um objeto do tipo que
   esperamos. Isso faz com que acreditamos que o objeto é de um tipo específico caso ele possua um método
   esperado. Faça o teste abaixo:

   class Franquia
       def info
           puts "Restaurante faz parte da franquia"
       end
   end

   class Restaurante < Franquia
       def info
           super
           puts "Restaurante Fazano"
       end
   end

   # metodo importante
   # recebe franquia e invoca o método info
   def informa(franquia)
     franquia.info
   end

   restaurante = Restaurante.new
   informa restaurante


 5.9 - Design Patterns: Template Method
     As operações de um sistema podem ser de diversos tipos e o que determida qual operação será realizada
pode ser um simples variável. Dependendo da variável uma coisa pode ocorrer enquanto outra vez é necessário
fazer outra. Para exemplificar melhor, vamos usar a classe Relatorio. Nosso relatório mostrará um conteúdo
inicialmente em HTML.

class Relatorio
    def imprime
        puts "<html>Dados do restaurante</html>"
    end
end

   O que acontece caso um paramêtro defina o formato dos dados que o relatório precisa ser criado?

class Relatorio
    def imprime(formato)
        if formato == :texto
            puts "*** Dados do restaurante ***"
        elsif formato == :html
            puts "<html>Dados do restaurante</html>"


                          Capítulo 5 - Metaprogramação e Padrões de Projeto - Design Patterns: Template Method - Página 46
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




            else
                puts "formato desconhecido!"
      end
end

    Para solucionar esse problema de forma orientada a objetos poderiamos criar uma classe abstrata que
define o comportamento de um relatório, ou seja, que define que um relatório de ter um head, um body, um
footer, etc. Mas como criar uma classe abstrata em Ruby ? Embora não exista a palavra chave reservada
“abstract” o conceito permanece presente na linguagem. Vejamos:

class Relatorio
    def imprime
        imprime_cabecalho
        imprime_conteudo
    end
end

    A classe Relatorio agora possui os métodos que definem um relatório. Obviamente esses métodos podem
ser invocados. A solução para isso normalmente é lançar uma exception nesses métodos não implementados.
Agora que temos nossa classe abstrata, podemos criar subclasses de Relatorio que contém a implementação
de cada um dos tipos, por exemplo para HTML:

class HTMLRelatorio < Relatorio
    def imprime_cabecalho
        puts "<html>"
    end

      def imprime_conteudo
          puts "Dados do relatorio"
      end
end

class TextoRelatorio < Relatorio
    def imprime_cabecalho
        puts "***"
    end

      def imprime_conteudo
          puts "Dados do relatorio"
      end
end

      Agora para usar nossos relatórios podemos fazer:

relatorio = HTMLRelatorio.new
relatorio.imprime

relatorio = TextoRelatorio.new
relatorio.imprime


 5.10 - Exercicio Opcional: Design Pattern - Template Method

              Capítulo 5 - Metaprogramação e Padrões de Projeto - Exercicio Opcional: Design Pattern - Template Method - Página 47
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




1) Crie a classe que define as obrigações de um relatório:

   class Relatorio
       def imprime
           imprime_cabecalho
           imprime_conteudo
       end
   end

2) Para termos implementações diferentes, crie um relatório HTML e um de texto puro:

   class HTMLRelatorio < Relatorio
       def imprime_cabecalho
           puts "<html>"
       end

         def imprime_conteudo
             puts "Dados do relatorio"
         end
   end

   class TextoRelatorio < Relatorio
       def imprime_cabecalho
           puts "***"
       end

         def imprime_conteudo
             puts "Dados do relatorio"
         end
   end

3) Utilize os relátorios com a chamada ao método imprime:

   relatorio = HTMLRelatorio.new
   relatorio.imprime

   relatorio = TextoRelatorio.new
   relatorio.imprime


 5.11 - Modulos
   Modulos podem ser usados como namespaces:

module Caelum
  module Validadores

    class ValidadorDeCpf
      # ...
    end

    class ValidadorDeRg


                                               Capítulo 5 - Metaprogramação e Padrões de Projeto - Modulos - Página 48
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




        # ...
      end

  end
end

validador = Caelum::Validadores::ValidadorDeCpf.new

      Ou como mixins, conjunto de métodos a ser incluso em outras classes:
module Comentavel
  def comentarios
    @comentarios ||= []
  end

  def recebe_comentario(comentario)
    self.comentarios << comentario
  end
end

class Revista
  include Comentavel
  # ...
end

revista = Revista.new
revista.recebe_comentario("muito ruim!")
puts revista.comentarios


 5.12 - Design Patterns: Observer
    Como executar operações caso algo ocorra no sistema. Temos uma classe Restaurante e queremos manter
avisados todos os objetos do sistema que se interessem em modificações nele. Nossa classe Franquia precisa
executar o método alerta no caso
class Franquia

  def alerta
    puts "Um restaurante foi qualificado"
  end

end

class Restaurante

  def qualifica(nota)
    puts "Restaurante recebeu nota #{nota}"
  end

end



                                  Capítulo 5 - Metaprogramação e Padrões de Projeto - Design Patterns: Observer - Página 49
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




restaurante = Restaurante.new
restaurante.qualifica(10)

   Poderiamos chamar o método alerta direto ao final do método qualifica ou poderiamos passar como para-
metro do método um observer para rodar. Porém essas maneiras acoplariam muito nosso código, por exemplo,
não funcionariam para alertar mais de um observer.

   Uma saída é criar uma lista de observadores e executá-los ao final da operação. Para isso podemos ter um
método que permite adicionar quantos objetos forem necessários serem alertados.

class Restaurante

  def initialize
    @observers = []
  end

  def adiciona_observer(observer)
    @observer << observer
  end

  def notifica
    # percorre todos os observers chamando o método alerta
  end

  # qualifica

end

restaurante = Restaurante.new
restaurante.qualifica(10)

    Poder ser observado não é uma característica única de um objeto. Podemos utilizar essa estratégia de
avisar componentes por todo o software. Por que não colocar o comportamento em uma classe responsável
por isso. Utilizando herança tornaríamos nosso código observável.

    Ao invés de utilizar a herança novamente podemos utilizar os módulos para isso. Todo comportamento que
faz do objeto ser um observer será colocado nesse módulo.

module Observer
    def initialize
       @observers = []
     end

      def adiciona_observer(observer)
        @observer << observer
      end

      def notifica
        # percorre todos os observers chamando o método alerta
      end
end



                                Capítulo 5 - Metaprogramação e Padrões de Projeto - Design Patterns: Observer - Página 50
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




class Restaurante
    include Observer
  def qualifica(nota)
    puts "Restaurante recebeu nota #{nota}"
        notifica
  end
end


             Modulo Observer
           O módulo acima já existe em ruby e é chamado de Observer. http://ruby-doc.org/core/classes/
           Observable.html


 5.13 - Desafio: Design Pattern - Observer

1) Crie um novo arquivo e implemente o Design Pattern Observer para Restaurante e Franquia.


 5.14 - Metaprogramação
   Por ser uma linguagem dinâmica, Ruby permite adicionar outros métodos e operações aos objetos em tempo
de execução.

   Imagine que tenho uma pessoa:

pessoa = Object.new()

   O que aconteceria, se eu tentasse invocar um método inexistente nesse objeto? Por exemplo, se eu tentar
executar

pessoa.fala()

   O interpretador retornaria com uma mensagem de erro uma vez que o método não existe.

   Mas e se eu desejasse, em tempo de execução, adicionar o comportamento (ou método) fala para essa
pessoa. Para isso, tenho que definir que uma pessoa possui o método fala:

pessoa = Object.new()

def pessoa.fala()
  puts "Sei falar"
end

   Agora que tenho uma pessoa com o método fala, posso invocá-lo:

pessoa = Object.new()

def pessoa.fala()
  puts "Sei falar"
end

pessoa.fala()


                         Capítulo 5 - Metaprogramação e Padrões de Projeto - Desafio: Design Pattern - Observer - Página 51
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    Tudo isso é chamado meta-programação, um recurso muito comum de linguagens dinâmicas. Meta-
programação é a capacidade de gerar/alterar código em tempo de execução. Note que isso é muito diferente de
um gerador de código comum, onde geraríamos um código fixo, que deveria ser editado na mão e a aplicação
só rodaria esse código posteriormente.

   Levando o dinamismo de Ruby ao extremo, podemos criar métodos que definem métodos em outros objetos:

class Aluno
  # nao sabe nada
end

class Professor
  def ensina(aluno)
    def aluno.escreve
      "sei escrever!"
    end
  end
end

juca = Aluno.new
juca.respond_to? :escreve
# => false

professor = Professor.new
professor.ensina juca
juca.escreve
# => "sei escrever!"

   A criação de métodos acessores é uma tarefa muito comum no desenvolvimento orientado a objetos. Os
métodos são sempre muito parecidos e os desenvolvedores costumam usar recursos de geração de códigos
das IDEs para automatizar esta tarefa.

     Já vimos que podemos criar código Ruby que escreve código Ruby (métodos). Aproveitando essa possi-
bilidade do Ruby, existem alguns métodos de classe importantes que servem apenas para criar alguns outros
métodos nos seus objetos.

class Pessoa
  attr_accessor :nome
end

p = Pessoa.new
p.nome = "Joaquim"
puts p.nome
# => "Joaquim"

   A chamada do método de classe attr_acessor, define os métodos nome e nome= na classe Pessoa.

    A técnica de código gerando código é conhecida como metaprogramação, ou metaprogramming, como
já definimos.

   Outro exemplo interessante de metaprogramação é como definimos a visibilidade dos métodos em Ruby. Por
padrão, todos os métodos definidos em uma classe são públicos, ou seja, podem ser chamados por qualquer
um.

                                       Capítulo 5 - Metaprogramação e Padrões de Projeto - Metaprogramação - Página 52
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    Não existe nenhuma palavra reservada (keyword) da linguagem para mudar a visibilidade. Isto é feito com
um método de classe. Toda classe possui os métodos private, public e protected, que são métodos que
alteram outros métodos, mudando a sua visibilidade (código alterando código == metaprogramação).

   Como visto, por padrão todos os métodos são públicos. O método de classe private altera a visibilidade de
todos os métodos definidos após ter sido chamado:

class Pessoa

  private

  def vai_ao_banheiro
    # ...
  end
end

    Todos os métodos após a chamada de private são privados. Isso pode lembrar um pouco C++, que define
regiões de visibilidade dentro de uma classe (seção pública, privada, ...). Um método privado em Ruby só
pode ser chamado em self e o self deve ser implícito. Em outras palavras, não podemos colocar o self
explicitamente para métodos privados, como em self.vai_ao_banheiro.

   Caso seja necessário, o método public faz com que os métodos em seguida voltem a ser públicos:

class Pessoa

  private
  def vai_ao_banheiro
    # ...
  end

  public
  def sou_um_metodo_publico
    # ...
  end
end

   O último modificador de visibilidade é o protected. Métodos protected só podem ser chamados em self
(implícito ou explícito). Por isso, o protected do Ruby acaba sendo semelhante ao protected do Java e C++,
que permitem a chamada do método na própria classe e em classes filhas.


 5.15 - Exercícios - Metaprogramação

1) Alguns restaurantes poderão receber um método a mais chamado “cadastrar_vips”. Para isso precisaremos
   abrir em tempo de execução a classe Restaurante.

   # faça a chamada e verifique a exception NoMethodError
     restaurante_um.cadastrar_vips

     # adicione esse método na classe Franquia
     def expandir(restaurante)
     def restaurante.cadastrar_vips


                              Capítulo 5 - Metaprogramação e Padrões de Projeto - Exercícios - Metaprogramação - Página 53
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




       puts "Restaurante #{self.nome} agora com área VIP!"
     end
   end

     # faça a franquia abrir a classe e adicionar o método
     franquia.expandir restaurante_um
     restaurante_um.cadastrar_vips

2) Um método útil para nossa franquia seria a verificação de nome de restaurantes cadastrados. vamos fazer
   isso usando method_missing.

   # Adicione na classe Franquia
     def method_missing(name, *args)
     @restaurantes.each do |r|
       return "O restaurante #{r.nome} já foi cadastrado!" if r.nome.eql? *args
     end
     return "O restaurante #{args[0]} não foi cadastrado ainda."
   end

     # Faça as chamadas e analise os resultados
   puts franquia.já_cadastrado?("Fazano")
     puts franquia.já_cadastrado?("Boteco")




                             Capítulo 5 - Metaprogramação e Padrões de Projeto - Exercícios - Metaprogramação - Página 54
C APÍTULO     6

Ruby on Rails
                                                                 “A libertação do desejo conduz à paz interior”
                                                                                                    – Lao-Tsé


   Aqui faremos um mergulho no Rails e, em um único capítulo, teremos uma pequena aplicação pronta: com
banco de dados, interface web, lógica de negócio e todo o necessário para um CRUD, para que nos capítulos
posteriores possamos ver cada parte do Rails com detalhes e profundidade, criando uma aplicação bem mais
completa.


 6.1 - Ruby On Rails
   David Heinemeier Hansson criou o Ruby on Rails para usar em um de seus projetos na 37signals, o Base-
camp. Desde então, passou a divulgar o código e incentivar o uso do mesmo, e em 2006 começou a ganhar
muita atenção da comunidade de desenvolvimento Web.

    O Rails foi criado pensando na agilidade e praticidade que ele proporcionaria na hora de escrever os aplica-
tivos para Web. No Brasil a Caelum vem utilizando o framework desde 2007, e grandes empresas como Abril e
Locaweb adotaram o framework em uma grande quantidade de projetos.

   Como pilares da agilidade em Rails, estão os conceitos de Don’t Repeat Yourself (DRY), e Convention over
Configuration (CoC).

   O primeiro conceito diz que você não deve repetir código e sim modularizá-lo. Ou seja, você escreve trechos
de código que serão reutilizáveis e evita o Copy And Paste de código.

   Já o segundo, diz que só devemos precisar fazer uma configuração nos casos excepcionais: ao utilizar
os padrões oferecidos pelo Rails, você configura apenas o que estiver fora do padrão, diminuindo bastante a
quantidade de configuração necessária para a grande maioria das aplicações.

   A arquitetura de desenvolvimento em Rails é baseada no conceito de separar tudo em três camadas: o
MVC (Model View Controller ). MVC é um padrão arquitetural onde os limites entre seus modelos, suas lógicas
e suas visualizações são bem definidos, sendo muito mais simples fazer um reparo, uma mudança ou uma
manutenção, já que essas três partes de comunicam de maneira bem desacoplada.




                                                      55
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




             Meta-Framework
           Rails na verdade não é um único framework, mas sim um conjunto de frameworks, alguns dos quais
           discutiremos adiante:

               • Rails

               • ActionDispatch

               • ActiveSupport

           Outros frameworks que faziam parte do núcleo do Rails antigamente foram removidos desse nú-
           cleo para diminuir o acoplamento com ele e permitir que vocês os substitua sem dificuldade, mas
           continuam funcionando e sendo usandos. Aqui estão alguns deles:

               • ActiveRecord

               • ActionController

               • ActionView

               • ActionMailer



             Projetos que usam o Ruby on Rails
           Há uma extensa lista de aplicações que usam o Ruby on Rails e, entre elas estão o Twitter, Yellow-
           Pages.com, Typo (blog open source) e o Spokeo (ferramenta de agrupamento de sites de relacio-
           namentos).
           Uma lista completa de sites usando RubyOnRails com sucesso pode ser encontrada nestes dois
           endereços:
           http://rails100.pbwiki.com
           http://blog.obiefernandez.com/content/2008/03/big-name-compan.html


 6.2 - Aprender Ruby?
    Ruby on Rails é escrito em Ruby, mas você não precisa conhecer profundamente a linguagem para começar
a programar com ele. Essa necessidade surge com o tempo, à medida que precisamos utilizar recursos mais
complexos.

   Como vimos, a linguagem é dinâmica e interpretada, sendo que facilita o desenvolvimento das aplicações
em alguns pontos básicos como, por exemplo, não obrigar o desenvolvedor a compilar o código ou a reiniciar
um servidor para que a atualização feita entre em produção.


 6.3 - IDE
   O Aptana RadRails é um ambiente de desenvolvimento integrado (Integrated Development Environment –
IDE) criado por Kyle Shank para facilitar ainda mais o desenvolvimento para o Ruby On Rails.




                                                              Capítulo 6 - Ruby on Rails - Aprender Ruby? - Página 56
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    Existem diversas funções como execução de testes automatizados, suporte para debug, syntax highlighting,
integração com diversas ferramentas, wizards, servidores, auto-complete, logs, perspectivas do banco de dados
etc. O RadRails fornece tudo o que é preciso para desenvolver em Ruby on Rails: desde a criação do projeto
até seu fechamento.

             Outras IDEs
            Existem diversas IDEs para trabalhar com Rails, sendo as mais famosas:

               • RubyMine (baseada no IntelliJ IDEA)

               • RadRails

               • MS Visual Studio 2008

               • Ruby in Steel

               • NetBeans

               • ScITE

               • InType

               • RoRed



    A maior parte dos desenvolvedores ruby rails não usam IDE alguma. Apenas bons editores de texto, como
o TextMate (Mac), Emacs, VI, GEdit, Kate, OpenKomodo, entre outros. Justamente pela baixa adoção de IDEs
no comunidade rails optamos por utilizar o GEdit.



                                                                        Capítulo 6 - Ruby on Rails - IDE - Página 57
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 6.4 - Criando um novo projeto rails
   Quando instalamos o rails em nossa máquina, ganhamos o comando ‘rails’. Através desse comando pode-
mos executar rotinas importantes nos nossos projetos. Uma dessas rotinas é a de criação de um projeto rails,
onde precisamos usar o parametro new mais o nome do projeto.


rails new meu_projeto


   Ainda nesse comando para criar novos projetos rails existe um outro parâmetro opcional onde podemos
mudar o banco de dados padrão que será usado no nosso projeto. Criando o projeto com o comando igual ao
de cima, o projeto usará o banco de dados SQLite, mas no projeto que vamos fazer vamos mudar para usar o
banco de dados MySql. Para fazer essa alteração basta usar o parâmetro ‘-d mysql’.


rails new meu_projeto -d mysql



 6.5 - Exercícios: Iniciando o Projeto

1) Inicie o GEdit:

   a) Abra o GEdit através do link “Text Editor” no seu desktop
   b) Clicar no menu Edit e escolher a opção Preferences
   c) Na nova janela clicar na aba Plugins e selecionar File Browser Pane




   d) Clicar no menu View e então selecionar Side Pane




                                                     Capítulo 6 - Ruby on Rails - Criando um novo projeto rails - Página 58
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




2) Inicie um novo projeto:

   a) Abra o terminal
   b) Executar o seguinte comando

       rails new agenda -d mysql




 6.6 - Estrutura dos diretórios
    Cada diretório tem uma função específica e bem clara na aplicação. Ao manter selecionado no wizard de
criação do projeto a opção “Generate Rails application skeleton”, o Rails gera toda a estrutura do seu programa,
criando os seguintes importantes diretórios:


                                                          Capítulo 6 - Ruby on Rails - Estrutura dos diretórios - Página 59
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




• app -> 95% da aplicação e dos códigos criados ficam aqui (inclusive todo o MVC, dividido em diretórios).

• config -> Configurações da aplicação.

• db -> Banco de Dados, Migrações e Esquemas.

• doc -> Documentação do sistema.

• lib -> Bibliotecas.

• log -> Informações de log.

• public -> Arquivos públicos (CSS, imagens, etc), que serão servidos pela WEB.

• script -> Scripts pré-definidos do Rails (console, server).

• test -> Testes de unidade, funcionais e de integração.

• tmp -> Qualquer coisa temporária como, por exemplo, cache e informações de sessões.

                                                       Capítulo 6 - Ruby on Rails - Estrutura dos diretórios - Página 60
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   • vendor -> Plugins e programas externos.


 6.7 - Carregando as dependências
    Justamente por essa característica de metaframework que Rails possui, na migração para o rails 3, decidi-
ram utilizar o Bunlder como responsável por gerenciar as dependências do seu projeto. Todo projeto que usa o
Bundler deve ter um arquivo Gemfile na raíz do projeto. O comando rails new nome_projeto que você acabou
de executar já criou este arquivo. A partir de agora qualquer biblioteca externa que você queira utilizar deve
ser descrita no Gemfile do seu projeto e sempre que for tentar rodar qualquer comando dentro do seu pro-
jeto o Bundler vai verificar se todas as dependências estão instaladas corretamente no seu computador. Caso
alguma dessas dependências não esteja estala, basta utilizar o comando bundle install pelo terminal que o
próprio Bundler se encarregará de baixar e instalar o que estive faltando. Em alguns capitulo futuros iremos utli-
zar algumas outras bibliotecas e pra isso vamos precisar alterar o Gemfile, mas por enquanto o arquivo padrão
que o rails gerou será suficiente para continuarmos.


              Principais comando do Bundler

                • bundle check - verifica se todas as dependências necessárias estão instaladas

                • bundle install - instala todas as dependências faltantes

                • bundle update - atualiza todas as dependências para a versão mais nova disponível

                • bundle list - lista todas as dependências configuradas para o projeto corrente



 6.8 - O Banco de Dados
   Uma das características do Rails é a facilidade de se comunicar com diversos bancos de modo transparente
ao programador.

    Um exemplo dessa facilidade é que ao gerar a aplicação, ele criou também um arquivo de configuração do
banco, pronto para se conectar ao MySQL. O arquivo está localizado em config/database.yml. Nada impede
a alteração manual dessa configuração para outros tipos de bancos.

    Nesse arquivo, configuramos três conexões diferentes: development, test e production, associados respec-
tivamente a agenda_development, agenda_test e agenda_production.

   Como esperado, development é usado na fase de desenvolvimento da aplicação e production em produção.
A configuração para test se refere ao banco utilizado para os testes que serão executados, e deve ser mantido
separado dos outros pois o framework apagará as tabelas após a execução.

   Antes de começar a utilizar nosso banco de dados, devemos criá-los.


 6.9 - Exercícios: Criando o banco de dados

1) Pelo terminal entre no diretorio do projeto. Execute a rake task db:create:all para criar todas as tabelas no
   seu banco de dados.

    $ rake db:create:all

                                                      Capítulo 6 - Ruby on Rails - Carregando as dependências - Página 61
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




2) Verifique que as três novas bases de dados agora foram criadas. Abra o terminal e logue como usuário root:

   $ mysql -u root

   mysql> show databases;




 6.10 - A base da construção: scaffold (andaime)
  Usando Rails, temos a opção de utilizar uma tarefa chamada scaffold, cuja tradução se equivale aos andai-
mes de um prédio em construção: criar a base para a construção de sua aplicação.

    Essa tarefa gera toda a parte de MVC (Model View Controller) relativa ao modelo dado, conectando tudo o
que é necessário para, por exemplo, lógicas de listagem, inserção, edição e busca, junto com suas respectivas
visualizações. Entre as partes do seu sistema que são geradas, existem os helpers, testes e o layout do site.

   Repare também na estrutura de arquivos que é criada para o modelo de pessoas: o Rails coloca em seu
devido lugar cada um dos controladores e visualizações.

    No scaffold, existe também uma opção para passar como parâmetro o modelo a ser criado. Com isso, o
Rails se encarrega de gerar o modelo e o script de criação da tabela no banco de dados para você.


 6.11 - Exercícios: Scaffold

1) Execute o scaffold do seu modelo pessoa:

   a) Entre novamente no terminal;
   b) Digite o seguinte comando no terminal:

       $ rails generate scaffold Pessoa nome:string data_de_nascimento:date altura:float


      Veja os diversos arquivos que são criados




                                          Capítulo 6 - Ruby on Rails - A base da construção: scaffold (andaime) - Página 62
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




c) Também gera um arquivo para criação das tabelas no banco de dados




d) E um arquivo routes.rb, que veremos mais adiante

                                                      Capítulo 6 - Ruby on Rails - Exercícios: Scaffold - Página 63
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




  e) (opcional) Criamos campos string, date e float. Quais outros tipos são suportados ? Abra a documentação
     do Rails (api.rubyonrails.org) e procure pela classe ActiveRecordConnectionAdaptersTable.


 6.12 - Gerar as tabelas
   Já definimos o modelo e seus atributos, agora vamos executar o processo de geração das tabelas. Basta
chamar o comando migrate que o rails executa o script de migração gerado pelo scaffold. O comando em
questão é uma “Rake Task”. Para executá-la basta usar o comando rake db:migrate no terminal
   Repare também que os campos no MySQL correspondem exatamente ao que foi definido no código de
migração.




   O Rails gerou também, por conta própria, o campo id, fazendo o papel de chave primária de nossa tabela.



                                                            Capítulo 6 - Ruby on Rails - Gerar as tabelas - Página 64
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 6.13 - Versão do Banco de Dados
   Ao chamar a Rake Task “migrate” pela primeira vez, será criada uma outra tabela chamada
schema_migrations.

     Essa tabela contém uma única coluna (version), que indica quais foram as migrações executadas até agora,
utilizando para isso o timestamp da última migration executada.


             Versões anteriores
            Nas versões anteriores do Rails, esta tabela se chamava schema_info e tinha apenas uma co-
            luna, com exatamente uma linha. Ela servia para indicar qual a versão do esquema do banco
            de dados que utilizávamos. Esse número era o mesmo que o começo do nome do arquivo do
            script de migração. No nosso caso, como possuímos um único script, o nome começaria com 001
            (001_create_pessoas.rb) e a versão do banco também seria 1.
            Por exemplo, ao rodar a task de migração em um projeto que possui 20 scripts, cujo banco fora
            gerado ainda na versão 15, o Rails executaria os scripts 16, 17, 18, 19 e 20.




    Existe uma versão chamada 0, que retorna para o banco de dados em sua situação antes de ser atualizado
pela primeira vez.

   Através dessa tarefa, também podemos voltar o esquema do banco de dados para versões anteriores,
bastando indicar nos argumentos da tarefa qual a versão que desejamos utilizar.

   Quando voltamos a versões anteriores do esquema, o rake chama o método down do script, por isso é
importante ter certeza que ele faz a operação inversa do método up.


 6.14 - Exercícios: Migrar tabela

1) Migre a tabela para o banco de dados:

   a) Entre o terminal
   b) Execute a rake task db:migrate

      $ rake db:migrate



   c) Verifique a tabela no mysql

      mysql -u root

      use agenda_development;


                                                     Capítulo 6 - Ruby on Rails - Versão do Banco de Dados - Página 65
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




      show tables;
      desc pessoas;



 6.15 - Server
    Precisamos de um servidor para rodar nossa aplicação web. Quando instalamos o Rails na nossa máquina
ele também instala um servidor, que, por padrão, usa a porta 3000.

     Este servidor é capaz de interpretar scripts em Ruby que as páginas utilizem. Por padrão o Webrick é
utilizado, sendo a opção mais simples. Veremos mais detalhes e opções no capítulo sobre deployment.

   Podemos iniciar o servidor através do comando rails server no terminal


$ rails server




   Após a inicialização do mesmo, basta abrir um browser e acessar o endereço http://localhost:3000




   Ao gerar o scaffold, o Rails criou algumas lógicas e suas respectivas visualizações (views).

                                                                       Capítulo 6 - Ruby on Rails - Server - Página 66
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   Por exemplo, ao visitar “http://localhost:3000/pessoas”, você é redirecionado para a listagem de pessoas.




 6.16 - Exercícios: Iniciando o servidor

1) a) Inicie o servidor com o comando:

      rails server



   b) Acesse a aplicação pela url: http://localhost:3000/pessoas


 6.17 - Documentação do Rails
    O RDoc (documentação gerada a partir dos código fonte ruby) da versão corrente do Ruby on Rails está
disponível em:

   http://api.rubyonrails.org
    Há diversos outros sites que fornecem outras versões da documentação, ou modos alternativos de exibição
e organização.

   • http://www.noobkit.com

   • http://www.railsmanual.com

   • http://rails.raaum.org


                                                  Capítulo 6 - Ruby on Rails - Exercícios: Iniciando o servidor - Página 67
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   • http://www.railsapi.org

   • http://www.railsbrain.com

   • http://www.gotapi.com

   • http://delynnberry.com/projects/rails-chm-documentation

   O RubyGems também oferece a documentação para cada um dos gems que estão instalados, para isso
basta iniciar o servidor de documentação embutido:


$ gem server
Starting gem server on http://localhost:8808/


   Este comando inicia um servidor WebRick na porta 8808. Basta acessar pelo browser para ver o RDoc de
todos os gems instalados.

   A última alternativa é gerar a documentação através do rake:


rails docs
rake doc:rails


    Depois de executar a task doc:rails, a documentação estará disponível no diretório docs/api/. A documen-
tação do ruby (bem como a biblioteca padrão) pode ser encontrada em:

   http://ruby-doc.org
   Existem ainda excelentes guias e tutoriais oficiais disponíveis. É obrigatório para todo desenvolvedor Rails
passar por estes guias:

   http://guides.rubyonrails.org
   Além desses guias, existe um site que lista as principais gems que podem ser usadas para cada tarefa:

   http://ruby-toolbox.com/
    A comunidade Ruby e Rails também costuma publicar diversos excelentes screencasts (vídeos) com aulas
e/ou palestras sobre diversos assuntos relacionados a Ruby e Rails. A lista está sempre crescendo, porém aqui
estão alguns dos principais:

   • http://railscasts.com - vídeos pequenos e de graça, normalmente de 15min a 45min. Mantidos por Ryan
     Bates.

   • http://peepcode.com - vídeos maiores, verdadeiras vídeo-aulas; alguns chegam a 2h. São pagos, porém
     muitos consideram o valor simbólico (~$9 por vídeo).

   • http://www.confreaks.com - famosos por gravar diversas conferências sobre Ruby e Rails.

   • http://rubytu.be/ - reúne screencasts de diversas fontes.




                                                         Capítulo 6 - Ruby on Rails - Documentação do Rails - Página 68
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 6.18 - Exercício Opcional: Utilizando a documentação

1) Ao inserir uma nova pessoa, o campo ano apresentado no formulário mostra um ano muito atual. Como
   alterar ? Verifique no arquivo app/views/pessoas/_form.html.erb que estamos usando um método chamado
   date_select:

  <%= f.date_select :data_de_nascimento %>
  Podemos procurar esse método na documentação, ele está em :ActionViewHelpersDateHelper e uma das
  opções que ele fornece é:

     • :start_year - Set the start year for the year select. Default is Time.now.year - 5.

  Como utilizar essa informação? basta passar por hash, como abaixo:

  <%= f.date_select :data_de_nascimento, :start_year => 1970 %>




                                      Capítulo 6 - Ruby on Rails - Exercício Opcional: Utilizando a documentação - Página 69
C APÍTULO    7

Active Record
                                                                    “Não se deseja aquilo que não se conhece”
                                                                                                      – Ovídio


   Nesse capítulo começaremos a desenvolver um sistema utilizando Ruby on Rails com recursos mais avan-
çados.


 7.1 - Motivação
    Queremos criar um sistema de qualificação de restaurantes. Esse sistema terá clientes que qualificam os
restaurantes visitados com uma nota, além de informar quanto dinheiro gastaram. Os clientes terão a possibili-
dade de deixar comentários para as qualificações feitas por eles mesmos ou a restaurantes ainda não visitados.
Além disso, os restaurantes terão pratos, e cada prato a sua receita.

  O site http://www.tripadvisor.com possui um sistema similar para viagens, onde cada cliente coloca co-
mentários sobre hotéis e suas visitas feitas no mundo inteiro.


 7.2 - Exercícios: Controle de Restaurantes

1) Crie um novo projeto chamado vota_prato:

   a) No terminal, garanta que não está no diretoria do projeto anterior.
   b) Digite o comando rails new vota_prato -d mysql
   c) Observe o log de criação do projeto:




                                                       70
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 7.3 - Modelo - O “M” do MVC
    Models são os modelos que serão usados nos sistemas: são as entidades que serão armazenadas em um
banco. No nosso sistema teremos modelos para representar um Cliente, um Restaurante e uma Qualificação,
por exemplo.

   O componente de Modelo do Rails é um conjunto de classes que usam o ActiveRecord, uma classe ORM
que mapeia objetos em tabelas do banco de dados. O ActiveRecord usa convenções de nome para determinar
os mapeamentos, utilizando uma série de regras que devem ser seguidas para que a configuração seja a mínima
possível.




                                                       Capítulo 7 - Active Record - Modelo - O “M” do MVC - Página 71
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




             ORM
           ORM (Object-Relational Mapping) é um conjunto de técnicas para a transformação entre os mode-
           los orientado a objetos e relacional.


 7.4 - ActiveRecord

    É um framework que implementa o acesso ao banco de dados de forma transparente ao usuário, fun-
cionando como um Wrapper para seu modelo. Utilizando o conceito de Conventions over Configuration, o
ActiveRecord adiciona aos seus modelos as funções necessárias para acessar o banco.

   ActiveRecord::Base é a classe que você deve estender para associar seu modelo com a tabela no Banco
de Dados.


 7.5 - Rake
   Rake é uma ferramenta de build, escrita em Ruby, e semelhante ao make e ao ant, em escopo e propósito.

   Rake tem as seguintes funcionalidades:

   • Rakefiles (versão do rake para os Makefiles) são completamente definidas em sintaxe Ruby. Não existem
     arquivos XML para editar, nem sintaxe rebuscada como a do Makefile para se preocupar.

   • É possível especificar tarefas com pré-requisitos.

   • Listas de arquivos flexíveis que agem como arrays, mas sabem como manipular nomes de arquivos e
     caminhos (paths).

   • Uma biblioteca de tarefas pré-compactadas para construir rakefiles mais facilmente.

   Para criar nossas bases de dados, podemos utilizar a rake task db:create:all. Para isso, vá ao terminal e
dentro do diretorio do projeto digite:


$ rake db:create:all


   Repare que o Rails cria três bancos de dados:             vota_prato_development, vota_prato_test e
vota_prato_production.




   Para ver todas as tasks rake disponíveis no seu projeto podemos usar o comando (na raiz do seu projeto):

                                                                Capítulo 7 - Active Record - ActiveRecord - Página 72
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




rake -T




 7.6 - Criando Modelos
   Agora iremos criar o modelo do Restaurante. Para isso, temos um gerador específico para model através
do comando rails generate model restaurante.

   Repare que o Rails gerou uma série de arquivos para nós.




 7.7 - Migrations
    Migrations ajudam a gerenciar a evolução de um esquema utilizado por diversos bancos de dados. Foi a
solução encontrada para o problema de como adicionar uma coluna no banco de dados local e propagar essa
mudança para os demais desenvolvedores de um projeto e para o servidor de produção.

    Com as migrations, podemos descrever essas transformações em classes que podem ser controladas por
sistemas de controle de versão (por exemplo, SVN) e executá-las em diversos bancos de dados.


                                                              Capítulo 7 - Active Record - Criando Modelos - Página 73
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    Sempre que executarmos a tarefa Generator -> model, o Rails se encarrega de criar uma migration inicial,
localizado em db/migrate.

   ActiveRecord::Migration é a classe que você deve estender ao criar uma migration.

   Quando geramos nosso modelo na seção               anterior, Rails gerou para nós uma migration
(db/migrate/<timestamp>_create_restaurantes.rb).      Vamos agora editar nossa migration com as infor-
mações que queremos no banco de dados.




   Queremos que nosso restaurante tenha um nome e um endereço. Para isso, devemos acrescentar:

t.string :nome, :limit => 80
t.string :endereco

   Sua migration deve ter ficado parecida com esta:




    Supondo que agora lembramos de adicionar a especialidade do restaurante. Como fazer? Basta usar o
outro gerador (Generator ) do rails que cria migration. Por exemplo:


$ rails generate migration add_column_especialidade_to_restaurante




                                                                  Capítulo 7 - Active Record - Migrations - Página 74
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   Como as migrations são sempre incrementais, basta incluirmos a coluna faltante:

def self.up
  add_column :restaurantes, :especialidade, :string, :limit => 40
end

def self.down
  remove_column :restaurantes, :especialidade
end




 7.8 - Exercícios: Criando os modelos

1) Crie nosso banco de dados

  a) Entre no terminal, no diretório do projeto
  b) execute rake db:create:all

  No terminal, acesse o mysql.

   mysql -u root

  show databases;




                                                  Capítulo 7 - Active Record - Exercícios: Criando os modelos - Página 75
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




2) Crie o modelo do Restaurante

   a) Novamente no Terminal, no diretório do projeto
   b) execute rails generate model restaurante




3) Edite seu script de migração do modelo “restaurante” para criar os campos nome e endereço:

   a) Abra o arquivo “db/migrate/<timestamp>_create_restaurantes.rb”
   b) Adicione as linhas:

   t.string :nome, :limit => 80
   t.string :endereco




4) Migre as tabelas para o banco de dados:

   a) Vá ao Terminal
   b) Execute rake db:migrate




                                                 Capítulo 7 - Active Record - Exercícios: Criando os modelos - Página 76
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   c) Olhe no banco de dados


   mysql -u root
   use vota_prato_development;
   desc restaurantes;




5) Adicione a coluna especialidade ao nosso modelo “restaurante":

   a) Vá novamente ao Terminal
   b) Digite: rails generate migration add_column_especialidade_restaurante




   c) Abra o arquivo “db/migrate/<timestamp>_add_column_especialidade_restaurante.rb”
   d) Adicione as linhas:

      def self.up
        add_column :restaurantes, :especialidade, :string, :limit => 40
      end

      def self.down
        remove_column :restaurantes, :especialidade
      end
      Seu arquivo deve ter ficado assim:

                                                 Capítulo 7 - Active Record - Exercícios: Criando os modelos - Página 77
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   e) Para efetivar a mudança no banco de dados execute rake db:migrate no Terminal




   f) Olhe no banco de dados




   g) Utilizamos add_column e remove_column na nossa migration para adicionar uma nova co-
      luna. O que mais poderia ser feito ? Abra a documentação e procure pelo módulo ActiveRe-
      cordConnectionAdaptersSchemaStatements.


 7.9 - Manipulando nossos modelos pelo console
   Podemos utilizar o console para escrever comandos Ruby, e testar nosso modelo. A grande vantagem disso,
é que não precisamos de controladores ou de uma view para testar se nosso modelo funciona de acordo com

                                       Capítulo 7 - Active Record - Manipulando nossos modelos pelo console - Página 78
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




o esperado e se nossas regras de validação estão funcionando. Outra grande vantagem está no fato de que se
precisarmos manipular nosso banco de dados, ao invés de termos de conhecer a sintaxe sql e digitar a query
manualmente, podemos utilizar código ruby e manipular através do nosso console.

   Para criar um novo restaurante, podemos utilizar qualquer um dos jeitos abaixo:

r = Restaurante.new
r.nome = "Fasano"
r.endereco = "Av. dos Restaurantes, 126"
r.especialidade = "Comida Italiana"
r.save

r = Restaurante.new do |r|
  r.nome = "Fasano"
  r.endereco = "Av. dos Restaurantes, 126"
  r.especialidade = "Comida Italiana"
end
r.save

r = Restaurante.new :nome => "Fasano",
                    :endereco => "Av. dos Restaurantes, 126",
                    :especialidade => "Comida Italiana"
r.save

Restaurante.create :nome => "Fasano",
                   :endereco => "Av. dos Restaurantes, 126",
                   :especialidade => "Comida Italiana"

   Repare que o create já salva o novo restaurante no banco de dados, não sendo necessário o comando save.

    Note que o comando save efetua a seguinte ação: se o registro não existe no banco de dados, cria um novo
registro; se já existe, atualiza o registro existente.

   Existe também o comando save!, que tenta salvar o registro, mas ao invés de apenas retornar “false” se
não conseguir, lança a exceção RecordNotSaved.

   Para atualizar um registro diretamente no banco de dados, podemos fazer:

Restaurante.update(1, {:nome => "1900"})

   Para atualizar multiplos registros no banco de dados:

Restaurante.update_all( "especialidade = ’Massas’" )

   Ou, dado um objeto r do tipo Restaurante, podemos utilizar:

r.update_attribute(:nome, "1900")

r.update_attributes :nome => "1900", :especialidade => "Pizzas"

   Existe ainda o comando update_attributes!, que chama o comando save! ao invés do comando save na hora
de salvar a alteração.

   Para remover um restaurante, também existem algumas opções. Todo ActiveRecord possui o método
destroy:

restaurante = ...
restaurante.destroy

                                         Capítulo 7 - Active Record - Manipulando nossos modelos pelo console - Página 79
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   Para remover o restaurante de id 1:

Restaurante.destroy(1)

   Para remover os restaurantes de ids 1, 2 e 3:

restaurantes = [1,2,3]
Restaurante.destroy(restaurantes)

   Para remover todos os restaurantes:

Restaurante.destroy_all

   Podemos ainda remover todos os restaurantes que obedeçam determinada condição, por exemplo:

Restaurante.destroy_all(:especialidade => "italiana")

    Os métodos destroy sempre fazem primeiro o find(id) para depois fazer o destroy(). Se for necessário
evitar o SELECT antes do DELETE, podemos usar o método delete():

Restaurante.delete(1)


 7.10 - Exercícios: Manipulando registros
   Teste a manipulação de registros pelo console.

1) Insira um novo restaurante

   a) Para ter acesso ao Console, basta digitar rails console no Terminal




   b) Digite:

      r = Restaurante.new :nome => "Fasano",
                          :endereco => "Av. dos Restaurantes, 126",
                          :especialidade => "Comida Italiana"
   c) Olhe seu banco de dados:

       mysql -u root

      use vota_prato_development;
      select * from restaurantes;




                                                   Capítulo 7 - Active Record - Exercícios: Manipulando registros - Página 80
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   d) Volte para o Console e digite:

      r.save
   e) Olhe seu banco de dados novamente:

       mysql -u root

      use vota_prato_development;
      select * from restaurantes;


2) Atualize seu restaurante

   a) Digite:

      r.update_attributes :nome => "1900"
   b) Olhe seu banco de dados novamente:

       mysql -u root

      use vota_prato_development;
      select * from restaurantes;


3) Vamos remover o restaurante criado:

   a) Digite

      Restaurante.destroy(1)
   b) Olhe seu banco de dados e veja que o restaurante foi removido

      mysql -u root

      use vota_prato_development;
      select * from restaurantes;



 7.11 - Exercícios Opcionais

1) Teste outras maneiras de efetuar as operações do exercício anterior.


 7.12 - Finders
   O ActiveRecord possui o método “find” para realizar buscas. Esse método, aceita os seguintes parâmetros:

Restaurante.all   # retorna todos os registros
Restaurante.first # retorna o primeiro registro
Restaurante.last # retorna o último registro

   Ainda podemos passar para o método find uma lista com os id’s dos registros que desejamos:

r = Restaurante.find(1)
varios = Restaurante.find(1,2,3)

                                                            Capítulo 7 - Active Record - Exercícios Opcionais - Página 81
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    Além desses, podemos definir condições para nossa busca (como o SELECT do MySQL). Existem diversas
formas de declararmos essas condições:

Restaurante.where("bla = 1 and xpto = 3")
Restaurante.where(["bla = ? and xpto = ?", 1, 3])
Restaurante.where(["bla = :b and xpto = :c", {:b => 1, :c => 3}])
Restaurante.where({ :bla => 1, :xpto => 3 }])

     Essas quatro formas fazem a mesma coisa. Procuram por registros com o campo bla = 1 e o campo xpto =
3.

     Existem ainda os chamados dynamic finders:

Restaurante.where(["nome = ? AND especialidade = ?", "Fasano", "italiana"])

     poderia ser escrito como:

find_all_by_nome_and_especialidade("Fasano", "italiana")

   Temos ainda o “find_or_create_by”, que retorna um objeto se ele existir, caso contrário, cria o objeto no
banco de dados e retorna-o:

Restaurante.find_or_create_by_nome("Fasano")

     Para finalizar, podemos chamar outros métodos encadeados para fazer querys mais complexas:

     • .order - define a ordenação. Ex: “created_at DESC, nome”.

     • .group - nome do atributo pelo qual os resultados serão agrupados. Efeito idêntico ao do comando SQL
       GROUP BY.

     • .limit - determina o limite do número de registros que devem ser retornados

     • .offset - determina o ponto de início da busca. Ex: para offset = 5, iria pular os registros de 0 a 4.

     • .include - permite carregar relacionamentos na mesma consulta usando LEFT OUTER JOINS.

     Exemplo mais completo:

Restaurante.where(’nome like :nome’, {:nome => ’%teste%’}).order(’nome DESC’).limit(20)


                  Para Sabe Mais - Outras opções para os finders
              Existem mais opções, como o “:lock”, que podem ser utilizadas, mas não serão abordadas nesse
              curso. Você pode consultá-las na documentação da API do Ruby on Rails.


 7.13 - Exercícios: Buscas dinâmicas

1) Vamos testar os métodos de busca:

     a) Abra o console (rails console no Terminal)
     b) Digite:

        Restaurante.first

                                                        Capítulo 7 - Active Record - Exercícios: Buscas dinâmicas - Página 82
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   c) Aperte enter
   d) Digite:

      Restaurante.all
   e) Aperte enter
   f) Digite:

      Restaurante.find(1)
   g) Aperte enter
   h) Digite:

      Restaurante.where(["nome = ? AND especialidade = ?",
                                           "Fasano", "Comida Italiana"])
   i) Aperte enter
   j) Digite:

      Restaurante.find_all_by_nome_and_especialidade("Fasano", "Comida Italiana")
   k) Aperte enter
   l) Digite:

      Restaurante.order("especialidade DESC").limit(1)
  m) Aperte enter


 7.14 - Validações
   Ao inserir um registro no banco de dados é bem comum a entrada de dados inválidos.

   Existem alguns campos de preenchimento obrigatório, outros que só aceitem números, que não podem
conter dados já existentes, tamanho máximo e mínimo etc.

    Para ter certeza que um campo foi preenchido antes de salvar no banco de dados, é necessário pensar em
três coisas: “como validar a entrada?”, “qual o campo a ser validado?” e “o que acontece ao tentar salvar uma
entrada inválida?”.

   Para validar esses registros, podemos implementar o método validate em qualquer ActiveRecord, porém
o Rails disponibiliza alguns comandos prontos para as validações mais comuns. São eles:

   • validates_presence_of: verifica se um campo está preenchido;

   • validates_size_of: verifica o comprimento do texto do campo;

   • validates_uniqueness_of: verifica se não existe outro registro no banco de dados que tenha a mesma
     informação num determinado campo;

   • validates_numericality_of: verifica se o preenchimento do campo é numérico;

   • validates_associated: verifica se o relacionamento foi feito corretamente;

   • etc...



                                                                   Capítulo 7 - Active Record - Validações - Página 83
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   Todos estes métodos disponibilizam uma opção (:message) para personalizar a mensagem de erro que
será exibida caso a regra não seja cumprida. Caso essa opção não seja utilizada, será exibida uma mensagem
padrão.

   Toda mensagem de erro é gravada num hash chamado errors, presente em todo ActiveRecord.

   Além dos validadores disponibilizados pelo rails, podemos utilizar um validador próprio:

validate :garante_alguma_coisa

def garante_alguma_coisa
  errors.add_to_base("Deve respeitar nossa regra") unless campo_valido?
end

   Repare que aqui, temos que incluir manualmente a mensagem de erro padrão do nosso validador.

   Se quisermos que o nome do nosso restaurante comece com letra maiúscula, poderíamos fazer:

validate :primeira_letra_deve_ser_maiuscula

private
def primeira_letra_deve_ser_maiuscula
  errors.add("nome", "primeira letra deve ser maiúscula") unless nome =~ /[A-Z].*/
end

   Além dessas alternativas, no Rails 3 incluiram uma nova maneira de criar validações que facilita os casos
onde temos vários validadores para o mesmo campo, como por exemplo:

validates :nome, :presence => true, :uniqueness => true, :length => { :maximum => 50 }

   equivalente a:

validates_presence_of :nome
validates_uniqueness_of :nome
validates_length_of :nome, :maximum => 50

             Modificadores de acesso
            Utilizamos aqui, o modificador de acesso private. A partir do ponto que ele é declarado, todos os
            métodos daquela classe serão privados, a menos que tenha um outro modificador de acesso que
            modifique o acesso a outros métodos.


             Validadores prontos
            Esse exemplo podería ter sido reescrito utilizando o validador “validates_format_of”, que verifica
            se um atributo confere com uma determinada expressão regular.


             Encoding de arquivos no Ruby e as classes de Model
            Devido ao encoding dos arquivos no Ruby 1.9 ser como padrão ASCII-8BIT, ao utilizarmos algum
            caracter acentuado no código fonte, é necessário indicarmos um encoding que suporte essa acen-
            tuação. Geralmente, esse encoding será o UTF-8. Portanto, temos que adicionar no começo do
            arquivo fonte a linha:

            #encoding: utf-8


                                                                    Capítulo 7 - Active Record - Validações - Página 84
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 7.15 - Exercícios: Validações

1) Para nosso restaurante implementaremos a validação para que o campo nome, endereço e especialidade
   não possam ficar vazios, nem que o sistema aceite dois restaurantes com o mesmo nome e endereço.

   a) Abra o modelo do restaurante (app/models/restaurante.rb)
   b) inclua as validações:

      validates_presence_of :nome, :message => "deve ser preenchido"
      validates_presence_of :endereco, :message => "deve ser preenchido"
      validates_presence_of :especialidade, :message => "deve ser preenchido"

      validates_uniqueness_of :nome, :message => "nome já cadastrado"
      validates_uniqueness_of :endereco, :message => "endereço já cadastrado"
   c) Por utilizarmos acentuação em nosso arquivo de modelo, adicione a diretiva (comentário) que indica qual
      o encoding em que o Ruby deve interpretar no início do seu arquivo.

      #encoding: utf-8

2) Inclua a validação da primeira letra maiúscula:

   validate :primeira_letra_deve_ser_maiuscula

   private
   def primeira_letra_deve_ser_maiuscula
     errors.add("nome", "primeira letra deve ser maiúscula") unless nome =~ /[A-Z].*/
   end

3) Agora vamos testar nossos validadores:

   a) Abra o Terminal
   b) Entre no Console (rails console)
   c) Digite:

      r = Restaurante.new :nome => "fasano",
                          :endereco => "Av. dos Restaurantes, 126"
      r.save
   d) Verifique a lista de erros, digitando:

      r.valid?                              # verifica se objeto passa nas validações
      r.errors.empty?              # retorna true/false indicando se há erros ou não
      r.errors.count                  # retorna o número de erros
      r.errors.on "nome"       # retorna apenas o erro do atributo nome

      r.errors.each {|field, msg| puts "#{field} - #{msg}" }




                                                          Capítulo 7 - Active Record - Exercícios: Validações - Página 85
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 7.16 - Exercícios - Completando nosso modelo

1) Vamos criar o nosso modelo Cliente, bem como sua migration:

   a) No terminal, digite: rails generate model cliente




   b) Abra o arquivo “db/migrate/<timestamp>_create_clientes.rb”
   c) Adicione as linhas:

      create_table :clientes do |t|
        t.string :nome, :limit => 80
        t.integer :idade
        t.timestamps
      end




   d) Vamos efetivar a migration usando o comando rake db:migrate


                                           Capítulo 7 - Active Record - Exercícios - Completando nosso modelo - Página 86
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   e) Olhe no console o que foi feito




   f) Olhe no banco de dados!




2) Vamos agora fazer as validações no modelo “cliente”:

   a) Abra o arquivo “app/models/cliente.rb”
   b) Adicione as seguintes linhas:

      validates_presence_of :nome, :message => " - deve ser preenchido"

      validates_uniqueness_of :nome, :message => " - nome já cadastrado"

      validates_numericality_of :idade,
                                :greater_than => 0,
                                :less_than => 100,
                                :message => " - deve ser um número entre 0 e 100"




3) Vamos criar o modelo Prato, bem como sua migration:

                                           Capítulo 7 - Active Record - Exercícios - Completando nosso modelo - Página 87
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   a) Vamos excutar o generator de model do rails novamente.
   b) rails generate model prato no Terminal
   c) Abra o arquivo “db/migrate/<timestamp>_create_pratos.rb”
   d) Adicione as linhas:

      t.string :nome, :limit => 80
   e) Volte para o Terminal
   f) execute rake db:migrate
   g) Olhe no console o que foi feito
   h) Olhe no banco de dados!

4) Vamos agora fazer as validações no modelo “prato”:

   a) Abra o arquivo “app/models/prato.rb”
   b) Adicione as seguintes linhas:

      validates_presence_of :nome, :message => " - deve ser preenchido"

      validates_uniqueness_of :nome, :message => " - nome já cadastrado"

5) Vamos criar o modelo Receita, bem como sua migration:

   a) Vá ao Terminal
   b) Execute rails generate model receita
   c) Abra o arquivo “db/migrate/<timestamp>_create_receitas.rb”
   d) Adicione as linhas:

      t.integer :prato_id
      t.text :conteudo
   e) Volte ao Terminal
   f) Execute rake db:migrate
   g) Olhe no console o que foi feito
   h) Olhe no banco de dados!

6) Vamos agora fazer as validações no modelo “receita”:

   a) Abra o arquivo “app/models/receita.rb”
   b) Adicione as seguintes linhas:

      validates_presence_of :conteudo, :message => " - deve ser preenchido"




                                             Capítulo 7 - Active Record - Exercícios - Completando nosso modelo - Página 88
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 7.17 - O Modelo Qualificação
    Antes de criarmos nosso modelo de Qualificação, repare que o Rails pluraliza os nomes de nossos modelos
de forma automática. Por exemplo, o nome da tabela do modelo Cliente ficou clientes. No entanto, qualificacao
é uma palavra que tem sua pluralização irregular (não basta adicionar um ‘s’ no final da palavra), e o Rails deve
gerar a seguinte palavra pluralizada: ‘qualificacaos’, uma vez que estamos utilizando o português e ele possui
regras de pluralização apenas para o inglês.

    Para corrigir isso, vamos ter de editar o arquivo “config/initializers/inflections.rb” e inserir manualmente
o plural da palavra ‘qualificacao’. Repare que nesse mesmo arquivo temos diversos exemplos comentados de
como podemos fazer isso.

    Quando inserirmos as linhas abaixo no final do arquivo, o Rails passará a utilizar esse padrão para a plura-
lização:

ActiveSupport::Inflector.inflections do |inflect|
  inflect.irregular ’qualificacao’, ’qualificacoes’
end


 7.18 - Exercícios - Criando o Modelo de Qualificação

1) Vamos corrigir a pluralização da palavra ‘qualificacao’

   a) Abra o arquivo “config/initializers/inflections.rb”
   b) Adicione as seguintes linhas ao final do arquivo:

      ActiveSupport::Inflector.inflections do |inflect|
        inflect.irregular ’qualificacao’, ’qualificacoes’
      end




             brazilian-rails
            Existe um plugin chamado Brazilian Rails que é um conjunto de gems para serem usadas com
            Ruby e com o Ruby on Rails e tem como objetivo unir alguns recursos úteis para os desenvolvedores
            brasileiros.

2) Vamos continuar com a criação do nosso modelo Qualificacao e sua migration.


                                                            Capítulo 7 - Active Record - O Modelo Qualificação - Página 89
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




a) No Terminal digite
b) rails generate model qualificacao




c) Abra o arquivo “db/migrate/<timestamp>_create_qualificacoes.rb”
d) Adicione as linhas:

   t.integer :cliente_id
   t.integer :restaurante_id
   t.float :nota
   t.float :valor_gasto
e) Adicione ainda as seguintes linhas depois de “create_table”: CUIDADO! Essas linhas não fazem parte
   do create_table, mas devem ficar dentro do método self.up.

   add_index(:qualificacoes, :cliente_id)
   add_index(:qualificacoes, :restaurante_id)




f) Volte ao Terminal
g) Execute rake db:migrate


                                   Capítulo 7 - Active Record - Exercícios - Criando o Modelo de Qualificação - Página 90
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




  h) Olhe no console o que foi feito




   i) Olhe no banco de dados




3) Vamos agora fazer as validações no modelo “qualificacao”:

  a) Abra o arquivo “app/models/qualificacao.rb”
  b) Adicione as seguintes linhas:

     validates_presence_of :nota, :message => " - deve ser preenchido"
     validates_presence_of :valor_gasto, :message => " - deve ser preenchido"

     validates_numericality_of :nota,
                               :greater_than_or_equal_to => 0,
                               :less_than_or_equal_to => 10,
                               :message => " - deve ser um número entre 0 e 10"

     validates_numericality_of :valor_gasto,
                               :greater_than => 0,
                               :message => " - deve ser um número maior que 0"




                                       Capítulo 7 - Active Record - Exercícios - Criando o Modelo de Qualificação - Página 91
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 c) Abra o Console (digite rails console no Terminal). No Console do Rails digite:

    "qualificacao".pluralize


7.19 - Relacionamentos




                                                            Capítulo 7 - Active Record - Relacionamentos - Página 92
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    Para relacionar diversos modelos, precisamos informar ao Rails o tipo de relacionamento entre eles. Quando
isso é feito, alguns métodos são criados para podermos manipular os elementos envolvidos nesse relaciona-
mento. Os relacionamentos que Rails disponibiliza são os seguintes:

   • belongs_to - usado quando um modelo tem como um de seus atributos o id de outro modelo (many-to-one
     ou one-to-one).
     Quando dissermos que uma qualificação belongs_to um restaurante, ainda ganharemos os seguintes
     métodos:

        – Qualificacao.restaurante (similar ao Restaurante.find(restaurante_id))
        – Qualificacao.restaurante=(restaurante)          (similar     ao      qualificacao.restaurante_id =
          restaurante.id)
        – Qualificacao.restaurante? (similar ao qualificacao.restaurante == algum_restaurante)

   • has_many - associação que provê uma maneira de mapear uma relação one-to-many entre duas entida-
     des.
     Quando dissermos que um restaurante has_many qualificações, ganharemos os seguintes métodos:

        – Restaurante.qualificacoes        (semelhante      ao       Qualificacao.find :all, :conditions =>
          ["restaurante_id = ?”, id])
        – Restaurante.qualificacoes<<
        – Restaurante.qualificacoes.delete
        – Restaurante.qualificacoes=

   • has_and_belongs_to_many - associação muitos-para-muitos, que é feita usando uma tabela de mapea-
     mento.
     Quando dissermos que um prato has_and_belongs_to_many restaurantes, ganharemos os seguintes
     métodos:

        – Prato.restaurantes
        – Prato.restaurantes<<
        – Prato.restaurantes.delete
        – Prato.restaurantes=

     Além disso, precisaremos criar a tabela pratos_restaurantes, com as colunas prato_id e restau-
     rante_id. Por convenção, o nome da tabela é a concatenação do nome das duas outras tabelas, seguindo
     a ordem alfabética.

   • has_one - lado bidirecional de uma relação um-para-um.
     Quando dissermos que um prato has_one receita, ganharemos os seguintes métodos:

        – Prato.receita, (semelhante ao Receita.find(:first, :conditions => “prato_id = id”))
        – Prato.receita=




                                                              Capítulo 7 - Active Record - Relacionamentos - Página 93
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 7.20 - Para Saber Mais: Auto-relacionamento
    Os relacionamentos vistos até agora foram sempre entre dois objetos de classes diferentes. Porém existem
relacionamentos entre classes do mesmo tipo, por exemplo, uma Categoria de um site pode conter outras cate-
gorias, onde cada uma contém ainda suas categorias. Esse relacionamento é chamado auto-relacionamento.

   No ActiveRecord temos uma forma simples para fazer essa associação.

class Category < ActiveRecord::Base
    has_many :children, :class_name => "Category", :foreign_key => "father_id"
    belongs_to :father, :class_name => "Category"
end


 7.21 - Para Saber Mais: Cache
   Todos os resultados de métodos acessados de um relacionamento são obtidos de um cache e não nova-
mente do banco de dados. Após carregar as informações do banco, o ActiveRecord só volta se ocorrer um
pedido explicito. Exemplos:

restaurante.qualificacoes                 #   busca   no banco de dados
restaurante.qualificacoes.size            #   usa o   cache
restaurante.qualificacoes.empty?          #   usa o   cache
restaurante.qualificacoes(true).size      #   força   a busca no banco de dados
restaurante.qualificacoes                 #   usa o   cache


 7.22 - Exercícios - Relacionamentos

1) Vamos incluir os relacionamentos necessários para nossos modelos:

   a) Abra o arquivo “app/models/cliente.rb”
   b) Adicione a seguinte linha:

      has_many :qualificacoes




   c) Abra o arquivo “app/models/restaurante.rb”
   d) Adicione a seguinte linha:

      has_many :qualificacoes
      has_and_belongs_to_many :pratos




                                              Capítulo 7 - Active Record - Para Saber Mais: Auto-relacionamento - Página 94
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




e) Abra o arquivo “app/models/qualificacao.rb”
f) Adicione as seguintes linhas:

   belongs_to :cliente
   belongs_to :restaurante




g) Abra o arquivo “app/models/prato.rb”
h) Adicione as seguintes linhas:

   has_and_belongs_to_many :restaurantes
   has_one :receita




                                               Capítulo 7 - Active Record - Exercícios - Relacionamentos - Página 95
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   i) Abra o arquivo “app/models/receita”
   j) Adicione a seguinte linha:

     belongs_to :prato




2) Vamos criar a tabela para nosso relacionamento has_and_belongs_to_many:

  a) Va para o Terminal
  b) Digite: rails generate migration createPratosRestaurantesJoinTable
  c) Abra o arquivo “db/migrate/<timestamp>_create_pratos_restaurantes_join_table.rb”
  d) O rails não permite que uma tabela de ligação para um relacionamento has_and_belongs_to_many possua
     chave primária auto incremento. Por isso, vamos fazer com que o rails não gere essa chave. Basta passar
     o parâmetro :id=>false para o método create_table. Dessa forma, teremos que digitar o seguinte no
     self.up:

     create_table :pratos_restaurantes, :id => false do |t|
     t.integer :prato_id
     t.integer :restaurante_id
         end
  e) E o seguinte no self.down

     drop_table :pratos_restaurantes




                                                  Capítulo 7 - Active Record - Exercícios - Relacionamentos - Página 96
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   f) Volte ao Terminal e execute a migration (rake db:migrate)
   g) Olhe no console o que foi feito
   h) Olhe no banco de dados

3) Vamos incluir as validações que garantam que os relacionamentos foram feitos corretamente:

   a) Abra o arquivo “app/models/qualificacao.rb”
   b) Adicione as seguintes linhas:

      validates_presence_of :cliente_id, :restaurante_id
      validates_associated :cliente, :restaurante
   c) Abra o arquivo “app/models/receita.rb”
   d) Adicione as seguintes linhas:

      validates_presence_of :prato_id
      validates_associated :prato
   e) Abra o arquivo “app/models/prato.rb”
   f) Adicione as seguintes linhas:

      validate :validate_presence_of_more_than_one_restaurante

      private
      def validate_presence_of_more_than_one_restaurante
        errors.add("restaurantes", "deve haver ao menos um restaurante") if restaurantes.empty?
      end

4) Faça alguns testes no terminal para testar essas novas validações.




                                                   Capítulo 7 - Active Record - Exercícios - Relacionamentos - Página 97
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 7.23 - Para Saber Mais - Eager Loading
   Podemos cair em um problema grave caso o número de qualificações para um restaurante seja muito grande.
Imagine que um determinado restaurante do nosso sistema possua com 100 qualificações. Queremos mostrar
todas as qualificações desse restaurante, então fazemos um for:

for qualificacao in Qualificacao.all
  puts "restaurante: " + qualificacao.restaurante.nome
  puts "cliente:      " + qualificacao.cliente.nome
  puts "qualificacao: " + qualificacao.nota
end

   Para iterar sobre as 100 qualificações do banco de dados, seriam geradas 201 buscas! Uma busca para to-
das as qualificações, 100 buscas para cada restaurante mais 100 buscas para cada cliente! Podemos melhorar
um pouco essa busca. Podemos pedir ao ActiveRecord que inclua o restaurante quando fizer a busca:

Qualificacao.find(:all, :include => :restaurante)

   Bem melhor! Agora a quantidade de buscas diminuiu para 102! Uma busca para as qualificações, outra
para todos os restaurantes e mais 100 para os clientes. Podemos utilizar a mesma estratégia para otimizar a
busca de clientes:

Qualificacao.includes(:restaurante, :cliente)

   Com essa estratégia, teremos o número de buscas muito reduzido. A quantidade total agora será de 1
+ o número de associações necessárias. Poderíamos ir mais além, e trazer uma associação de uma das
associações existentes em qualificação:

Qualificacao.includes(:cliente, {:restaurante => {:pratos => :receita}})


 7.24 - Para Saber Mais - Named Scopes
   Para consultas muito comuns, podemos usar o recurso de Named Scopes oferecido pelo ActiveRecord,
que permite deixarmos alguns tipos de consultas comuns “preparadas”.

   Imagine que a consulta de restaurantes de especialidade “massa” seja muito comum no nosso sistema.
Podemos facilitá-la criando um named scope na classe Restaurante:

class Restaurante < ActiveRecord::Base
  scope :massas, where({ :especialidade => ’massas’ })
end

   As opções mais comuns do método find também estão disponíveis para named scopes, como :conditions,
:order, :select e :include.

   Com o named scope definido, a classe ActiveRecord ganha um método de mesmo nome, através do qual
podemos recuperar os restaurantes de especialidade "massas

   de forma simples:

Restaurante.massas
Restaurante.massas.first
Restaurante.massas.last
Restaurante.massas.where(["nome like ?", ’%x%’])


                                                Capítulo 7 - Active Record - Para Saber Mais - Eager Loading - Página 98
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   O método associado ao named scope criado retorna um objeto da classe ActiveRecordNamedScope Scope,
que age como um Array, mas aceita a chamada de alguns métodos das classes ActiveRecord, como o find
para filtrar ainda mais a consulta.

   Podemos ainda definir diversos named scopes e combiná-los de qualquer forma:

class Restaurante < ActiveRecord::Base
  scope :massas, where(:especialidade => ’massas’ })
  scope :recentes, where([ "created_at > ?", 3.months.ago ])
  scope :pelo_nome, order(’nome’)
end

Restaurante.massas   # todos de especialidade = ’massas’
Restaurante.recentes # todos de created_at > 3 meses atras

# especialidade = ’massas’ e created_at > 3 meses atras
Restaurante.massas.recentes
Restaurante.recentes.massas

Restaurante.massas.pelo_nome.recentes


 7.25 - Para Saber Mais - Modules
    As associações procuram por relacionamentos entre classes que estejam no mesmo módulo. Caso precise
de relacionamentos entre classes em módulos distintos, é necessário informar o nome completo da classe no
relacionamento:

module Restaurante
  module RH
    class Pessoa < ActiveRecord::Base;
        end
  end

  module Financeiro
    class Pagamento < ActiveRecord::Base
      belongs_to :pessoa, :class_name => "Restaurante::RH::Pessoa"
    end
  end
end




                                                   Capítulo 7 - Active Record - Para Saber Mais - Modules - Página 99
C APÍTULO     8

Controllers e Views
                                                  “A Inteligência é quase inútil para quem não tem mais nada”
                                                                                                 – Carrel, Alexis

   Nesse capítulo, você irá aprender o que são controllers e como utilizá-los para o benefício do seu projeto,
além de aprender a trabalhar com a camada visual de sua aplicação.


 8.1 - O “V” e o “C” do MVC
   O “V” de MVC representa a parte de view (visualização) da nossa aplicação, sendo ela quem tem contato
com o usuário, recebe as entradas e mostra qualquer tipo de saída.

  Há diversas maneiras de controlar as views, sendo a mais comum delas feita através dos arquivos
HTML.ERB, ou eRuby (Embedded Ruby), páginas HTML que podem receber trechos de código em Ruby.

   Controllers são classes que recebem uma ação de uma View e executam algum tipo de lógica ligada a um
ou mais modelos. Em Rails esses controllers estendem a classe ApplicationController.

  As urls do servidor são mapeadas da seguinte maneira: /controller/action/id. Onde “controller” representa
uma classe controladora e “action” representa um método do mesmo. “id” é um parâmetro qualquer (opcional).


 8.2 - Hello World
   Antes de tudo criaremos um controller que mostrará um “Hello World” para entender melhor como funciona
essa idéia do mapeamento de urls.

   Vamos usar o generator do rails para criar um novo controller que se chamará “HelloWorld”. Veja que o Rails
não gera apenas o Controller, mas também outros arquivos.




                                                     100
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   Apos habilitar o rota padrão do rails tente acessar a página http://localhost:3000/hello_world

    Na URL acima passamos apenas o controller sem nenhuma action, por isso recebemos uma mesagem de
erro.




   Além de não dizer qual a action na URL, não escrevemos nenhuma action no controller.

   Criaremos um método chamado hello no qual escreveremos na saída do cliente a frase “Hello World!”.
Cada método criado no controller é uma action, que pode ser acessada através de um browser.

   Para escrever na saída, o Rails oferece o comando render, que recebe uma opção chamada “text” (String).
Tudo aquilo que for passado por esta chave será recebido no browser do cliente.


 8.3 - Exercícios: Criando o controlador

1) Crie um controller que mostre na tela a mensagem “Hello World”

   a) Va ao Terminal
   b) Execute rails generate controller HelloWorld




   c) Entre no seu novo controller (app/controllers/hello_world_controller.rb)


                                           Capítulo 8 - Controllers e Views - Exercícios: Criando o controlador - Página 101
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




d) Inclua o método “hello":

   def hello
     render :text => "Hello World!"
   end




e) Descomente a última linha do arquivo config/routes.rb para habilitar a rota padrão do rails. No próximo
   capítulo falaremos mais sobre esse assunto.

   # This is a legacy wild controller route that’s not recommended for RESTful applications.
   # Note: This route will make all actions in every controller accessible via GET requests.
   match ’:controller(/:action(/:id(.:format)))’




f) O último passo antes de testar no browser é iniciar o server.
g) Execute no Terminal: rails server
h) Confira o link http://localhost:3000/hello_world/hello.




                                         Capítulo 8 - Controllers e Views - Exercícios: Criando o controlador - Página 102
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 8.4 - Redirecionamento de Action e Action padrão
    Mas não há necessidade de toda vez escolher qual action será executada. Temos a opção de escrever uma
action padrão que será invocada sempre que nenhuma outra for definida na url sendo acessada.

   Para definir uma action padrão temos que dar o nome do método de index:

def index
  render :text => "Action Padrão!"
end

   Dentro de uma action, podemos redirecionar a saída para uma outra action. No exemplo do Hello World, ao
chamar o comando redirect_to e passar como argumento a action desejada (:action => “hello

   ), o Rails fará o redirecionamento no cliente.

def index
  redirect_to(:action => "hello")
end

   Ao acessar http://localhost:3000/hello_world, o servidor nos redireciona para a página http://localhost:
3000/hello_world/hello, mostrando um “Hello World” igual ao anterior.
    Ao invés de fazer o redirecionamento, podemos chamar outra action diretamente. Assim não vamos ser
redirecionados e a URL continuará a mesma.

def index
  hello
end


             Redirecionamento no servidor e no cliente
            O redirecionamento no servidor é conhecido como forward e a requisição é apenas repassada a
            um outro recurso (página, controlador) que fica responsável em tratar a requisição.
            Há uma outra forma que é o redirecionamento no cliente (redirect). Nesta modalidade, o servidor
            responde a requisição original com um pedido de redirecionamento, fazendo com que o nave-
            gador dispare uma nova requisição para o novo endereço. Neste caso, a barra de endereços do
            navegador muda.




                                   Capítulo 8 - Controllers e Views - Redirecionamento de Action e Action padrão - Página 103
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 8.5 - Trabalhando com a View: O ERB

             ERb
           ERb é uma implementação de eRuby que já acompanha a linguagem Ruby. Seu funcionamento é
           similar ao dos arquivos JSP/ASP: arquivos html com injeções de código. A idéia é que o HTML serve
           como um template, e outros elementos são dinâmicamente inseridos em tempo de renderização.


    Para uma página aceitar código Ruby, ela deve estar entre “<%” e “%>”. Há uma variação deste operador,
o “<%=”, que não só executa códigos Ruby, mas também imprime o resultado na página HTML.

   É importante notar que todos os atributos de instância (@variavel) de um controlador estão disponíveis em
sua view. Além disso, ela deve ter o mesmo nome do controlador, o que significa que a view da nossa action
index do controlador restaurantes_controller.rb deve estar em app/views/restaurantes/index.html.erb.

   Precisamos de uma view que vá possibilitar inserir os valores de um novo restaurante:

<form action=’/restaurantes/create’>
  Nome: <input type=’text’ name=’nome’/>
  <input type=’submit’ value=’Create’/>
</form>

    E agora, para receber este valor nome no controlador, basta usar o hash params. (Repare que agora usamos
outra action, create, para buscar os dados do formulário apresentado anteriormente):

class RestaurantesController < ApplicationController
  def create
    nome = params[’nome’]
  end
end

   O problema desta abordagem é que precisaríamos recuperar os valores enviados pelo formulário, um a
um. Para um formulário com 15 campos, teríamos 15 linhas! Para simplificar esta tarefa, o Rails oferece a
possibilidade de utilizar algo parecido com um hash para os valores dos atributos:

<form action=’/restaurantes/create’>
  Nome: <input type=’text’ name=’restaurante[nome]’ />
  Endereço: <input type=’text’ name=’restaurante[endereco]’ />
  Especialidade: <input type=’text’ name=’restaurante[especialidade]’ />
  <input type=’submit’ value=’Create’/>
</form>

   Desta forma, podemos receber todos os valores como um hash nos controladores:

class RestaurantesController < ApplicationController
  def create
    valores = params[’restaurante’]
  end
end

    O mais interessante é que as classes ActiveRecord já aceitam um hash com os valores iniciais do objeto,
tanto no método new, no método create (que já salva), quanto no método update_attributes:


                                           Capítulo 8 - Controllers e Views - Trabalhando com a View: O ERB - Página 104
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




Restaurante.create(params[’restaurante’])


 8.6 - Entendendo melhor o CRUD
   Agora, queremos ser capazes de criar, exibir, editar e remover restaurantes. Como fazer?

     Primeiro, temos de criar um controller para nosso restaurante. Pela view Generators, vamos criar um con-
troller para restaurante. Rails, por padrão, utiliza-se de sete actions “CRUD”. São eles:

   • list: exibe todos os items

   • show: exibe um item específico

   • new: formulário para a criação de um novo ítem

   • create: cria um novo ítem

   • edit: formulário para edição de um ítem

   • update: atualiza um ítem existente

   • destroy: remove um ítem existente

    Desejamos listar todos os restaurantes do nosso Banco de Dados, e portanto criaremos a action list.
Como desejamos que o comportamento padrão do nosso controlador restaurante seja exibir a listagem de
restaurantes, podemos renomeá-la para index.

   Assim como no console buscamos todos os restaurantes do banco de dados com o comando find, também
podemos fazê-lo em controllers (que poderão ser acessados pelas nossas views, como veremos mais adiante).

   Basta agora passar o resultado da busca para uma variável:

def index
  @restaurantes = Restaurante.order("nome")
end

     Para exibir um restaurante específico, precisamos saber qual restaurante buscar. Essa informação vem no
“id” da url, e contem o id do restaurante que desejamos. Para acessá-la, podemos usar como parâmetro do
método find params[id], que recupera as informações passadas no id da url.

   Agora, podemos criar nossa action show:

def show
  @restaurante = Restaurante.find(params[:id])
end

  Para incluir um novo restaurante, precisamos primeiro retornar ao browser um restaurante novo, sem infor-
mação alguma. Vamos criar nossa action new

def new
 @restaurante = Restaurante.new
end

    Uma vez que o usuário do nosso sistema tenha preenchido as informações do novo restaurante e deseje
salvá-las, enviará uma requisição à nossa action create, passando como parâmetro na requisição, o novo
restaurante a ser criado. Vamos criar nossa action:

                                               Capítulo 8 - Controllers e Views - Entendendo melhor o CRUD - Página 105
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




def create
  @restaurante = Restaurante.new(params[:restaurante])
  @restaurante.save
end

    Para editar um restaurante, devemos retornar ao browser o restaurante que se quer editar, para só depois
salvar as alterações feitas:

def edit
  @restaurante = Restaurante.find(params[:id])
end

   Uma vez que o usuário tenha atualizado as informações do restaurante e deseje salvá-las, enviará uma
requisição à nossa action update passando no id da url o id do restaurante a ser editado, bem como o restaurante
que será “colado” em seu lugar:

def update
  @restaurante = Restaurante.find(params[:id])
  @restaurante.update_attributes(params[:restaurante])
end

    Para remover um restaurante, o usuário enviará uma requisição à nossa action destroy passando no id da
url o id do restaurante a ser excluído:

def destroy
  @restaurante = Restaurante.find(params[:id])
  @restaurante.destroy
end


 8.7 - Exercícios: Controlador do Restaurante

1) Gere um controller para o modelo restaurante:

   a) Va ao Terminal;
   b) Execute rails generate controller restaurantes

2) Crie as actions CRUD para o controller criado:

   a) Abra o seu controller de Restaurantes (app/controllers/restaurantes_controllers.rb)
   b) Insira no controller a actions CRUD:

      class RestaurantesController < ApplicationController
        def index
          @restaurantes = Restaurante.order("nome")
        end

        def show
          @restaurante = Restaurante.find(params[:id])
        end

        def new
          @restaurante = Restaurante.new

                                       Capítulo 8 - Controllers e Views - Exercícios: Controlador do Restaurante - Página 106
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




        end

        def create
          @restaurante = Restaurante.new(params[:restaurante])
          if @restaurante.save
            redirect_to(:action => "show", :id => @restaurante)
          else
            render :action => "new"
          end
        end

        def edit
          @restaurante = Restaurante.find(params[:id])
        end

        def update
          @restaurante = Restaurante.find(params[:id])
          if @restaurante.update_attributes(params[:restaurante])
            redirect_to(:action => "show", :id => @restaurante)
          else
            render :action => "edit"
          end
        end

        def destroy
          @restaurante = Restaurante.find(params[:id])
          @restaurante.destroy

         redirect_to(:action => "index")
       end
     end


 8.8 - Helper
   Helpers são módulos que disponibilizam métodos para serem usados em nossas views. Eles provêm atalhos
para os códigos mais usados e nos poupam de escrever muito código. O propósito de um helper é simplificar
suas views.

   Quando criamos um controller, o Rails automaticamente cria um helper para esse controller em
app/helpers/. Todo método escrito num helper, estará automaticamente disponível em sua view. Existe um
Helper especial, o application_helper.rb, cujos métodos ficam disponíveis para todas as views.

   Quando trabalhamos com formulários, usamos os chamados FormHelpers, que são módulos especial-
mente projetados para nos ajudar nessa tarefa. Todo FormHelper está associado a um ActiveRecord. Existem
também os FormTagHelpers, que contém um _tag em seu nome. FormTagHelpers, não estão necessaria-
mente associados a ActiveRecord algum.

   Abaixo, uma lista dos FormHelpers disponíveis:

   • check_box


                                                              Capítulo 8 - Controllers e Views - Helper - Página 107
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   • fields_for

   • file_field

   • form_for

   • hidden_field

   • label

   • password_field

   • radio_button

   • text_area

   • text_field

   E uma lista dos FormTagHelpers:

   • check_box_tag

   • field_set_tag

   • file_field_tag

   • form_tag

   • hidden_field_tag

   • image_submit_tag

   • password_field_tag

   • radio_button_tag

   • select_tag

   • submit_tag

   • text_area_tag

   • text_field_tag

   Agora, podemos reescrever nossa view:

<%= form_tag :action => ’create’ do %>
  Nome: <%= text_field :restaurante, :nome %>
  Endereço: <%= text_field :restaurante, :endereco %>
  Especialidade: <%= text_field :restaurante, :especialidade %>
  <%= submit_tag ’Criar’ %>
<% end %>

   Repare que como utilizamos o form_tag, que não está associado a nenhum ActiveRecord, nosso outro
Helper text_field não sabe qual o ActiveRecord que estamos trabalhando, sendo necessário passar para cada
um deles o parâmetro :restaurante, informando-o.


                                                              Capítulo 8 - Controllers e Views - Helper - Página 108
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   Podemos reescrever mais uma vez utilizando o FormHelper form_for, que está associado a um
ActiveRecord:

<%= form_for :restaurante, :url => { :action => ’create’ } do |f| %>
  Nome: <%= f.text_field :nome %>
  Endereço: <%= f.text_field :endereco %>
  Especialidade: <%= f.text_field :especialidade %>
  <%= submit_tag ’Criar’ %>
<% end %>

   Repare agora que não foi preciso declarar o nome do nosso modelo para cada text_field, uma vez que
nosso Helper form_for já está associado a ele.


            Helper Method
           Existe também o chamado helper_method, que permite que um método de seu controlador vire um
           Helper e esteja disponível na view para ser chamado. Exemplo:

           class TesteController < ApplicationController
             helper_method :teste

             def teste
               "algum conteudo dinamico"
             end
           end
           E em alguma das views deste controlador:

           <%= teste %>



 8.9 - Exercícios: Utilizando helpers para criar as views

1) Vamos criar as views do restaurante:

   a) Crie o arquivo app/views/restaurantes/index.html.erb.
   b) Digite o conteúdo abaixo:

      <h1>Listagem de Restaurantes</h1>

      <table>
        <tr>
          <th>Nome</th>
          <th>Endereço</th>
          <th>Especialidade</th>
        </tr>

      <% @restaurantes.each do |restaurante| %>
        <tr>
          <td><%= restaurante.nome %></td>
          <td><%= restaurante.endereco %></td>
          <td><%= restaurante.especialidade %></td>
          <td><%= link_to ’Mostrar’, { :action => ’show’, :id => restaurante } %></td>

                              Capítulo 8 - Controllers e Views - Exercícios: Utilizando helpers para criar as views - Página 109
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




      <td><%= link_to ’Editar’, { :action => ’edit’, :id => restaurante } %></td>
      <td><%= link_to ’Deletar’, { :action => ’destroy’, :id => restaurante } %></td>
    </tr>
  <% end %>
  </table>

  <br/>
  <%= link_to ’Novo’, { :action => ’new’ } %>




c) Teste agora entrando em: http://localhost:3000/restaurantes (Não esqueça de iniciar o servidor)




                          Capítulo 8 - Controllers e Views - Exercícios: Utilizando helpers para criar as views - Página 110
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




d) Crie o arquivo app/views/restaurantes/show.html.erb
e) Digite o conteúdo abaixo:

   <h1>Exibindo Restaurante</h1>

   <p>
     <b>Nome: </b>
     <%= @restaurante.nome %>
   </p>

   <p>
     <b>Endereço: </b>
     <%= @restaurante.endereco %>
   </p>

   <p>
     <b>Especialidade: </b>
     <%= @restaurante.especialidade %>
   </p>

   <%= link_to ’Editar’, { :action => ’edit’, :id => @restaurante } %>
   <%= link_to ’Voltar’, { :action => ’index’ } %>




                           Capítulo 8 - Controllers e Views - Exercícios: Utilizando helpers para criar as views - Página 111
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




f) Crie o arquivo app/views/restaurantes/new.html.erb
g) Digite o conteúdo abaixo:

   <h1>Adicionando Restaurante</h1>

   <% if @restaurante.errors.any? %>
     <ul>
     <% @restaurante.errors.full_messages.each do |msg| %>
       <li><%= msg %></li>
     <% end %>
     </ul>
   <% end %>

   <%= form_for :restaurante, :url => { :action => ’create’ } do |f| %>
     Nome: <%= f.text_field :nome %><br/>
     Endereço: <%= f.text_field :endereco %><br/>
     Especialidade: <%= f.text_field :especialidade %><br/>
     <%= submit_tag ’Criar’ %>
   <% end %>

   <%= link_to ’Voltar’, { :action => ’index’ } %>
h) Crie o arquivo app/views/restaurantes/edit.html.erb
i) Digite o conteúdo abaixo:

   <h1>Editando Restaurante</h1>


                           Capítulo 8 - Controllers e Views - Exercícios: Utilizando helpers para criar as views - Página 112
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




      <% if @restaurante.errors.any? %>
        <ul>
        <% @restaurante.errors.full_messages.each do |msg| %>
          <li><%= msg %></li>
        <% end %>
        </ul>
      <% end %>

      <%= form_for :restaurante, :url => { :action => ’update’, :id => @restaurante } do |f| %>
        Nome: <%= f.text_field :nome %><br/>
        Endereço: <%= f.text_field :endereco %><br/>
        Especialidade: <%= f.text_field :especialidade %><br/>
        <%= submit_tag ’Atualizar’ %>
      <% end %>

      <%= link_to ’Voltar’, { :action => ’index’ } %>
   j) Teste suas views: http://localhost:3000/restaurantes Não esqueça que existe uma validação para
      primeira letra maiúscula no nome do restaurante.


 8.10 - Partial
   Agora, suponha que eu queira exibir em cada página do restaurante um texto, por exemplo: “Controle de
Restaurantes”.

   Poderíamos escrever esse texto manualmente, mas vamos aproveitar essa necessidade para conhecer um
pouco sobre Partials.

   Partials são fragmentos de html.erb que podem ser incluídas em uma view. Eles permitem que você reutilize
sua lógica de visualização.

   Para criar um Partial, basta incluir um arquivo no seu diretório de views (app/views/restaurantes) com o
seguinte nome: _meupartial. Repare que Partials devem obrigatóriamente começar com _.

   Para utilizar um Partial em uma view, basta acrescentar a seguinte linha no ponto que deseja fazer a inclusão:

render :partial => "meupartial"


 8.11 - Exercícios: Customizando o cabeçalho

1) Vamos criar um partial:

   a) Crie o arquivo: app/views/restaurantes/_titulo.html.erb
   b) Coloque o seguinte conteúdo:

      <h1>Controle de Restaurantes</h1><br/>




                                                                   Capítulo 8 - Controllers e Views - Partial - Página 113
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   c) Abra todos os arquivos criados no exercício anterior (app/views/restaurantes/* )
   d) Insira a seguinte linha no início:

      <%= render :partial => "titulo" %>
      Seu app/views/restaurantes deve estar com os seguintes arquivos:




   e) Teste suas views: http://localhost:3000/restaurantes


 8.12 - Layout
    Como vimos, quando criamos um Partial, precisamos declará-lo em todas as páginas que desejamos utilizá-
los. Existe uma alternativa melhor quando desejamos utilizar algum conteúdo estático que deve estar presente
em todas as páginas: o layout.

   Cada controller pode ter seu próprio layout, e uma alteração nesse arquivo se refletirá por to-
das as views desse controller. Os arquivos de layout devem ter o nome do controller, por exemplo
app/views/layouts/restaurantes.html.erb.

   Um arquivo de layout “padrão” tem o seguinte formato:

<html>
  <head>

                                                                 Capítulo 8 - Controllers e Views - Layout - Página 114
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    <title>Um título</title>
  </head>
  <body>
    <p style="color: green"><%= flash[:notice] %></p>

    <%= yield %>
  </body>
</html>

    Tudo o que está nesse arquivo pode ser modificado, com exceção do <%= yield %>, que renderiza cada view
do nosso controlador. Também deixaremos a linha <p style="color: green”><%= flash[:notice] %></p>,
pois ela é a responsável por exibir as mensagens do escopo flash.

     Podemos utilizar ainda o layout application.html.erb.       Para isso, precisamos criar o arquivo
app/views/layouts/application.html.erb e apagar os arquivos de layout dos controladores que queremos que
utilizem o layout do controlador application. Com isso, se desejarmos ter um layout único para toda nossa
aplicação, por exemplo, basta ter um único arquivo de layout.


 8.13 - Exercícios: Criando o header

1) Nesse exercício, vamos utilizar o layout application para alterar o título de todas as janelas de nossa aplica-
   ção:

   a) Abra o arquivo app/views/layouts/application.html.erb
   b) Altere o title para Programa de Qualificação de Restaurantes
   c) Adicione <p style="color: green”><%= flash[:notice] %></p> no body

      <!DOCTYPE html>
      <html>
        <head>
          <title>Programa de Qualificação de Restaurantes</title>
          <%= stylesheet_link_tag :all %>
          <%= javascript_include_tag :defaults %>
          <%= csrf_meta_tag %>
        </head>
        <body>
          <p style="color: green"><%= flash[:notice] %></p>
          <%= yield %>
        </body>
      </html>




                                                 Capítulo 8 - Controllers e Views - Exercícios: Criando o header - Página 115
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




  d) Teste suas views: http://localhost:3000/restaurantes. Repare no título das janelas.


 8.14 - Outras formas de gerar a View
   O Rails já vem com suporte a outros handlers para geração de views. Além do ERB, podemos também usar
o Builder e o RJS, que veremos mais adiante.

   O Builder é adequado quando a view a ser gerada é um arquivo XML, já que permite a criação de um xml
usando sintaxe Ruby. Veja um exemplo:

# app/views/authors/show.xml.builder
xml.author do
  xml.name(’Alexander Pope’)
end

   O xml resultante é:

<author>
  <name>Alexander Pope</name>
</author>

   Outra alternativa muito popular para a geração das views é o HAML:

   http://haml.hamptoncatlin.com

#content
  .left.column

                                            Capítulo 8 - Controllers e Views - Outras formas de gerar a View - Página 116
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    %h2 Welcome to our site!
    %p= print_information
  .right.column= render :partial => "sidebar"


   E o equivalente com ERB:

<div id=’content’>
  <div class=’left column’>
    <h2>Welcome to our site!</h2>
    <p>
      <%= print_information %>
    </p>
  </div>
  <div class="right column">
    <%= render :partial => "sidebar" %>
  </div>
</div>


 8.15 - Filtros
   O módulo ActionController::Filters define formas de executar código antes e depois de todas as actions.

   Para executar código antes das actions:

class ClientesController < ApplicationController
  before_filter :verifica_login

  private
  def verifica_login
    redirect_to :controller => ’login’ unless usuario_logado?
  end
end

   De forma análoga, podemos executar código no fim do tratamento da requisição:

class ClientesController < ApplicationController
  after_filter :avisa_termino

  private
  def avisa_termino
    logger.info "Action #{params[:action]} terminada"
  end
end

    Por fim, o mais poderoso de todos, que permite execução de código tanto antes, quanto depois da action a
ser executada:

class ClientesController < ApplicationController
  around_filter :envolvendo_actions

  private
  def envolvendo_actions

                                                                Capítulo 8 - Controllers e Views - Filtros - Página 117
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    logger.info "Antes de #{params[:action]}: #{Time.now}"
    yield
    logger.info "Depois de #{params[:action]}: #{Time.now}"
  end
end

   Os filtros podem também ser definidos diretamente na declaração, através de blocos:

class ClientesController < ApplicationController
  around_filter do |controller, action|
    logger.info "#{controller} antes: #{Time.now}"
    action.call
    logger.info "#{controller} depois: #{Time.now}"
  end
end

   Caso não seja necessário aplicar os filtros a todas as actions, é possível usar as opções :except e :only:

class ClientesController < ApplicationController
  before_filter :verifica_login, :only => [:create, :update]

  # ...
end


            Logger
           As configurações do log podem ser feitas através do arquivo config/environment.rb, ou especifica-
           mente para cada environment nos arquivos da pasta config/environments. Entre as configurações
           que podem ser customizadas, estão qual nível de log deve ser exibido e para onde vai o log (stdout,
           arquivos, email, ...).

           Rails::Initializer.run do |config|
             # ...
             config.log_level = :debug
             config.log_path = ’log/debug.log’
             # ...
           end
           Mais detalhes sobre a customização do log podem ser encotrados no wiki oficial do
           Rails:
           http://wiki.rubyonrails.org/rails/show/HowtoConfigureLogging




                                                                 Capítulo 8 - Controllers e Views - Filtros - Página 118
C APÍTULO     9

Rotas e Rack
                                                    “Não é possível estar dentro da civilização e fora da arte”
                                                                                                 – Rui Barbosa


   O modo como urls são ligadas a controladores e actions pode ser customizado no Rails. O módulo res-
ponsável por esta parte é o que foi criado com o seu projeto NomeDoProjeto::Application.routes e as rotas
podem ser customizadas no arquivo config/routes.rb.


 9.1 - Rack
   O rack é uma abstração das requisições e respostas HTTP da maneira mais simples possível. Criando uma
API unificada para servidores, frameworks, e softwares (os conhecidos middleware) em apenas uma chamada
de método.

    A grande motivação da criação do Rack é que, diferente do mundo java onde existe uma especificação
que abstrai todo o HTTP, no mundo ruby cada framework havia criado a sua forma de tratar as requisições e
respostas. Por isso, escrever um servidor ou mesmo permitir que o framework X pudesse rodar em um servidor
que já existisse era um trabalho realmente complicado. Graças ao surgimento do rack e da sua padronização
hoje é possível que qualquer servidor que conheça rack consiga executar qualquer aplicação que se comunique
com o HTTP através do rack.

   Mais do que isso, hoje também é possível fazer uma “aplicação” web em apenas uma linha. Exemplo:

run Proc.new {|env| [200, {"Content-Type" => "text/html"}, ["Hello World"]]}

   Basta salvar esse arquivo, por exemplo como hello.ru, e subir nosso servidor pelo Terminal com o seguinte
comando:


rackup hello.ru


   Para criar uma “aplicação” em rack tudo o que precisamos é criar um método que retorne [httpStatusCode,
headers, body], como no exemplo acima.

   O comando rackup é criado quando instalamos a gem ‘rack’ e serve para iniciar aplicações feitas em rack.
Elas nada mais são que um arquivo ruby, mas devem ser salvos com a extensão .ru (RackUp) e devem chamar
o método run.


 9.2 - Exercícios - Testando o Rack

1) Vamos fazer uma aplicação rack.


                                                    119
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   a) Crie um arquivo chamado “helloRack.ru”
   b) Adicione as seguintes linhas:

      run Proc.new {|env| [200, {"Content-Type" => "text/html"}, ["Hello World"]]}
   c) Inicie a aplicação com o comando rackup helloRack.ru
   d) Teste no browser pela url: http://localhost:9292/




 9.3 - routes.rb
   Veja abaixo como criar uma nova rota na nossa aplicação através do arquivo config/routes.rb:

VotaPrato::Application.routes.draw do
  match ’inicio’, :controller => ’restaurantes’, :action => ’index’
end

   match cria uma nova rota e tem 2 formas de ser utilizado. Na nova maneira, ele recebe um único parâmetro
que deve ser um hash, onde a chave do primerio elemento é a rota que queremos mapear, e o valor para
essa chave deve ser uma string com o nome do controlador e da action separado por um caracter ‘#’, como no
exemplo abaixo:

match ’inicio’ => ’restaurantes#index’

   Nesse exemplo o método match recebeu um hash onde a primeira chave é ‘inicio’ (rota a ser mapeada) e
o valor para essa chave é ‘restaurantes#index’, ou seja, quando acessar localhost:3000/inicio o Rails vai
executar a action index no controller restaurantes.

   A outra abordagem é usar o método match recebendo dois parâmetros:

   • url
   • hash com o conjunto de parâmetros de requisição a serem preenchidos

    No exemplo acima, para a url “localhost:3000/inicio” o método index do controlador de restaurantes
(RestaurantesController) é chamado.

                                                                  Capítulo 9 - Rotas e Rack - routes.rb - Página 120
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   Qualquer parâmetro de requisição pode ser preenchido por uma rota. Tais parâmetros podem ser recupera-
dos posteriormente através do hash de parâmetros da requisição, params[’nome’].

   Os parâmetros :controller e :action são especiais, representam o controlador e a action a serem execu-
tados.

    Uma das características mais interessantes do rails é que as urls das rotas podem ser usadas para capturar
alguns dos parâmetros:

match ’categorias/:nome’, :controller => ’categorias’, :action => ’show’

   Neste caso, o parâmetro de requisição params[’nome’] é extraído da própria url!

             Rotas padrão
            Antigamente o Rails criava uma rota padrão. Hoje em dia ela continua no arquivo config/routes.rb,
            mas vem comentada por padrão:
             match ‘:controller(/:action(/:id(.:format)))’
            Esta rota padrão que nos permitiu usar o formato de url que temos usado até agora. O nome do
            controlador e a action a ser executada são retirados da própria url chamada.


   Você pode definir quantas rotas forem necessárias. A ordem define a prioridade: rotas definidas no início
tem mais prioridade que as do fim.


 9.4 - Pretty URLs
   A funcionalidade de roteamento embutida no Rails é bastante poderosa, podendo até substituir mod_rewrite
em muitos casos. As rotas permitem uma grande flexibilidade para criação de urls que se beneficiem de técnicas
de Search Engine Optimization (SEO).

   Um exemplo interessante seria para um sistema de blog, que permitisse a exibição de posts para determi-
nado ano:

match ’blog/:ano’ => ’posts#list’

   Ou ainda para um mês específico:

match ’blog/:ano/:mes’ => ’posts#list’

   Os parâmetros capturados pela url podem ter ainda valores default:

match ’blog(/:ano)’ => ’posts#list’, :ano => 2011

   Para o último exemplo, a url ‘http://localhost:3000/blog’ faria com que a action list do controlador
PostsController fosse chamada, com o params[’ano’] sendo 2011.


 9.5 - Named Routes
   Cada uma das rotas pode ter um nome único:

match ’blog/:ano’ => ’posts#list’, :as => ’posts’

   O funcionamento é o mesmo de antes, com a diferença que usando o ‘:as’ demos um nome à rota.

    Para cada uma das Named Routes são criados automaticamente dois helpers, disponíveis tanto nos contro-
ladores quanto nas views:

                                                                  Capítulo 9 - Rotas e Rack - Pretty URLs - Página 121
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   • posts_path => ‘/blog/:ano’

   • posts_url => ‘http://localhost:3000/blog/:ano’

   A convenção para o nome dos helpers é sempre nome_da_rota_path e nome_da_rota_url.

   Você pode ainda ver o roteamento para cada uma das urls disponíveis em uma aplicação rails com a ajuda
de uma task do rake:


rake routes



 9.6 - REST - resources
   REST é um modelo arquitetural para sistemas distribuídos. A idéia básica é que existe um conjunto fixo de
operações permitidas (verbs) e as diversas aplicações se comunicam aplicando este conjunto fixo de operações
em recursos (nouns) existentes, podendo ainda pedir diversas representações destes recursos.

    A sigla REST vem de Representational State Transfer e surgiu da tese de doutorado de Roy Fielding, descre-
vendo as idéias que levaram a criação do protocolo HTTP. A web é o maior exemplo de uso de uma arquitetura
REST, onde os verbos são as operações disponíveis no protocolo (GET, POST, DELETE, PUT, HEADER, ...),
os recursos são identificados pelas URLs e as representações podem ser definidas através de Mime Types.

    Ao desenhar aplicações REST, pensamos nos recursos a serem disponibilizados pela aplicação e em seus
formatos, ao invés de pensar nas operações.

   Desde o Rails 1.2, o estilo de desenvolvimento REST para aplicações web é encorajado pelo framework,
que possui diversas facilidades para a adoção deste estilo arquitetural.

   As operações disponíveis para cada um dos recursos são:

   • GET: retorna uma representação do recurso

   • POST: criação de um novo recurso

   • PUT: altera o recurso

   • DELETE: remove o recurso

   Os quatro verbos do protocolo HTTP são comumente associados às operações de CRUD em sistemas
Restful. Há uma grande discussão dos motivos pelos quais usamos POST para criação (INSERT ) e PUT
para alteração (UPDATE). A razão principal é que o protocolo HTTP especifica que a operação PUT deve ser
idempotente, já POST não.


              Idempotência
            Operações idempotentes são operações que podem ser chamadas uma ou mais vezes, sem dife-
            renças no resultado final. Idempotência é uma propriedade das operações.


   A principal forma de suporte no Rails a estes padrões é através de rotas que seguem as convenções da
arquitetura REST. Ao mapear um recurso no routes.rb, o Rails cria automaticamente as rotas adequadas no
controlador para tratar as operações disponíveis no recurso (GET, POST, PUT e DELETE).

                                                             Capítulo 9 - Rotas e Rack - REST - resources - Página 122
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




# routes.rb
resources :restaurantes

   Ao mapear o recurso :restaurantes, o rails automaticamente cria as seguintes rotas:

   • GET /restaurantes
     :controller => ‘restaurantes’, :action => ‘index’

   • POST /restaurantes
     :controller => ‘restaurantes’, :action => ‘create’

   • GET /restaurantes/new
     :controller => ‘restaurantes’, :action => ‘new’

   • GET /restaurantes/:id
     :controller => ‘restaurantes’, :action => ‘show’

   • PUT /restaurantes/:id
     :controller => ‘restaurantes’, :action => ‘update’

   • DELETE /restaurantes/:id
     :controller => ‘restaurantes’, :action => ‘destroy’

   • GET /restaurantes/:id/edit
     :controller => ‘restaurantes’, :action => ‘edit’

   Como é possível perceber através das rotas, todo recurso mapeado implica em sete métodos no controlador
associado. São as famosas sete actions REST dos controladores rails.

   Além disso, para cada rota criada, são criados os helpers associados, já que as rotas são na verdade Named
Routes.

restaurantes_path             # => "/restaurantes"
new_restaurante_path          # => "/restaurantes/new"
edit_restaurante_path(3)      # => "/restaurantes/3/edit"

    Rails vem com um generator pronto para a criação de novos recursos. O controlador (com as sete actions), o
modelo, a migration, os esqueleto dos testes (unitário, funcional e fixtures) e a rota podem ser automaticamente
criados.


rails generate resource comentario


   O gerador de scaffolds do Rails 2.0 em diante, também usa o modelo REST:


rails generate scaffold comentario conteudo:text author:string


    Na geração do scaffold são produzidos os mesmos artefatos de antes, com a adição das views e de um
layout padrão.

   Não deixe de verificar as rotas criadas e seus nomes (Named Routes):

                                                             Capítulo 9 - Rotas e Rack - REST - resources - Página 123
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




rake routes



 9.7 - Actions extras em Resources
    As sete actions disponíveis para cada resource costumam ser suficientes na maioria dos casos. Antes de
colocar alguma action extra nos seus resources, exercite a possibilidade de criar um novo resource para tal.

   Quando necessário, você pode incluir algumas actions extras para os resources:

resources :comentarios do
  member do
    post :desabilita
  end
# url: /comentarios/:id/desabilita, named_route: desabilita_comentario_path
end

  :member define actions que atuam sobre um recurso específico: /comentarios/1/desabilita. Dentro do bloco
member usar dessa forma method :action, onde method pode ser get, post, put, delete ou any.

   Outro bloco que pode ser usado dentro de um resource é o collection que serve para definir actions extras
que atuem sobre o conjunto inteiro de resources. Definirá rotas do tipo /comentarios/action.

resources :comentarios do
  collection do
    get :feed
  end
# url: /comentarios/feed, named_route: feed_comentarios_path
end

   Para todas as actions extras, são criadas Named Routes adequadas. Use o rake routes como referência
para conferir os nomes dados às rotas criadas.


 9.8 - Diversas Representações
   Um controlador pode ter diversos resultados. Em outras palavras, controladores podem responder de diver-
sas maneiras, através do método respond_to:

class MeuController < ApplicationController
  def list
    respond_to do |format|
      format.html
      format.js do
        render :update do |page|
          page.insert_html :top, ’div3’, "Novo conteudo"
        end
      end
      format.xml
    end
  end
def

   O convenção para o nome da view de resultado é sempre:

                                                   Capítulo 9 - Rotas e Rack - Actions extras em Resources - Página 124
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   app/views/:controller/:action.:format.:handler

   Os handlers disponíveis por padrão no Rails são: erb, builder, rhtml, rxml e rjs. Os formatos instalados por
padrão ficam na constante Mime::SET e você pode instalar outros pelo arquivo ‘config/initializers/mime_types.rb’.


 9.9 - Para Saber Mais - Nested Resources
   Quando há relacionamentos entre resources, podemos aninhar a definição das rotas, que o rails cria auto-
maticamente as urls adequadas.

   No nosso exemplo, :restaurante has_many :qualificacoes, portanto:

# routes.rb
resources :restaurantes do
  resources :qualificacoes
end

   A rota acima automaticamente cria as rotas para qualificações específicas de um restaurante:

   • GET /restaurante/:restaurante_id/qualificacoes
     :controller => ‘qualificacoes’, :action => ‘index’

   • GET /restaurante/:restaurante_id/qualificacoes/:id
     :controller => ‘qualificacoes’, :action => ‘show’

   • GET /restaurante/:restaurante_id/qualificacoes/new
     :controller => ‘qualificacoes’, :action => ‘new’

   • ...

   As sete rotas comuns são criadas para o recurso :qualificacao, mas agora as rotas de :qualificacoes
são sempre específicas a um :restaurante (todos os métodos recebem o params[’restaurante_id’]).


 9.10 - Rails e o Rack
    A partir do Rails 3, quando criamos uma nova aplicação, um dos arquivos que ele cria é config.ru na raiz do
projeto e, mais que isso, podemos afirmar que toda aplicação Rails 3 é uma applicação rack. Prova disso é que
conseguimos iniciar a aplicação através do comando rackup config.ru




                                               Capítulo 9 - Rotas e Rack - Para Saber Mais - Nested Resources - Página 125
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




  Outro ponto interessante sobre o rack e o Rails, é que agora é possível mapear uma aplicação rack direta-
mente em uma rota de uma aplicação rails.

# routes.rb
  match ’rack’,
  :to => proc{|env| [200, {"Content-Type" => "text/html"}, ["App Rack numa rota Rails"]]}




                                                              Capítulo 9 - Rotas e Rack - Rails e o Rack - Página 126
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 9.11 - Exercícios - Criando um rota para uma aplicação Rack

1) Vamos fazer uma aplicação rack.

  a) Abra o arquivo “routes.rb”
  b) Adicione a seguinte linha:

     match ’rack’,
      :to => proc{|env| [200, {"Content-Type" => "text/html"}, ["App Rack numa rota Rails"]]}
   c) Inicie a aplicação com o comando rails server
  d) Teste no browser pela url: http://localhost:3000/rack




                              Capítulo 9 - Rotas e Rack - Exercícios - Criando um rota para uma aplicação Rack - Página 127
C APÍTULO   10

Completando o Sistema
                                                                  “O êxito parece doce a quem não o alcança”
                                                                                            – Dickinson, Emily


 10.1 - Um pouco mais sobre o Scaffold
    Vimos que quando usamos o gerador scaffold o Rails cria os arquivos necessários em todas as cama-
das. Controller, Model, Views e até mesmo arquivos de testes e a Migration. Para concluir nossos projeto
precisamos criar apenas Controller + Views pois tanto o modelo quanto as migrations já estão prontos. Para
isso vamo usar o mesmo gerador scaffold mas vamos passar os parâmetros: --migration=false para ele igno-
rar a criação da migration e o parâmetro -s que é a abreviação para --skip que faz com que o rails “pule” os
arquivos já existentes.

   Para concluir os modelos que já começamos vamos executar o gerador da seguinte manera: rails generate
scaffold cliente nome:string idade:integer --migration=false -s


             Outros paramêtros nos geradores
            Para conhecer todas as opções de parâmetros que um gerador pode receber tente executá-lo pas-
            sando o parâmetro -h Ex. rails generate scaffold -h


 10.2 - Exercícios

1) Vamos gerar os outros controllers e views usando o scaffold:

   a) Primeiro vamos gerar o scaffold para cliente
   b) Va ao Terminal
   c) Execute: rails generate scaffold cliente nome:string idade:integer --migration=false -s




                                                     128
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




d) Agora vamos gerar para qualificacao.
e) Execute: rails generate scaffold qualificacao cliente_id:integer restaurante_id:integer nota:float
   valor_gasto:float --migration=false -s




f) Olhe as views criadas (app/views/clientes e app/views/qualificacoes)




                                                   Capítulo 10 - Completando o Sistema - Exercícios - Página 129
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




g) Olhe as rotas criadas (config/routes.rb)




h) Abra os arquivos app/views/clientes/index.html.erb e app/views/restaurantes/index.html.erb e apa-
   gue as linhas que chamam a action destroy Lembre-se de que não queremos inconsistências na nossa
   tabela de qualificações
i) Reinicie o servidor
j) Teste: http://localhost:3000/clientes e http://localhost:3000/qualificacoes

Note que precisamos utilizar a opção “--migration=false” no comando scaffold, além de informar manu-
almente os atributos utilizados em nossas migrations. Isso foi necessário, pois já tinhamos um migration

                                                     Capítulo 10 - Completando o Sistema - Exercícios - Página 130
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   pronto, e queríamos que o Rails gerasse os formulários das views para nós, e para isso ele precisaria
   conhecer os atributos que queríamos utilizar.



             css scaffold
           O comando scaffold, quando executado, gera um css mais bonito para nossa aplicação. Se quiser
           utilizá-lo, edite nosso layout (app/views/layouts/application.html.erb) e adicione a seguinte linha
           logo abaixo da tag <title>:
           <%= stylesheet_link_tag ‘scaffold’ %>

2) Vamos agora incluir Helpers no nosso Layout, para poder navegar entre Restaurante, Cliente e Qualificação
   sem precisarmos digitar a url:

   a) Abra o Helper “applications": “app/helpers/application_helper.rb”
   b) Digite o seguinte método:

      def menu_principal
        menu = %w(cliente qualificacao restaurante)
        menu_principal = "<ul>"
        menu.each do |item|
          menu_principal << "<li>" + link_to(item, :controller => item.pluralize) + "</li>"
        end
        menu_principal << "</ul>"
        raw menu_principal
      end




   c) Adicione     a    chamada      ao     método      <%=menu_principal %>              no      nosso        layout
      (app/views/layouts/application.html.erb), ficando desse jeito:

      ...
      <body>
        <%= menu_principal %>

        <p style="color: green"><%= flash[:notice] %></p>

        <%= yield %>
      </body>
      ...

                                                         Capítulo 10 - Completando o Sistema - Exercícios - Página 131
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   d) Teste: http://localhost:3000/restaurantes


 10.3 - Selecionando Clientes e Restaurante no form de Qualificações
   Você já deve ter reparado que nossa view de adição e edição de qualificações está um tanto quanto estranha:
precisamos digitar os IDs do cliente e do restaurante manualmente.

    Para corrigir isso, podemos utilizar o FormHelper select, inserindo o seguinte código nas nossas views de
adição e edição de qualificações:

<%= select(’qualificacao’, ’cliente_id’,
    Cliente.order(:nome).collect
    {|p| [ p.nome, p.id]}) %>

   em substituição ao:

<%= f.text_field :cliente_id %>

   Mas existe um outro FormHelper mais elegante, que produz o mesmo efeito, o collection_select:

<%= collection_select(:qualificacao, :cliente_id,
    Cliente.order(:nome),
    :id, :nome, {:prompt => true}) %>

   Como estamos dentro de um form_for, podemos usar do fato de que o formulário sabe qual o nosso Active-
Record, e com isso fazer apenas:

<%= f.collection_select(:cliente_id,
    Cliente.order(:nome),
    :id, :nome, {:prompt => true}) %>




               Capítulo 10 - Completando o Sistema - Selecionando Clientes e Restaurante no form de Qualificações - Página 132
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 10.4 - Exercícios

1) Vamos utilizar o FormHelper collection_select para exibirmos o nome dos clientes e restaurantes nas
   nossas views da qualificação:

   a) Abra o arquivo app/views/qualificacoes/_form.html.erb
   b) Troque a linha:

      <%= f.text_field :cliente_id %>
      por:

      <%= f.collection_select(:cliente_id,
          Cliente.order(’nome’),
          :id, :nome, {:prompt => true}) %>
   c) Troque a linha:

      <%= f.text_field :restaurante_id %>
      por:

      <%= f.collection_select(:restaurante_id,
          Restaurante.order(’nome’),
          :id, :nome, {:prompt => true}) %>




   d) Teste: http://localhost:3000/qualificacoes

2) Agora vamos exibir o nome dos restaurantes e clientes nas views index e show de qualificações:

                                                       Capítulo 10 - Completando o Sistema - Exercícios - Página 133
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




a) Abra o arquivo app/views/qualificacoes/show.html.erb
b) Troque a linha:

   <%= @qualificacao.cliente_id %>
   por:

   <%= @qualificacao.cliente.nome %>
c) Troque a linha:

   <%= @qualificacao.restaurante_id %>
   por:

   <%= @qualificacao.restaurante.nome %>




d) Abra o arquivo app/views/qualificacoes/index.html.erb

                                                  Capítulo 10 - Completando o Sistema - Exercícios - Página 134
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   e) Troque as linhas:

      <td><%= qualificacao.cliente_id %></td>
      <td><%= qualificacao.restaurante_id %></td>
      por:

      <td><%= qualificacao.cliente.nome %></td>
      <td><%= qualificacao.restaurante.nome %></td>




   f) Teste: http://localhost:3000/qualificacoes

3) Por fim, vamos utilizar o FormHelper hidden_field para permitir a qualificação de um restaurante a partir da
   view show de um cliente ou de um restaurante. No entanto, ao fazer isso, queremos que não seja necessário
   a escolha de cliente ou restaurante. Para isso:

   a) Abra o arquivo app/views/qualificacoes/_form.html.erb
   b) Troque as linhas

      <p>
        <%= f.label :cliente_id %><br />
        <%= f.collection_select(:cliente_id,
            Cliente.order(’nome’),
            :id, :nome, {:prompt => true}) %>
      </p>
      por:

      <% if @qualificacao.cliente %>

                                                        Capítulo 10 - Completando o Sistema - Exercícios - Página 135
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




     <%= f.hidden_field ’cliente_id’ %>
   <% else %>
     <p><%= f.label :cliente_id %><br />
     <%= f.collection_select(:cliente_id,
         Cliente.order(’nome’),
         :id, :nome, {:prompt => true}) %></p>
   <% end %>
c) Troque as linhas

   <p>
     <%= f.label :restaurante_id %><br />
     <%= f.collection_select(:restaurante_id,
         Restaurante.order(’nome’),
         :id, :nome, {:prompt => true}) %>
   </p>
   por:

   <% if @qualificacao.restaurante %>
     <%= f.hidden_field ’restaurante_id’ %>
   <% else %>
     <p><%= f.label :restaurante_id %><br />
     <%= f.collection_select(:restaurante_id,
         Restaurante.order(’nome’),
         :id, :nome, {:prompt => true}) %></p>
   <% end %>




d) Adicione a seguinte linha na view show do cliente (app/views/clientes/show.html.erb):

   <%= link_to "Nova qualificação", :controller => "qualificacoes",
                                    :action => "new",
                                    :cliente => @cliente %>




                                                     Capítulo 10 - Completando o Sistema - Exercícios - Página 136
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




e) Adicione a seguinte linha na view show do restaurante (app/views/restaurantes/show.html.erb):

   <%= link_to "Qualificar este restaurante", :controller => "qualificacoes",
                                              :action => "new",
                                              :restaurante => @restaurante %>




                                                    Capítulo 10 - Completando o Sistema - Exercícios - Página 137
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




f) Por fim, precisamos fazer com que o controlador da action new das qualificações receba os parâmetros
   para preenchimento automático. Abra o controller app/controllers/qualificacoes_controller.rb
g) Adicione as seguintes linhas à nossa action new:

   if params[:cliente]
     @qualificacao.cliente = Cliente.find(params[:cliente])
   end
   if params[:restaurante]
     @qualificacao.restaurante = Restaurante.find(params[:restaurante])
   end




                                                      Capítulo 10 - Completando o Sistema - Exercícios - Página 138
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   h) Teste: http://localhost:3000/clientes, entre na página Show de um cliente e faça uma nova qualifi-
      cação.


 10.5 - Exercícios Opcionais

1) Crie um método no nosso Application Helper para converter um número para valor monetário:

   a) Abra o arquivo app/helpers/application_helper.rb
   b) Adicione o seguinte método:

      def valor_formatado(number)
        number_to_currency(number, :unit => "R$", :separator => ",", :delimiter => ".")
      end


                                               Capítulo 10 - Completando o Sistema - Exercícios Opcionais - Página 139
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   c) Em app/views/qualificacoes/index.html.erb e app/views/qualificacoes/show.html.erb, troque o se-
      guinte código:

      @qualificacao.valor_gasto
      por:

      valor_formatado(@qualificacao.valor_gasto)


 10.6 - Mais sobre os controllers
   Podemos notar que nossas actions, por exemplo a index, fica muito parecida com a action index de outros
controladores, mudando apenas o nome do modelo em questão.

#qualificacoes_controller
def index
  @qualificacoes = Qualificacao.all

  respond_to do |format|
    format.html # index.html.erb
    format.xml { render :xml => @qualificacoes }
  end
end

#clientes_controller
def index
  @clientes = Cliente.all

  respond_to do |format|
    format.html # index.html.erb
    format.xml { render :xml => @clientes }
  end
end

    Normalmente precisamos fazer exatamente a mesma ação para formatos iguais e por isso acabamos repe-
tindo o mesmo bloco de respond_to nas actions. Para solucionar esse problema, no rails 3 acrescentaram o
método respond_to nos controllers e o método respond_with nas actions. Veja o exemplo:

class ClientesController < ApplicationController

  respond_to :html, :xml

  # GET /clientes
  # GET /clientes.xml
  def index
    @clientes = Cliente.all

    respond_with @clientes
  end

  # GET /clientes/1
  # GET /clientes/1.xml

                                            Capítulo 10 - Completando o Sistema - Mais sobre os controllers - Página 140
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




  def show
    @cliente = Cliente.find(params[:id])

    respond_with @cliente
  end
  ...
end

    Dessa forma estamos dizendo para o rails que esse controller irá responder para os formatos html e xml,
dentro da action basta eu dizer qual objeto é pra ser usado. No caso da action index, se a requisição pedir
o formato html, o rails simplesmente irá enviar a chamada para o arquivo views/clientes/index.html.erb e a
variável @clientes estará disponível lá. Se a requisição pedir o formato xml, o rails fará exatamente o mesmo
que estava no bloco de respond_to que o scaffold criou, irá renderizar a variável @clientes em xml. O bloco de
código acima é equivalente ao gerado pelo scaffold:

class ClientesController < ApplicationController
  # GET /clientes
  # GET /clientes.xml
  def index
    @clientes = Cliente.all

    respond_to do |format|
      format.html # index.html.erb
      format.xml { render :xml => @clientes }
    end
  end

  # GET /clientes/1
  # GET /clientes/1.xml
  def show
    @cliente = Cliente.find(params[:id])

    respond_to do |format|
      format.html # show.html.erb
      format.xml { render :xml => @cliente }
    end
  end
   ...
end

   Veja na imagem como ficaria o ClientesController usando essa outra maneira de configurar os controllers.




                                             Capítulo 10 - Completando o Sistema - Mais sobre os controllers - Página 141
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




                 Capítulo 10 - Completando o Sistema - Mais sobre os controllers - Página 142
C APÍTULO   11

Calculations
                                          “Ao examinarmos os erros de um homem conhecemos o seu caráter”
                                                                                – Chamfort, Sébastien Roch


   Nesse capítulo, você aprenderá a utilizar campos para calcular fórmulas como, por exemplo, a média de um
campo.


 11.1 - Métodos
    Uma vez que existem os campos valor gasto e nota, seria interessante disponibilizar para os visitantes do
site a média de cada um desses campos para determinado restaurante.

   Em Rails esse recurso é chamado calculations, métodos dos nossos modelos que fazem operações mais
comuns com campos numéricos como, por exemplo:

   • average(column_name, options = {}) - média

   • maximum(column_name, options = {}) - maior valor

   • minimum(column_name, options = {}) - menor valor

   • sum(column_name, options = {}) - soma

   • count(*args) - número de entradas


 11.2 - Média
  Supondo que o cliente pediu para adicionar a nota média de um restaurante na tela com as informações do
mesmo (show). Basta adicionar uma chamada ao método average das qualificações do nosso restaurante:

<b>Nota média: </b><%= @restaurante.qualificacoes.average(:nota) %><br/>

   Podemos mostrar também o número total de qualificações que determinado restaurante possui:

<b>Qualificações: </b><%= @restaurante.qualificacoes.count %><br/>

   E, por último, fica fácil adicionar o valor médio gasto pelos clientes que visitam tal restaurante:

<b>Preço médio: </b><%= @restaurante.qualificacoes.average(:valor_gasto) %><br/>




                                                       143
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 11.3 - Exercícios

1) Altere a view show de restaurante para mostrar sua nota média, quantas qualificações possui e preço médio:

   a) Insira as seguintes linhas em app/views/restaurantes/show.html.erb:

      <b>Nota média: </b><%= @restaurante.qualificacoes.average(:nota) %><br/>
      <b>Qualificações: </b><%= @restaurante.qualificacoes.count %><br/>
      <b>Preço médio: </b><%= @restaurante.qualificacoes.average(:valor_gasto) %><br/><br/>




   b) Entre no link http://localhost:3000/restaurantes e escolha um restaurante para ver suas estatísti-
      cas.




                                                                  Capítulo 11 - Calculations - Exercícios - Página 144
C APÍTULO   12

Associações Polimórficas
                                                                     “Os negócios são o dinheiro dos outros”
                                                                                          – Alexandre Dumas


   Nesse capítulo você verá como criar uma relação muitos-para-muitos para mais de um tipo de modelo.


 12.1 - Nosso problema
   O cliente pede para a equipe de desenvolvedores criar uma funcionalidade que permita aos visitantes deixar
comentários sobre suas visitas aos restaurantes.

   Para complicar a vida do programador, o cliente pede para permitir comentários também em qualificações,
permitindo aos usuários do site justificar a nota que deram.

    Esse problema poderia ser resolvido de diversas maneiras sendo que trabalharemos em cima de um modelo
para representar um comentário, relacionado com restaurantes e qualificações, aproveitando para mostrar como
realizar tal tipo de relacionamento.

   Seria simples se pudéssemos criar mais uma tabela com o comentário em si e o id da entidade relacionada.
O problema surge no momento de diferenciar um comentário sobre qualificação de um sobre restaurante.

   Para diferenciar os comentários de restaurantes e qualificações, podemos usar um atributo de nome “tipo”.

   Em Ruby podemos criar apelidos para um ou mais modelos, algo similar a diversas classes implementarem
determinada interface (sem métodos) em java. Podemos chamar nossos modelos Restaurante e Qualificacao
como comentáveis, por exemplo.

   Um exemplo dessa estrutura em Java é o caso de Serializable – interface que não obriga a implementação
de nenhum método mas serve para marcar classes como serializáveis, sendo que diversas classes da api
padrão do Java implementam a primeira.

   No caso do Ruby, começamos criando um modelo chamado Comentario.


 12.2 - Alterando o banco de dados
   O conteúdo do script de migração criará as colunas “comentário”, “id de quem tem o comentário”, e o “tipo”.

  Nos campos id e tipo, colocamos o nome da coluna com o apelido seguido de _id e _type, respectiva-
mente, notificando o Ruby que ele deve buscar tais dados daquilo que é “comentavel”.

    Note que no português a palavra “comentavel” soa estranho e parece esquisito trabalhar com ela, mas para
seguir o padrão definido no inglês em diversas linguagens, tal apelido indica o que os modelos são capazes de
fazer e, no caso, eles são “comentáveis”.


                                                    145
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   O script deve então criar três colunas, sem nada de novo comparado com o que vimos até agora:


rails generate scaffold comentario 
      conteudo:text comentavel_id:integer comentavel_type:string


   Caso seja necessário, podemos ainda adicionar índices físicos nas colunas do relacionamento, deixando a
migration criada como a seguir:

class CreateComentarios < ActiveRecord::Migration
  def self.up
    create_table :comentarios do |t|
      t.text :conteudo
      t.integer :comentavel_id
      t.string :comentavel_type

      t.timestamps
    end

    add_index :comentarios, :comentavel_type
    add_index :comentarios, :comentavel_id
  end

  def self.down
    drop_table :comentarios
  end
end

   Para trabalhar nos modelos, precisamos antes gerar a nova tabela necessária:


rake db:migrate


   O modelo Comentario (app/models/comentario.rb) deve poder ser associado a qualquer objeto do grupo de
modelos comentáveis. Qualquer objeto poderá fazer o papel de comentavel, por isso dizemos que a associação
é polimórfica:

class Comentario < ActiveRecord::Base
  belongs_to :comentavel, :polymorphic => true
end

   A instrução :polymorphic indica a não existência de um modelo com o nome :comentavel.

   Falta agora comentar que uma qualificação e um restaurante terão diversos comentários, fazendo o papel
de algo comentavel. Para isso usaremos o relacionamento has_many:

class Qualificacao < ActiveRecord::Base
  belongs_to :cliente
  belongs_to :restaurante

  has_many :comentarios, :as => :comentavel



                                        Capítulo 12 - Associações Polimórficas - Alterando o banco de dados - Página 146
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




  # ...
end

   E o Restaurante:

class Restaurante < ActiveRecord::Base
  has_many :qualificacoes

  has_many :comentarios, :as => :comentavel

  # ...
end

   A tradução do texto pode ser quase literal: o modelo TEM MUITOS comentários COMO comentável.


 12.3 - Exercícios

1) Vamos criar o modelo do nosso comentário e fazer a migração para o banco de dados:

   a) Va ao Terminal
   b) Digite: rails generate scaffold comentario conteudo:text comentavel_id:integer comenta-
      vel_type:string




   c) Vamos inserir alguns índices físicos. Abra o arquivo db/migrate/<timestamp>_create_comentarios.rb
   d) Insira as seguintes linhas:

      add_index :comentarios, :comentavel_type
      add_index :comentarios, :comentavel_id




                                                       Capítulo 12 - Associações Polimórficas - Exercícios - Página 147
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




  e) Volte ao Terminal para executar a migration
   f) Execute: rake db:migrate

2) Vamos modificar nossos modelos:

  a) Abra o arquivo app/models/comentario.rb
  b) Adicione a seguinte linha:

     belongs_to :comentavel, :polymorphic => true




  c) Abra o arquivo app/models/qualificacao.rb


                                                     Capítulo 12 - Associações Polimórficas - Exercícios - Página 148
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




d) Adicione a seguinte linha:

   has_many :comentarios, :as => :comentavel




e) Abra o arquivo app/models/restaurante.rb
f) Adicione a seguinte linha:

   has_many :comentarios, :as => :comentavel




                                                   Capítulo 12 - Associações Polimórficas - Exercícios - Página 149
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




3) Para o próximo capítulo, iremos precisar que o nosso sistema já inclua alguns comentários. Para criá-los,
   você pode usar o rails console ou ir em http://localhost:3000/comentarios e adicionar um comentá-
   rio qualquer para o “Comentavel” 1, por exemplo, e o tipo “Restaurante”. Isso criará um comentário para o
   restaurante de ID 1.




                                                       Capítulo 12 - Associações Polimórficas - Exercícios - Página 150
C APÍTULO   13

Ajax com Rails
                                                                                   “O Cliente tem sempre razão”
                                                                                                   – Selfridge, H.


   Nesse capítulo, você verá como trabalhar com AJAX de maneira não obstrusiva no Rails.


 13.1 - Adicionando comentários nas views
    Até agora trabalhamos com arquivos html.erb, que são páginas html com scripts em ruby, mas nada de
javascript.

    Como o Ruby on Rails é um framework voltado para o desenvolvimento web, é natural que a questão do
javascript seja levantada. O Rails, antes da versão 3, tentava facilitar o desenvolvimento de código javascript
com recursos como o RJS Templates, que produzia código javascript a partir de código Ruby. Contudo, o
código gerado era acoplado ao Prototype, o que dificultava o uso de outras bibliotecas poulares como o JQuery.
No Rails 3 optou-se por uma nova forma, não obstrutiva, de se trabalhar com javascript, permintindo que os
desenvolvedores tenham controle absoluto do código criado, e podendo, inclusive, escolher a biblioteca que
será usada (Prototype, JQuery, Moo-tools ou qual quer outra, desde que um driver exista para essa biblioteca).


 13.2 - Instalando manualmente o JQuery no projeto
    Para instalar o JQuery, a única coisa que precisa ser feita é colocar o arquivo do JQuery que você pode
baixar direto do site oficial do projeto e o ‘driver’ para o Rails que pode ser baixado em http://github.com/rails/
jquery-ujs. Pegue esses 2 arquivos e coloque no public/javascript/ do seu projeto para que o Rails possa
encontrá-los. Outro passo importante é remover os arquivos do Prototype que o Rails insere automaticamente
durante a criação dos projetos, para que não ocorram conflitos.




                                                       151
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   Copiados os arquivos, precisamos fazer com que o Rails importe esses arquivos nas nos-
sas páginas.     A maneira mais fácil de fazer isso é alterar nosso application layout, no arquivo
app/views/layout/application.html.erb , para que sejam incluídos todos os arquivos de javascript. Para tanto,
basta mudar a linha do javascript_include_tag para :all, como no exemplo abaixo:

<%= javascript_include_tag ’jquery’, ’rails’ %>




                                    Capítulo 13 - Ajax com Rails - Instalando manualmente o JQuery no projeto - Página 152
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 13.3 - Instalando o JQuery no projeto usando a gem jquery-rails
   Abra o arquivo Gemfile e adicione a seguinte linha:

gem ’jquery-rails’, ’>= 0.2.6’

   Agora execute no terminal:


bundle install
rails generate jquery:install



 13.4 - Criando as chamadas AJAX
   Falta ainda escrever a funcionalidade de adicionar comentários aos nossos restaurantes e qualificações.
Podemos, aqui, utilizar AJAX para uma experiência mais marcante no uso do site pelos usuários.

    Nosso primeiro passo será possibilitar a inclusão da lista de comentários nas páginas de qualquer modelo
que seja comentável. Para não repetir este código em todas as páginas que aceitem comentários, podemos
isolá-lo em um helper:

def comentarios(comentavel)
  comentarios = "<div id=’comentarios’>"
  comentarios << "<h3>Comentarios</h3>"
  comentavel.comentarios.each do |comentario|
    comentarios << render(:partial => "comentarios/comentario",
                          :locals => { :comentario => comentario })
  end
  comentarios << "</div>"
  raw comentarios
end



                          Capítulo 13 - Ajax com Rails - Instalando o JQuery no projeto usando a gem jquery-rails - Página 153
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




  Podemos simplificar o código acima, utilizando a opção :collection. Dessa maneira, o partial é renderizado
uma vez para cada elemento que eu tenha no meu array:

def comentarios(comentavel)
  comentarios = "<div id=’comentarios’>"
  comentarios << "<h3>Comentarios</h3>"
  comentarios << render(:partial => "comentarios/comentario",
     :collection => comentavel.comentarios) unless comentavel.comentarios.empty?
  comentarios << "</div>"
  raw comentarios
end

   Agora, vamos criar o partial responsável pela renderização de cada um dos comentários. Repare que
usamos o método link_to passando o parâmetro :remote => true, que faz uma chamada a uma url utilizando
para isso uma requisição assíncrona (AJAX ):

<!-- /app/views/comentarios/_comentario.html.erb -->
<p id="comentario_<%= comentario.id %>">
  <%= comentario.conteudo %> -
  <%= link_to ’(remover)’, comentario,
                          :method => :delete,
                          :remote => true,
                          :id => "remove_comentario_#{comentario.id}" %>
</p>

   Além disso, precisamos invocar nosso             helper    em    app/views/restaurantes/show.html.erb             e
app/views/qualificacoes/show.html.erb:

<%= comentarios @qualificacao %>

   Tente clicar no link e verá que nada acontece, porém ao recarregar a página, o comentário foi removido!

   A ação ComentariosController#destroy está sendo chamada de forma assíncrona (Ajax), porém a página
não foi atualizada. Por isso precisamos tratar a responsta do servidor para remover o item da página.

   Para isso, primeiramente vamos alterar o app/views/layouts/application.html.erb para nos possibilitar escre-
vermos javascript no mesmo arquivo que exibe os comentários.

<!-- /app/views/layouts/application.html.erb -->
<!DOCTYPE html>
<html>
<head>
  <title>Restaurante2</title>
  <%= stylesheet_link_tag :all %>
  <%= javascript_include_tag :defaults %>
  <%= csrf_meta_tag %>
</head>
<body>
  <%= yield %>

  <script type="text/javascript">
    <%=yield :js%>
  </script>


                                                   Capítulo 13 - Ajax com Rails - Criando as chamadas AJAX - Página 154
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




</body>
</html>


            Usando o yield
           Usando o yield passando um símbolo como parâmentro podemos usar o método content_for nas
           nossas views e fazer um tipo de include inteligente nos nossos arquivos.


   Agora vamos alterar novamente o arquivo app/views/comentarios/_comentario.html.erb para colocar o ja-
vascript que será renderizado no lugar do ‘yield :js’.

<p id="comentario_<%= comentario.id %>">
  <%= comentario.conteudo()%>
  <%= link_to ’remover’, comentario,
        :method => :delete, :remote => true,
        :id => "remove_comentario_#{comentario.id}"%>
</p>

<%= content_for :js do%>
  $(’#remove_comentario_<%=comentario.id%>’).bind(
        ’ajax:success’,
        function(xhr, result){
          $(’#comentario_<%=comentario.id%>’).remove();
        }
      );
<%end%>

   Dessa forma, teremos um html gerado parecido com esse:

<div id=’comentarios’><h3><Comentarios></h3>
<p id="comentario_1">
  comentario 1
  <a href="/comentarios/1" data-method="delete" data-remote="true"
    id="remove_comentario_1" rel="nofollow">remover</a>
</p>

<p id="comentario_2">
  Comentario 2
  <a href="/comentarios/2" data-method="delete" data-remote="true"
    id="remove_comentario_2" rel="nofollow">remover</a>
</p>

<!-- Continuação do HTML -->

  <script type="text/javascript">

  $(’#remove_comentario_1’).bind(
      ’ajax:success’,
      function(xhr, result){
        $(’#comentario_1’).remove();
      }

                                                Capítulo 13 - Ajax com Rails - Criando as chamadas AJAX - Página 155
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




  );

  $(’#remove_comentario_2’).bind(
      ’ajax:success’,
      function(xhr, result){
        $(’#comentario_2’).remove();
      }
  );

  </script>
</body>

   Basta fazermos com que nossa action destroy não renderize nada , adicionando mais um formato ao bloco
respond_to:

def destroy
  @comentario = Comentario.find(params[:id])
  @comentario.destroy

  respond_to do |format|

       format.xml { head :ok }
       format.js { head :ok }
       end

  end
end


 13.5 - Exercícios

1) Vamos instalar o JQuery na nossa aplicação

   a) Adicione a linha abaixo no arquivo Gemfile

        gem ’jquery-rails’, ’>= 0.2.6’
   b) Execute o gerador do jquery-rails para instalar o jquery no projeto.

         rails generate jquery:install



   c) Abra o arquivo app/views/layout/application.html.erb e adicione o yield para javascripts no final do
      body

        <script type="text/javascript">
          <%=yield :js%>
        </script>




                                                                   Capítulo 13 - Ajax com Rails - Exercícios - Página 156
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




2) Vamos adicionar os comentários nas views.

  a) Abra o arquivo app/helpers/application_helper.rb
  b) Insira as seguintes linhas:

     def comentarios(comentavel)
       comentarios = "<h3>Comentarios</h3>"
       comentarios << "<div id=’comentarios’>"
       if comentavel.comentarios.any?
         comentarios << render(:partial => "comentarios/comentario",
                               :collection => comentavel.comentarios)
       end
       comentarios << "</div>"
       raw comentarios
     end




                                                              Capítulo 13 - Ajax com Rails - Exercícios - Página 157
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




c) Crie o arquivo app/views/comentarios/_comentario.html.erb com o seguinte conteúdo:

  <p id="comentario_<%= comentario.id %>">
    <%= comentario.conteudo %> -
    <%= link_to ’(remover)’, comentario,
          :method => :delete,
          :remote => true,
          :id => "remove_comentario_#{comentario.id}" %>
  </p>

  <%=content_for :js do%>
    $(’#remove_comentario_<%=comentario.id%>’).bind(
          ’ajax:success’,
          function(xhr, result){
            $(’#comentario_<%=comentario.id%>’).remove();
          }
    );
  <%end%>




                                                         Capítulo 13 - Ajax com Rails - Exercícios - Página 158
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




d) Altere as seguintes linhas da action destroy do controller comentarios_controller.rb

   def destroy
     @comentario = Comentario.find(params[:id])
     @comentario.destroy

     respond_to do |format|
       format.xml { head :ok }
       format.js   { head :ok }
     end
   end




e) Adicione a seguinte linha em app/views/restaurantes/show.html.erb

   <%= comentarios @restaurante %>

                                                             Capítulo 13 - Ajax com Rails - Exercícios - Página 159
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




f) Adicione a seguinte linha em app/views/qualificacoes/show.html.erb

  <%= comentarios @qualificacao %>




                                                         Capítulo 13 - Ajax com Rails - Exercícios - Página 160
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   g) Teste em http://localhost:3000/restaurantes, escolhendo um restaurante no qual você já tenha
      inserido comentários.


 13.6 - Adicionando comentários
    Para possibilitar a adição de comentários podemos adicionar um novo link logo após a lista de comentários,
criando um novo helper method no ApplicationController:

def novo_comentario(comentavel)
  comentarios = render(:partial => "comentarios/novo_comentario",
                      :locals => { :comentavel => comentavel })
  raw comentarios
end

   É necessário agora criar o novo partial. Lembre que para criar um comentário, é preciso saber o que está
sendo comentado (comentável).

<!-- /app/views/comentarios/_novo_comentario.html.erb -->
<div id=’novo_comentario’>
  <a href="javascript:$(’#novo_comentario’).children().toggle();">Novo comentario</a>
  <div id="form_comentario" style="display: none;">
    <%= form_for Comentario.new, :remote => true do |f| %>
      <%= hidden_field :comentario, :comentavel_id, :value => comentavel.id %>
      <%= hidden_field :comentario, :comentavel_type, :value => comentavel.class %>
      <div class="field">
        <%= f.label ’conteudo’ %><br />
        <%= f.text_area ’conteudo’ %>

                                                     Capítulo 13 - Ajax com Rails - Adicionando comentários - Página 161
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




      </div>
      <div class="actions">
        <%= f.submit %>
        <a href="javascript:$(’#novo_comentario’).children().toggle();">Cancelar</a>
      </div>
    <% end %>
  </div>
</div>

<%content_for :js do%>
 $(’#form_comentario’).bind(’ajax:complete’, function(xhr, result){
   $(’#comentarios’).html(result.responseText);
   $(’#form_comentario textarea’).val("")
   $(’#form_comentario’).hide();
   $(’#novo_comentario > a’).show();
 });
<%end%>


 13.7 - Exercícios

1) Vamos permitir a adição de novos comentários:

   a) Abra o arquivo app/helpers/application_helper.rb
   b) Vamos criar um novo método nesse Helper. A função desse método será renderizar um partial contendo
      o link para criação de novos comentários. Para isso, adicione o método novo_comentario na sua classe
      ApplicationHelper:

      def novo_comentario(comentavel)
          raw render(:partial => "comentarios/novo_comentario",
                            :locals => { :comentavel => comentavel })
      end




                                                              Capítulo 13 - Ajax com Rails - Exercícios - Página 162
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




c) Crie o novo partial app/views/comentarios/_novo_comentario.html.erb com o seguinte conteúdo:

  <div id=’novo_comentario’>
    <a href="#" onclick="$(’#novo_comentario’).children().toggle();">Novo comentario</a>
    <div id="form_comentario" style="display: none;">
      <%= form_for Comentario.new, :remote => true do |f| %>
        <%= hidden_field :comentario, :comentavel_id, :value => comentavel.id %>
        <%= hidden_field :comentario, :comentavel_type, :value => comentavel.class %>
        <div class="field">
          <%= f.label ’conteudo’ %><br />
          <%= f.text_area ’conteudo’ %>
        </div>
        <div class="actions">
          <%= f.submit %>
          <a href="#" onclick="$(’#novo_comentario’).children().toggle();">Cancelar</a>
        </div>
      <% end %>
    </div>
  </div>

  <%content_for :js do%>
   $(’#form_comentario’).bind(’ajax:complete’, function(xhr, result){
     $(’#comentarios’).html(result.responseText);
     $(’#form_comentario textarea’).val("")
     $(’#form_comentario’).hide();
     $(’#novo_comentario > a’).show();
   });
  <%end%>




                                                         Capítulo 13 - Ajax com Rails - Exercícios - Página 163
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




d) O link deverá ser colocado após a verificação da existência de comentários para mostrar a lista dos
   comentários, para isso, abra o arquivo app/views/restaurantes/show.html.erb e abaixo do unless que
   faz a verificação adicione a chamada para o seu novo Helper :

   <% unless @restaurante.comentarios.empty?%>
       <%= comentarios @restaurante %>
   <% end %>

   <%= novo_comentario(@restaurante) %>
e) Faça o mesmo para o arquivo app/views/qualificacoes/show.html.erb.
f) Para finalizar o processo temos que alterar o nosso controller para exibir a lista de comentários do nosso
   comentável. Altere o método create no app/controllers/comentarios_controller.rb

   if @comentario.save
     format.xml { render :xml => @comentario, :status => :created, :location => @comentario }
     format.js {}
   else
g) E agora crie o arquivo views/comentarios/create.js.erb

   <%= render(:partial => "comentarios/comentario",
              :collection => @comentario.comentavel.comentarios) %>
h) Para que nosso partial exiba corretamente os javascripts precisamos criar um layout para colocar o bloco
   de yield dos javascripts.
i) Crie o arquivo app/views/layouts/application.js.erb com o seguinte conteúdo

   <%= yield %>

   <script type="text/javascript">

                                                              Capítulo 13 - Ajax com Rails - Exercícios - Página 164
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    <%=yield :js%>
  </script>
j) Agora já é possível cadastrar um comentário direto do show dos comentáveis




                                                           Capítulo 13 - Ajax com Rails - Exercícios - Página 165
C APÍTULO   14

Alguns Plugins e Gems Importantes
                                                   “A minoria pode ter razão, a maioria está sempre errada”
                                                                             – Mikhail Aleksandrovitch Bakunin


 14.1 - Paginação
   O uso do plugin will_paginate sempre foi recomendado ao invés da forma clássica de paginação embutida
no Rails 1.2.

   No Rails 2.0, a paginação foi removida para o plugin classic_pagination e agora você deve escolher qual
usar.

    Hoje o will_paginate é um gem. Para poder usá-lo nas suas aplicações Rails, abra o arquivo Gemfile e
adicione a seguinte linha:


gem install will_paginate


   A documentação pode ser encontrada no wiki hospedado no github.com:

   http://github.com/mislav/will_paginate/wikis
   Após a instalação do gem, para usá-lo em uma aplicação Rails, basta inserir no final do arquivo Gemfile:

gem "will_paginate"

   Para trazer os dados paginados, basta usar o método paginate, no lugar de find:

@restaurantes = Restaurante.all.paginate :page => params[’page’]

   O método paginate funciona como um finder normal. Suporta todas as opções previamente vistas, como
:conditions, :order e :include.

   O número de items por página é padronizado em 30, mas você pode customizar de duas formas. Através
do método per_page nas classes ActiveRecord::Base:

class Restaurante < ActiveRecord::Base
  def self.per_page
    10
  end
  # ...
end

   Ou passando como parâmetro ao método paginate:

@restaurantes = Restaurante.all.paginate :page => params[’page’], :per_page => 10

                                                   166
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   O gem fornece ainda um helper para inclusão dos links de paginação em qualquer view:

# index.html.erb
<% @restaurantes.each do |restaurante| %>
  <li><%= restaurante.nome %></li>
<% end %>
<%= will_paginate @restaurantes %>

   Alguns exemplos de estilos (css) alternativos para a paginação podem ser encontrados em:

   http://mislav.caboo.se/static/will_paginate/


 14.2 - Exercícios - Título

1) Adicione o will_paginate ao seu projeto, no arquivo Gemfile

   gem ’will_paginate’



   Execute o seguinte comando no terminal para instalar a gem

   bundle install



2) Abra o arquivo app/controllers/restaurantes_controller.rb. Na action list, troque a linha:

   @restaurantes = Restaurante.order("nome")
   por

   @restaurantes = Restaurante.order("nome").paginate :page=> params[’page’], :per_page=>3

3) Abra o arquivo app/views/restaurantes/index.html.erb. Adicione a linha abaixo após a tabela:

   <%= will_paginate @restaurantes %>

4) Abra a listagem de restaurantes e verifique a paginação.


 14.3 - Hpricot
    HPricot é uma biblioteca poderosa para manipulação de xhtml. Bastante útil para capturar conteúdo da
internet que não tenha sido criado pensando em integração e não oferece formatos mais adequados para
serem consumidos por outros sistemas, como json ou xml.


gem install hpricot


   open-uri é uma biblioteca que usaremos para fazer requisições http:

doc = Hpricot(open(’http://twitter.com/guilhermecaelum’))
    Analisando o html gerado pelo twitter, vemos que as mensagens estão sempre dentro de elementos com a
classe "hentry

                                          Capítulo 14 - Alguns Plugins e Gems Importantes - Exercícios - Título - Página 167
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   . Além disso, dentro de cada hentry, a única parte que nos interessa é o conteúdo dos subitems de classe
"entry-content

   .

    Podemos procurar estes itens com o Hpricot, usando seletores CSS. Expressões XPath também poderiam
ser usadas:

doc / ".hentry .entry-content"

   Para imprimir cada um dos itens de uma maneira mais interessante:

items = doc / ".hentry .entry-content"
items.each do |item|
  puts item.inner_text
end


 14.4 - Exercícios - Testando o Hpricot

1) Vamos fazer um leitor de twitties de um determinado usuário

   a) Crie um arquivo chamado “twitter_reader.rb”
   b) Adicione ás seguintes linhas:

       require ’rubygems’
       require ’hpricot’
       require ’open-uri’

       doc = Hpricot(open(’http://twitter.com/paulo_caelum’))
       items = doc / ".hentry .entry-content"
       items.each do |item|
         puts item.inner_text
       end
   c) Teste usando o comando ruby twitter_reader.rb


 14.5 - File Uploads: Paperclip
   Podemos fazer upload de arquivos sem a necessidade de plugins adicionais, utilizando algo como o código
abaixo:

File.open("public/"+path, "nome") { |f| f.write(params[:upload][’picture_path’].read) }

    O código acima recebe o binário do arquivo e faz o upload para a pasta public. Porém, ao fazer um upload
seria interessante fazer coisas como redimensionar a imagem, gerar thumbs, associar com models ActiveRe-
cord, etc.

   Um dos primeiros plugins rails voltados para isso foi o attachment_fu. Hoje em dia o plugin mais indicado
é o Paperclip. O Paperclip tem como finalidade ser um plugin de fácil uso com o modelos Active Record.
As configurações são simples e é possível validar tamanho do arquivo ou tornar sua presença obrigatória. O
paperclip tem como pré-requisito o ImageMagick,



                               Capítulo 14 - Alguns Plugins e Gems Importantes - Exercícios - Testando o Hpricot - Página 168
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 14.6 - Exercícios

1) Para instalar o paperclip, abra o arquivo Gemfile e adicione a gem:

   gem ’paperclip’
   E no terminal, rode :

   bundle install



2) Adicione o has_attached_file do paperclip na classe Restaurante. Vamos configurar mais uma opção que
   daremos o nome de styles. Toda vez que a view chamar a foto do restaurante com essa opção, o Rail
   buscará pelo thumb.

   class Restaurante < ActiveRecord::Base
     has_attached_file :foto, :styles => { :medium => "300x300>", :thumb => "100x100>" }
   end

             Economizando espaço em disco
            É boa prática ao configurar os tamanhos das imagens que armazenaremos, sobrescrever o tama-
            nho do estilo “original”, dessa maneira evitamos que o Paperclip salve imagens muito maiores do
            que utilizaremos em nossa aplicação.

            has_attached_file :foto, :styles => { :medium => "300x300>",
                                                  :thumb => "100x100>",
                                                  :original => "800x600>" }
            No exemplo acima, a imagem “original” será salva com tamanho máximo de 800x600 pixels,
            isso evita que armazenemos desnecessariamente em nossa aplicação, por exemplo, imagens
            de 4000x3000 pixels, tamanho resultante de uma foto tirada em uma máquina fotográfica
            digital de 12MP.


3) Precisamos de uma migration que defina novas colunas para a foto do restaurante na tabela de restaurantes.
   O paperclip define 4 colunas básicas para nome, conteúdo, tamanho do arquivo e data de update.
   Crie a migration AddFotoColumnsToRestaurante abaixo na pasta db/migrate:

   class AddAttachmentFotoToRestaurante < ActiveRecord::Migration
     def self.up
       add_column :restaurantes, :foto_file_name, :string
       add_column :restaurantes, :foto_content_type, :string
       add_column :restaurantes, :foto_file_size, :integer
       add_column :restaurantes, :foto_updated_at, :datetime
     end

     def self.down
       remove_column       :restaurantes,   :foto_file_name
       remove_column       :restaurantes,   :foto_content_type
       remove_column       :restaurantes,   :foto_file_size
       remove_column       :restaurantes,   :foto_updated_at
     end
   end

                                                  Capítulo 14 - Alguns Plugins e Gems Importantes - Exercícios - Página 169
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




             Geradores do Paperclip
           Você também pode usar o generator do próprio Paperclipe: rails generate paperclip Restaurante
           foto


   Rode a migration no terminal com:

   rake db:migrate



4) Abra a view app/views/restaurantes/new.html.erb e altere o formulário. Seu form deve ficar como o abaixo:

   <%= form_for :restaurantes, :url => {:action=>’create’},
                               :html => {:multipart=>true} do |f| %>
     <!--outros campos-->
     <%= f.file_field :foto %>
   <% end %>

5) Abra a view app/views/restaurantes/show.html.erb e adicione:

   <p>
     <b>Foto:</b>
       <%= image_tag @restaurante.foto.url(:thumb) %>
   </p>
   Repare que aqui chamamos o thumb, que foi configurado como um dos styles do model. Suba o server e
   insira um novo restaurante com foto.




                                              Capítulo 14 - Alguns Plugins e Gems Importantes - Exercícios - Página 170
C APÍTULO   15

Testes
                                                  “Ninguém testa a profundidade de um rio com os dois pés.”
                                                                                         – Provérbio Africano


 15.1 - O Porquê dos testes?
    Testes de Unidade são classes que o programador desenvolve para se certificar que partes do seu sistema
estão funcionando corretamente.

    Eles podem testar validações, processamento, domínios etc, mas lembre-se que um teste unitário deve
testar somente um pedaço de código (de onde veio o nome unitário).

   Criar esse tipo de testes é uma das partes mais importantes do desenvolvimento de uma aplicação pois
possibilita a verificação real de todas as partes do programa automaticamente.


             Extreme Programming (XP)
           Extreme Programming é um conjunto de práticas de programação que visam a simplicidade, pratici-
           dade, qualidade e flexibilidade de seu sistema. Os testes de unidade fazem parte dessa metodogia
           de programação.


   O Ruby já possui classes que nos auxiliam no desenvolvimento destes testes.


 15.2 - Test::Unit
   Test::Unit é a biblioteca usada para escrever suas classes de teste.

   Ao escrever testes em Ruby utilizando esse framework, você deve herdar a classe TestCase que provê a
funcionalidade necessária para fazer os testes.

require ’test/unit’

  class PessoaTest < Test::Unit::TestCase
    # ...
end

   Ao herdar TestUnit TestCase, você ganha alguns métodos que irão auxiliar os seus testes:

   • assert(boolean, msg=nil)

   • assert_equal(esperado, atual, msg=nil)

   • assert_not_equal(esperado, atual, msg=nil)

                                                    171
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   • assert_in_delta(esperado, atual, delta, msg=nil)

   • assert_instance_of(classe, objeto, msg=nil)

   • assert_kind_of(classe, objeto, msg=nil)

   • assert_match(regex, texto, msg=nil)

   • assert_no_match(regex, texto, msg=nil)

   • assert_nil(objeto, msg=nil)

   • assert_not_nil(objeto, msg=nil)

   • assert_respond_to(objeto, metodo, msg=nil)

   • assert_same(esperado, atual, msg=nil)

   • assert_not_same(esperado, atual, msg=nil)

   O método assert simples recebe como parâmetro qualquer expressão que devolva um valor booleano e
todos os métodos assert recebem opcionalmente como último argumento uma mensagem que será exibida
caso a asserção falhe.

    Mais detalhes e outros métodos assert podem ser encontrados na documentação do módulo
TestTestUnit Assertions, na documentação da biblioteca core da linguagem Ruby (http://ruby-doc.org/
core/).
   Os testes podem ser executados em linha de comando, bastando chamar ruby o_que_eu_quero_testar.rb.
O resultado é um “.” para os testes que passarem, “E” para erros em tempo de execução e “F” para testes
que falharem.

   Também é possível executar todos os testes com algumas tasks do rake:


rake   test               #   roda   todos   os   testes   de   unidade, de integração e funcionais
rake   test:units         #   roda   todos   os   testes   da   pasta test/unit
rake   test:functionals   #   roda   todos   os   testes   da   pasta test/functional
rake   test:integration   #   roda   todos   os   testes   da   pasta test/integration
rake   test:plugins       #   roda   todos   os   testes   de   plugins, na pasta vendor/plugins


    Existem ainda outras tarefas disponíveis para o rake. Sempre podemos consultá-las com rake -T, no dire-
tório do projeto.

   Podemos criar uma classe de teste que só possua um único “assert true”, no diretório test/unit/.

class MeuTeste < Test::Unit::TestCase
    def test_truth
        assert true
    end
end

   Ao escrever testes de unidade em projetos Ruby On Rails, ao invés de herdar diretamente de
TestUnit TestCase, temos a opção de herdar da classe fornecida pelo ActiveSupport do Rails:



                                                                           Capítulo 15 - Testes - Test::Unit - Página 172
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




require ’test_helper’

class RestauranteTest < ActiveSupport::TestCase
  def test_anything
    assert true
  end
end

   Além disso, todos os testes em projetos Rails devem carregar o arquivo test_helper.rb, disponível em
qualquer projeto gerado pelo Rails. As coisas comuns a todos os testes, como método utilitários e configurações,
ficam neste arquivo.

   A vantagem de herdar de ActiveSupport::TestCase ao invés da original é que o Rails provê diversas funci-
onalidades extras aos testes, como fixtures e métodos assert extras. Alguns dos asserts extras:

   • assert_difference

   • assert_no_difference

   • assert_valid(record) - disponível em testes de unidade

   • assert_redirected_to(path) - para testes de controladores

   • assert_template(esperado) - também para controladores

   • entre outros

 15.3 - Exercícios - Teste do modelo

1) Vamos testar nosso modelo restaurante. Para isso precisamos utilizar o banco de dados específico para
   testes.

   rake db:create:all
   rake db:migrate RAILS_ENV=test

2) O Rails já tem suporte inicial para testes automatizados. Nossa aplicação já possui arquivos importantes
   para nossos testes. Abra o arquivo test/fixtures/restaurantes.yml. Esse arquivo simula os dados de um
   restaurante. Crie os dois restaurantes abaixo. Importante: Cuidado com a identação!

   fazano:
     nome: Fazano
     endereco: Rua Vergueiro

   fogo_de_chao:
     nome: Fogo de Chao
     endereco: Avenida dos Bandeirantes

3) O arquivo de teste do modelo está em test/unit/restaurante_test.rb. Obs: Verifique se o require na primeira
   linha está correto.

   require ’test/test_helper’



                                                         Capítulo 15 - Testes - Exercícios - Teste do modelo - Página 173
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




     class RestauranteTest < ActiveSupport::TestCase
       fixtures :restaurantes

           def test_restaurante

             restaurante_fazano = Restaurante.new :nome => restaurantes(:fazano).nome,
                                  :endereco => restaurantes(:fazano).endereco

             assert restaurante_fazano.save

             restaurante_fazano_copia = Restaurante.find(restaurante_fazano.id)

             assert_equal restaurante_fazano.nome, restaurante_fazano_copia.nome

             restaurante_fazano.nome = "Fazano"

             assert restaurante_fazano.save
             assert restaurante_fazano.destroy
           end
     end

4) Para rodar o teste, vá na raiz do projeto pelo terminal e digite:

   ruby test/unit/restaurante_test.rb
   Verifique se tudo está certo:

   Loaded suite test/unit/restaurante_test
   Started
   .
   Finished in 0.044991 seconds.

   1 tests, 4 assertions, 0 failures, 0 errors


 15.4 - Exercícios - Teste do controller

1) Para testar o controller de restaurantes vamos criar uma nova action chamada busca. Essa action direciona
   para o restaurante buscado caso encontre ou devolve uma mensagem de erro caso contrário. Abra o arquivo
   app/controllers/restaurantes_controller.rb e adicione a action busca:

   def busca
     @restaurante = Restaurante.find_by_nome(params[:nome])
     if @restaurante
       redirect_to :action => ’show’, :id => @restaurante.id
     else
       flash[:notice] = ’Restaurante não encontrado.’
       redirect_to :action => ’list’
     end
   end

2) Abra o arquivo test/functional/restaurantes_controller_test.rb.

                                                          Capítulo 15 - Testes - Exercícios - Teste do controller - Página 174
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   require ’test/test_helper’

   class RestaurantesControllerTest < ActionController::TestCase
     fixtures :restaurantes
       def setup
         @controller = RestaurantesController.new
         @request    = ActionController::TestRequest.new
         @response   = ActionController::TestResponse.new
       end

       def test_procura_restaurante
         get :busca, :nome => ’Fazano’
         assert_not_nil assigns(:restaurante)
         assert_equal restaurantes(:fazano).nome, assigns(:restaurante).nome
         assert_redirected_to :action => ’show’
       end

      def test_procura_restaurante_nao_encontra
         get :busca, :nome => ’Botequin’
         assert_redirected_to :action => ’list’
         assert_equal ’Restaurante não encontrado.’, flash[:notice]
       end
   end
   Verifique se tudo está certo;

   Loaded suite test/functional/restaurantes_controller_test
   Started
   ..
   Finished in 0.206066 seconds.

   2 tests, 4 assertions, 0 failures, 0 errors

3) Rode o teste no terminal com ruby test/functional/restaurantes_controller_test.rb.


 15.5 - RSpec
   Muito mais do que uma nova forma de criar testes de unidade, RSpec fornece uma forma de criar especifi-
cações executáveis do seu código.

   No TDD, descrevemos a funcionalidade esperada para nosso código através de testes de unidade. BDD
(Behavior Driven Development) leva isso ao extremo e diz que nossos testes de unidade devem se tornar
especificações executáveis do código. Ao escrever as especificações estaremos pensando no comportamento
esperado para nosso código.


             Introdução ao BDD
            Uma ótima descrição sobre o termo pode ser encontrada no site do seu próprio criador: Dan North.
            http://dannorth.net/introducing-bdd/




                                                                         Capítulo 15 - Testes - RSpec - Página 175
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    RSpec fornece uma DSL (Domain Specific Language) para criação de especificações executáveis de código.
As especificações do RSpec funcionam como exemplos de uso do código, que validam se o código está mesmo
fazendo o que deveria e funcionam como documentação.
      http://rspec.info
      Para instalar o rspec e usar em qualquer programa Ruby, basta instalar o gem:

gem install rspec


    Para usar em aplicações Rails, precisamos instalar mais um gem que dá suporte ao rspec ao Rails. Além
disso, precisamos usar o gerador que vem junto desta gem, para adicionar os arquivos necessários nos projetos
que forem usar rspec:

cd projeto-rails
rails generate rspec:install


   O último comando também adiciona algumas tasks do rake para executar as specs do projeto, além de criar
a estrutura de pastas e adicionar os arquivos necessários.

rake spec         # executa todas as specs do projeto
rake -T spec      # para ver as tasks relacionadas ao rspec


   O rspec-rails também pode ser instalado como plugin, porém hoje é altamente recomendado seu uso como
gem. Mais detalhes podem ser encontrados na documentação oficial
      http://wiki.github.com/rspec/rspec-rails/
   RSpec é compatível com testes feitos para rodar com Test::Unit. Desta forma, é possível migrar de forma
gradativa. Apesar disso, a sintaxe oferecida pelo RSpec se mostra bem mais interessante, já que segue as idéias
do Behavior Driven Development e faz com que os testes se tornem especificações executáveis do código:
describe Restaurante, " com nome" do
  it "should have name"
    Restaurante.all.should_not be_empty
    Restaurante.first.should_not be_nil
    Restaurante.first.name.should == "Fasano"
  end
end
      A classe de teste vira um Example Group (describe). Cada método de teste vira um Example (it “should
...

      ).
   Além disso, os métodos assert tradicionais do Test::Unit viram uma chamada de should. O RSpec adici-
ona a todos os objetos os métodos should e should_not, que servem para validarmos alguma condição sobre
o estado dos nossos objetos de uma forma mais legível e expressiva que com asserts.
    Como argumento para o método should, devemos passar uma instância de Matcher que verifica uma con-
dição particular. O RSpec é extremamente poderoso, pois nos permite escrever nossos próprios Matchers.
Apesar disso, já vem com muitos prontos, que costumam ser mais do que suficientes:

                                                                            Capítulo 15 - Testes - RSpec - Página 176
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   • be_<nome> para métodos na forma <nome>?.

     objeto.should be_empty         # testa: objeto.empty?
     objeto.should_not be_nil       # testa: not objeto.nil?

     objeto.should be_kind_of(Restaurante)       # testa: objeto.kind_of(Restaurante)
     Além de be_<nome>, tambem podemos usar be_a_<nome> ou be_an_<nome>, aumentando a legibili-
     dade.

   • be_true, be_false, eql, equal, exist, include:

     objeto.should be_true
     objeto.should_not be_false

     objeto.should eql(outro)   # testa: objeto.eql?(outro)
     objeto.should equal(outro) # testa: objeto.equal?(outro)

     objeto.should exist # testa: objeto.exist?
     [4,5,3].should include(3) # testa: [4,5,3].include?(3)

   • have_<nome> para métodos na forma has_<nome>?.

     itens = { :um => 1, :dois => ’2’ }
     itens.should have_key(:dois)     # testa: itens.has_key?(:dois)
     itens.should_not have_value(/3/) # testa: not itens.has_value?(/3/)

   • be_close, inclui tolerância.

     conta = 10.0 / 3.0
     conta.should be_close(3.3, 0.1) # == 3.3 `.1

   • have(num).<colecao>, para testar a quantidade de itens em uma associação.

     categoria.should have(15).produtos       # testa categoria.produtos.size == 15
     Um uso especial deste matcher é para objetos que já são coleções. Neste caso, podemos usar o nome
     que quisermos:

     array = [1,2,3]
     array.should have(3).items         # testa array.size == 3
     array.should have(3).numbers       # mesma coisa

   • have_at_least(num).<colecao>: mesma coisa que o anterior, porém usa >=.

   • have_at_most(num).<colecao>: mesma coisa que o anterior, porém usa <=.

   • match, para expressões regulares.

     texto.should match(/^F/)       # verifica se começa com F


   Este são os principais, mas ainda existem outros. Você pode encontrar a lista de Matchers completa na
documentação do módulo Spec::Matchers:




                                                                        Capítulo 15 - Testes - RSpec - Página 177
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




Exemplos pendentes

   Um exemplo pode estar vazio. Desta forma, o RSpec o indicará como pendente:

describe Restaurante do
  it "should have endereco"
end

    Isto facilita muito o ciclo do BDD, onde escrevemos o teste primeiro, antes do código de verdade. Podemos
ir pensando nas funcionalidades que o sistema deve ter e deixá-las pendentes, antes mesmo de escrever o
código. Em outras palavras, começamos especificando o que será escrito.


Before e After

    Podemos definir algum comportamento comum para ser executado antes ou depois de cada um dos exem-
plos, como o setup e o teardown do Test::Unit:

describe Restaurante do
  before do
    @a_ser_testado = Restaurante.new
  end

  it "should ..."

  after do
    fecha_e_apaga_tudo
  end
end

   Estes métodos podem ainda receber um argumento dizendo se devem ser executados novamente para cada
exemplo (:each) ou uma vez só para o grupo todo (:all):

describe Restaurante do
  before(:all) do
    @a_ser_testado = Restaurante.new
  end

  it "should ..."

  after(:each) do
    fecha_e_apaga_tudo
  end
end


 15.6 - Cucumber, o novo Story Runner
    RSpec funciona muito bem para especificações em níveis próximos ao código, como as especificações
unitárias.

   User Stories é uma ferramenta indicada para especificações em níveis mais altos, como funcionalidades de
negócio, ou requisitos. Seu uso está sendo bastante difundido pela comunidade Rails. User Stories costumam

                                                     Capítulo 15 - Testes - Cucumber, o novo Story Runner - Página 178
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




ter o seguinte formato:


In order to <benefício>
As a <interessado>
I want to <funcionalidade>.


    Cucumber é uma excelente biblioteca escrita em Ruby, que serve para tornar especificações como esta,
na forma de User Stories, escritas em texto puro, executáveis. Cucumber permite a associação de código Ruby
arbitrário, usualmente código de teste com RSpec, a cada um dos passos desta descrição da funcionalidade.

      Para instalar tudo o que é necessário:


gem install cucumber capybara database_cleaner

gem   ’database_cleaner’
gem   ’cucumber-rails’
gem   ’cucumber’
gem   ’rspec-rails’
gem   ’spork’
gem   ’launchy’


    Para projetos rails, é possível usar o generator fornecido pelo Cucumber para adicionar os arquivos neces-
sários ao projeto:


cd projetorails
rails generate cucumber:install


    As User Stories são chamadas de Features pelo Cucumber. São arquivos de texto puro com a extensão
.feature. Arquivos com definição de features sempre contém uma descrição da funcionalidade (Story) e alguns
exemplos (Scenarios), na seguinte estrutura:


Feature: <nome da story>
  In order to <beneficio>
  As a <interessado>
  I want to <funcionalidade>

  Scenario: <nome do exemplo>
    Given <pré condições>
    And   <mais pré condições>
    When <ação>
    And   <mais ação>
    Then <resultado>
    And   <mais resultado>

  Scenario: <outro exemplo>
    Given ...
    When ...


                                                       Capítulo 15 - Testes - Cucumber, o novo Story Runner - Página 179
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    Then ...


    Antigamente, o RSpec incluia sua própria implementação de Story Runner, que hoje está sendo substituída
pelo Cucumber. O RSpec Story Runner original utilizava um outro formato para features, mais tradicional, que
não dá prioridade ao Return Of Investment. O benefício da funcionalidade fica em segundo plano, no final da
descrição:


Story: transfer from savings to checking account
  As a savings account holder
  I want to transfer money from my savings account to my checking account
  So that I can get cash easily from an ATM

  Scenario: ...


   O importante para o Cucumber são os exemplos (Scenarios) que explicam a funcionalidade. Cada um dos
Scenarios contém um conjunto de passos, que podem ser do tipo Given (pré-requisitos), When (ações), ou
Then (resultado).

   A implementação de cada um dos passos (steps) dos scenarios devem ficar dentro do diretório
step_definitions/, na mesma pasta onde se encontram os arquivos .feature, texto puro.

    O nome destes arquivos que contém a definição de cada um dos passos deve terminar com _steps.rb.
Cada passo é representado na chamada dos métodos Given, Then ou When, que recebem como argumento uma
String ou expressão regular batendo com o que estiver escrito no arquivo de texto puro (.feature).

   Tipicamente, os projetos contém um diretório features/, com a seguinte estrutura:


projeto/
|-- features/
|   |-- minha.feature
|   |-- step_definitions/
|   |   |-- alguns_steps.rb
|   |   ‘-- outros_steps.rb
|   ‘-- support/
|       ‘-- env.rb


   O arquivo support/env.rb é especial do Cucumber e sempre é carregado antes da execução dos testes.
Geralmente contém a configuração necessária para os testes serem executados e código de suporte aos testes,
como preparação do Selenium ou Webrat.

   Os arquivos com definições dos passos são arquivos Ruby:

Given "alguma condicao descrita no arquivo texto puro" do
  # codigo a ser executado para este passo
end

Given /e outra condicao com valor: (.*)/ do |valor|
  # codigo de teste para esse passo
end


                                                     Capítulo 15 - Testes - Cucumber, o novo Story Runner - Página 180
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




When /alguma acao/
  # ...
end

Then /verifica resultado/
  # ...
end

    O código de teste para cada passo pode ser qualquer código Ruby. É comum o uso do RSpec para verificar
condições (métodos should) e Webrat ou Selenium para controlar testes de aceitação. Mais detalhes sobre
estes frameworks para testes de aceitação podem ser vistos no capítulo “Outros testes e specs”.

    Não é necessário haver um arquivo com definição de passos para cada arquivo de feature texto puro. Isto é
até considerado má prática por muitos, já que inibe o reuso para definições de steps.




                                                     Capítulo 15 - Testes - Cucumber, o novo Story Runner - Página 181
C APÍTULO   16

Apêndice B - Integrando Java e Ruby
                                                           “Não há poder. Há um abuso do poder nada mais”
                                                                                        – Montherlant, Henri


   Nesse capítulo você aprenderá a acessar código escrito anteriormente em Java através de scripts escritos
em Ruby: o projeto JRuby.


 16.1 - O Projeto
   JRuby (http://www.jruby.org/) é uma implementação de um interpretador Ruby escrito totalmente em java,
e mais ainda, com total integração com a Virtual Machine.

   Além de ser open-source, ele disponibiliza a integração entre as bibliotecas das duas linguagens.

   Atualmente há algumas limitações como, por exemplo, não é possível herdar de uma classe abstrata. O
suporte a Ruby on Rails também não está completo.

   Os líderes desse projeto open source já trabalharam na Sun, o que permitiu termos uma implementação
muito rápida e de boa qualidade.


 16.2 - Testando o JRuby
   Vamos criar um script que imprima um simples “Testando o JRuby” na tela do seu console:

print "Testando o JRuby!n"

    Pode parecer muito simples, mas a grande diferença é que agora quem estará realmente rodando é uma
Virtual Machine Java! Não há mais a necessidade de instalar o ruby na máquina, apenas a JVM e algumas
bibliotecas do JRuby! Isto pode ajudar muito na adoção da linguagem.

   Agora se executarmos tanto com os comandos “ruby” ou “jruby” o resultado será o mesmo:


 16.3 - Exercícios

1) Crie um arquivo chamado testando.rb que imprime na tela “Testando o JRuby!":

   a) Edite o arquivo: testando.rb.
   b) Adicione o seguinte conteúdo:

      print "Testando o JRuby!n"



                                                    182
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   c) Rode o arquivo com o JRuby:

       jruby testando.rb




 16.4 - Compilando ruby para .class com Jruby
     Existe a possibilidade de compilarmos o arquivo .rb para um .class através do JRuby. Para isso devemos
utilizar o jrubyc(JRuby Compiler) de modo muito semelhante ao javac:


jrubyc <path do arquivo .rb>


   Vamos criar um arquivo ola_mundo_jruby.rb:

# ola_mundo_jruby.rb
puts ’Ola Mundo com JRuby!’

   Agora vamos compilar esse arquivo:


jrubyc ola_mundo_jruby.rb


    Após isso, o arquivo ola_mundo_jruby.class já foi criado na mesma pasta do arquivo ola_mundo_jruby.rb e
nós podemos utiliza-lo apartir de outro arquivo .rb através do require, porém esse .class é diferente do que o
javac cria apartir do .java, sendo assim é impossível roda-lo direto na JVM como rodamos outra classe qualquer
do java.


 16.5 - Rodando o .class do ruby na JVM
    Como foi dito anteriormente, não é possível executar diretamente na JVM um arquivo compilado pelo jruby,
isso acontece pelas características dinâmicas do ruby que tornam necessário a utilização de um jar. Tal jar pode
ser baixada no site do Jruby(http://jruby.org/download).

     Com o .jar em mãos, é fácil executar um bytecode do jruby na JVM, simplesmente devemos utilizar a opção
“-jar” da seguinte maneira:


java -jar <path do arquivo .jar> <path do arquivo .class>


   Lembrando que é necessário que a extensão do arquivo(.class) esteja explícita.

  Vamos copiar o arquivo .jar do jruby para a pasta onde o ola_mundo_jruby.class está e rodar o nosso olá
mundo:


java -jar jruby.jar ola_mundo_jruby.class


   Após isso veremos nosso “Ola Mundo com JRuby!”.



                       Capítulo 16 - Apêndice B - Integrando Java e Ruby - Compilando ruby para .class com Jruby - Página 183
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 16.6 - Importando um bytecode(.class) criado pelo jruby
   Para importar um bytecode que foi criado a partir de um arquivo .rb utilizamos o conhecido require.

require ’<path do bytecode>’

   Obs.: Lembre-se de retirar a extensão do arquivo (.class), o certo seria fazer algo como:

require ’app/funcionario’

   e não:

# desta maneira o arquivo não será encontrado
require ’app/funcionario.class’


 16.7 - Importando classes do Java para sua aplicação JRuby
    Para importar classes Java utilizamos o método java_import, porém devemos ter o cuidado de antes requerer
a biblioteca que tem esse método.

    Vamos criar uma classe Pessoa em Java, e importar ela para dentro do JRuby. Primeiramente criaremos a
classe Pessoa no java:

// Pessoa.java
        public class Pessoa {
            private String nome;

             public Pessoa(String meuNome) {
                 this.nome = meuNome;
             }

             public void setNome(String novoNome) {
                 this.nome = novoNome;
             }

             public String getNome(){
                 return this.nome;
             }

             public void seMostra(){
                 System.out.println(this.getNome());
             }
        }


   Agora iremos compilar o código fonte com o javac utilizando:


javac Pessoa.java


    Teremos então o arquivo Pessoa.class. Vamos criar um arquivo testando_jruby.rb onde iremos testar essa
classe:

# testando_jruby.rb
        require ’java’ # o java_import faz parte desta biblioteca

               Capítulo 16 - Apêndice B - Integrando Java e Ruby - Importando um bytecode(.class) criado pelo jruby - Página 184
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




        java_import ’Pessoa’

        pessoa = Pessoa.new ’Hugo Roque’
        pessoa.se_mostra # Observe que o nome do método no código Java é
                         # seMostra, porém o JRuby faz um alias para
                         # todos os métodos passando-os de Camelcase para
                         # Underscore case.
                         # Obs.: o método seMostra ainda existe.

        pessoa.nome = ’Nico Steppat’ #     Observe que ao criarmos um setter
                                     #     para o nome(setNome), o JRuby criou
                                     #     o método nome= automaticamente.
                                     #     Obs.: Os métodos setNome e set_nome
                                     #     continuam existindo.

        puts pessoa.nome #   Observe que ao criarmos um getter
                         #   para o nome(getNome), o JRuby criou
                         #   o método nome automaticamente
                         #   Obs.: Os métodos getNome e get_nome
                         #   continuam existindo.

   Ao executarmos o exemplo acima, teremos como saida:


Hugo Roque
Nico Steppat


   Lembrando que para executar este exemplo basta utilizar


jruby testando_jruby.rb



 16.8 - Testando o JRuby com Swing
   Agora vamos integrar nossso “Testando o JRuby” com um pouco de Java, criando uma janela. Instanciamos
um objeto Java em JRuby usando a notação:

require ’java’

module Swing
  include_package ’java.awt’
  include_package ’javax.swing’
end

module AwtEvent
  include_package ’java.awt.event’
end

# Reparem que não é necessário herdar nem
# implementar nada, apenas definir o metodo


                             Capítulo 16 - Apêndice B - Integrando Java e Ruby - Testando o JRuby com Swing - Página 185
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




# com o nome que o java exige (duck typing)
class ListenerDoBotao
  def action_performed(evento)
    Swing::JOptionPane.showMessageDialog(nil, "ActionListener feito em ruby")
  end
end

frame = Swing::JFrame.new
painel = Swing::JPanel.new
frame.add painel

label = Swing::JLabel.new
label.text = "Testando o JRuby!" # label.setText("Testando o JRuby!")
painel.add label

botao = Swing::JButton.new ’clique aqui’
botao.add_action_listener ListenerDoBotao.new
painel.add botao

frame.pack
frame.set_size(400, 400)
frame.visible = true

    O include_package é parecido com um import, e depois estamos criando uma instância de JFrame. Dessa
mesma maneira você pode acessar qualquer outra classe da biblioteca do Java. Assim você tem toda a expres-
sividade e poder do Ruby, somado a quantidade enorme de bibliotecas do Java.


             Para saber mais: Suporte a closure com JRuby
           O JRuby permite a passagem de blocos de código como argumento para metodos do java que re-
           cebem como parâmetro uma interface que define apenas um método, assim como o futuro suporte
           a closures prometido para o Java 8. No exemplo acima poderíamos ter passado o ActionListener
           para o botão sem necessidade de escrever uma classe só para isso, e nem mesmo seria preciso
           instanciar um objeto, fazendo desta forma:

           botao.add_action_listener do |evento|
               Swing::JOptionPane.showMessageDialog(nil, "ActionListener em closure")
           end




                              Capítulo 16 - Apêndice B - Integrando Java e Ruby - Testando o JRuby com Swing - Página 186
C APÍTULO   17

Apêndice C - Deployment
                        “Há noites que eu não posso dormir de remorso por tudo o que eu deixei de cometer.”
                                                                                           – Mario Quintana


    Como construir ambientes de produção e deployment para aplicações Rails sempre foram alguns dos maio-
res desafios desta plataforma. Existem diversos detalhes a serem considerados e diversas opções disponíveis.


 17.1 - Webrick
    A forma mais simples de executar aplicações rails é usar o servidor que vem embutido em todas estas
aplicações: Webrick.

   É um servidor web muito simples, escrito em Ruby, que pode ser iniciado através do arquivo script/server,
dentro do projeto:


cd projetorails
rails server


   Por padrão, o Webrick inicia na porta 3000, porém isto pode ser mudado com a opção -p:


rails server -p 3002


   Por ser muito simples, não é recomendado o uso do webrick em produção.


 17.2 - CGI
    Uma das primeiras alternativas de deployment para aplicações Rails foi o uso de servidores web famo-
sos, como o Apache Httpd. Porém, como o httpd só serve conteúdo estático, precisar delegar as requisições
dinâmicas para processos Ruby que rodam o Rails, através do protocolo CGI.

    Durante muito tempo, esta foi inclusive uma das formas mais comuns de servir conteúdo dinâmico na inter-
net, com linguagens como Perl, PHP, C, entre outras.

   O grande problema no uso do CGI, é que o servidor Web inicia um novo processo Ruby a cada requisição
que chega. Processos são recursos caros para o sistema operacional e iniciar um novo processo a cada
requisição acaba limitando bastante o tempo de resposta das requisições.




                                                    187
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




 17.3 - FCGI - FastCGI
    Para resolver o principal problema do CGI, surgiu o FastCGI. A grande diferença é que os processos que
tratam requisições dinâmicas (workers) são iniciados junto ao processo principal do servidor Web.

    Desta forma, não é mais necessário iniciar um novo processo a cada requisição, pois já foram iniciados. Os
processos ficam disponíveis para todas as requisições, e cada nova requisição que chega usa um dos processos
existentes.

             Pool de processos
            O conjunto de processos disponíveis para tratar requisições dinâmicas também é popularmente
            conhecido como pool do processos.


    A implementação de FCGI para aplicações Rails, com o apache Httpd nunca foi satisfatória. Diversos bugs
traziam muita instabilidade para as aplicações que optavam esta alternativa.

   Infelizmente, FCGI nunca chegou a ser uma opção viável para aplicações Rails.


 17.4 - Lighttpd e Litespeed
   Implementações parecidas com Fast CGI para outros servidores Web pareceram ser a solução para o
problema de colocar aplicações Rails em produção. Duas alternativas ficaram famosas.

    Uma delas é a implementação de Fast CGI e/ou SCGI do servidor web Lighttpd. É um servidor web escrito
em C, bastante performático e muito leve. Muitos reportaram problemas de instabilidade ao usar o Lighttpd em
aplicações com grandes cargas de requisições.

    Litespeed é uma outra boa alternativa, usado por aplicações Rails em produção até hoje. Usa o proto-
colo proprietário conhecido como LSAPI. Por ser um produto pago, não foi amplamente difundido dentro da
comunidade de desenvolvedores Rails.

   http://www.litespeedtech.com/ruby-lsapi-module.html


 17.5 - Mongrel
  Paralelamente às alternativas que usam FCGI (e variações) através de servidores Web existentes, surgiu
uma alternativa feita em Ruby para rodar aplicações Rails.

   Mongrel é um servidor web escrito por Zed Shaw, em Ruby. É bastante performático e foi feito especifica-
mente para servir aplicações Rails. Por esses motivos, ele rapidamente se tornou a principal alternativa para
deployment destas aplicações. Hoje suporta outros tipos de aplicações web em Ruby.


 17.6 - Proxies Reversos
   O problema com o Mongrel é que uma instância do Rails não pode servir mais de uma requisição ao mesmo
tempo. Em outras palavras, o Rails não é thread-safe. Possui um lock que não permite a execução de seu
código apenas por uma thread de cada vez.

   Por causa disso, para cada requisição simultânea que precisamos tratar, é necessário um novo processo
Mongrel. O problema é que cada Mongrel roda em uma porta diferente. Não podemos fazer os usuários terem
de se preocupar em qual porta deverá ser feita a requisição.

                                                    Capítulo 17 - Apêndice C - Deployment - FCGI - FastCGI - Página 188
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   Por isto, é comum adicionar um balanceador de carga na frente de todos os Mongrels. É o balanceador
que recebe as requisições, geralmente na porta 80, e despacha para as instâncias de Mongrel.

    Como todas as requisições passam pelo balanceador, ele pode manipular o conteúdo delas, por exemplo
adicionando informações de cache nos cabeçalhos HTTP. Neste caso, quando faz mais do que apenas distribuir
as requisições, o balanceador passa a ser conhecido como Proxy Reverso.


             Reverso?
            Proxy é o nó de rede por onde passam todas as conexões que saem. O nome Proxy Reverso vem
            da idéia de que todas as conexões que entram passam por ele.


   O principal ponto negativo no uso de vários Mongrels é o processo de deployment. A cada nova versão,
precisariamos instalar a aplicação em cada um dos Mongrels e reinicar todos eles.

   Para facilitar o controle (start, stop, restart) de vários Mongrels simultâneamente, existe o projeto mon-
grel_cluster.


 17.7 - Phusion Passenger (mod_rails)
   Ninh Bui, Hongli Lai e Tinco Andringa da empresa Phusion decidiram tentar novamente criar um módulo
para rodar aplicações Rails usando o Apache Httpd.

   Phusion Passenger, também conhecido como mod_rails, é um módulo para o Apache Httpd que adiciona
suporte a aplicações Web escritas em Ruby. Uma de suas grandes vantagens é usar o protocolo Rack para
enviar as requisições a processos Ruby.

    Como o Rack foi criado especificamente para projetos Web em Ruby, praticamente todos os frameworks
web Ruby suportam este protocolo, incluindo o Ruby on Rails, o Merb e o Sinatra. Só por serem baseados no
protocolo Rack, são suportados pelo Passenger.

   A outra grande vantagem do mod_rails é a facilidade de deployment. Uma vez que o módulo esteja instalado
no Apache Httpd, bastam três linhas de configuração no arquivo httpd.conf:


<VirtualHost *:80>
    ServerName www.aplicacao.com.br
    DocumentRoot /webapps/aplicacoes/projetorails
</VirtualHost>


   A partir daí, fazer deployment da aplicação Rails consiste apenas em copiar o código para a pasta configu-
rada no Apache Httpd. O mod_rails detecta que é uma aplicação Rails automaticamente e cuida do resto.

   A documentação do Passenger é uma ótima referência:

   http://www.modrails.com/documentation/Users%20guide.html


 17.8 - Ruby Enterprise Edition
    Além do trabalho no mod_rails, os desenvolvedores da Phusion fizeram algumas modificações importantes
no interpretador MRI. As mudanças podem trazer redução de até 30% no uso de memória em aplicações Rails.


                                       Capítulo 17 - Apêndice C - Deployment - Phusion Passenger (mod_rails) - Página 189
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




    O patch principalmente visa modificar um pouco o comportamento do Garbage Collector, fazendo com que
ele não modifique o espaço de memória que guarda o código do Rails. Desta forma, os sistemas operacionais
modernos conseguem usar o mesmo código Rails carregado na memória para todos os processos. Esta técnica
é conhecida como Copy on Write; suportada pela maioria dos sistemas operacionais modernos.

   Outra mudança importante promovida pelos desenvolvedores da Phusion foi o uso de uma nova biblioteca
para alocação de memória, tcmalloc, no lugar da original do sistema operacional. Esta biblioteca é uma criação
do Google.


 17.9 - Exercícios: Deploy com Apache e Passenger

1) Abra o FileBrowser e copie o projeto restaurantes para o Desktop. o projeto está em /rr910/Aptana Studio
   Workspace/restaurantes

2) Abra o terminal e digite:

    install-httpd



   Feche e abra o terminal novamente Esse comando baixa httpd e compila na pasta /home/apache. No nosso
   caso=> /home/rr910/apache

3) Ainda no terminal entre no diretório do projeto e rode a migration para atualizar o banco em produção:

    cd Desktop/restaurante

   rake db:migrate:reset RAILS_ENV=production


4) Abra o arquivo de configuração do Apache:

    gedit /home/rr910/apache/conf/httpd.conf



   Altere a linha abaixo:

    Listen 8080



   Adicione a linha a baixo em qualquer lugar do arquivo:

    Servername http://localhost:8080



5) Suba o Apache, no terminal rode:

    apachectl start



   Acesse http://localhost:8080/ no broser e confira se o Apache subiu, deve aparecer a menssagem It
   works!.

                               Capítulo 17 - Apêndice C - Deployment - Exercícios: Deploy com Apache e Passenger - Página 190
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




6) vamos instalar o Passenger. no terminal rode:

   gem install passenger

   passenger-install-apache2-module


   Quando o instalador surgir no terminal, pressione enter.
   No fim, copie a instrução semelhante a essa:

   LoadModule passenger_module /home/rr910/.gem/ruby/1.8/gems/passenger-2.2.5/ext/apache2/

     mod_passenger.so
    PassengerRoot /home/rr910/.gem/ruby/1.8/gems/passenger-2.2.5

    PassengerRuby /usr/bin/ruby1.8


7) Abra o arquivo de configuração do Apache:

   gedit /home/rr910/apache/conf/httpd.conf



   Adicione essas linhas ao final do arquivo:

   <VirtualHost *:8080>

        DocumentRoot /home/rr910/Desktop/restaurante/public

   </VirtualHost>

   <Directory />
      Options FollowSymLinks
      AllowOverride None
      Order allow,deny
      Allow from all
   </Directory>


8) No terminal, de o restart no apache:

   apachectl restart



   Acesse http://localhost:8080/restaurantes. Nossa aplicação está rodando no Apache com Passenger!




                            Capítulo 17 - Apêndice C - Deployment - Exercícios: Deploy com Apache e Passenger - Página 191
C APÍTULO   18

Apêndice D - Instalação
                                                                        “A dúvida é o principio da sabedoria”
                                                                                                  – Aristóteles


 18.1 - Ruby - Ubuntu
   Para instalar o Rails no Ubuntu deve-se executar os seguintes passos:

   • Build essencial para instalação de gems com extensão nativa:

      sudo apt-get install build-essential



   • Instalar ruby

      sudo apt-get install ruby1.8 ruby1.8-dev



   • Precisamos também instalar o rubygems. Existe um pacote deb no apt-get, mas que é melhor não
     usar pois ele está sempre desatualizado. Então vamos fazer o download e instalação manuais. Faça o
     download da última versão:
     http://rubyforge.org/frs/?group_id=126 (1.1.1)
     Basta descompactar e executar no diretório:

      sudo ruby setup.rb



     Depois de instalar, não se esqueça de atualizar o rubygems:

      sudo gem update --system



     Feito isso, você já estará com o Ruby e rubygems mais atuais.

    O Ubuntu cria os executáveis com o sufixo 1.8. Para tudo funcionar como esperado, é necessário ainda criar
alguns links:


sudo ln -s /usr/bin/gem1.8 /usr/bin/gem
sudo ln -s /usr/bin/ruby1.8 /usr/bin/ruby
sudo ln -s /usr/bin/rdoc1.8 /usr/bin/rdoc

                                                    192
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




sudo ln -s /usr/bin/ri1.8 /usr/bin/ri
sudo ln -s /usr/bin/irb1.8 /usr/bin/irb



 18.2 - Ruby - Windows
   Para instalar no Windows, basta fazer o download da última versão do ruby em:

   http://rubyforge.org/frs/?group_id=167.
   Basta descompactar e dar duplo clique para instalar.

   Após isso, é necessário atualizar a rubygem. Digite no prompt de comando:


gem update --system



 18.3 - Rails
   Para instalar Rails, basta executar o seguinte comando:

   No Ubuntu:


sudo gem install rails


   No Windows, abra um prompt de comando e digite:


gem install rails



 18.4 - JDK
   Para utilização do editor Aptana, é necessária a instalação da JDK.

   No Ubuntu:


sudo apt-get install sun-java6-jdk


   No Windows:

   Fazer o download em http://java.sun.com/javase/downloads/index.jsp


 18.5 - Aptana
   O Aptana Studio pode ser adquirido em: http://www.aptana.com/studio/download

    Após fazer o download do Aptana, basta descompactá-lo e clicar em “Aptana”. Feito isso, é necessário
instalar o plugin para manipulação de projetos Rails. Para isso, faça:


                                                    Capítulo 18 - Apêndice D - Instalação - Ruby - Windows - Página 193
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




   Menu Help -> Software Updates -> Find and Install -> Search for new features to install

   Selecione Aptana: RadRails Development Environment -> next O Aptana irá fazer download o plugin Rails
automáticamente


 18.6 - Mongrel
   Para instalar o mongrel, basta executar o seguinte comando:

   No Ubuntu:


sudo gem install mongrel


   No Windows, abra um prompt de comando e digite:


gem install mongrel



 18.7 - MySQL
   No Ubuntu:


sudo apt-get install mysql-server-5.0


   No Windows:

   Basta fazer o download em http://dev.mysql.com/downloads/mysql/5.0.html

   Após isso, bastá descompactar e dar duplo clique para instalar.


 18.8 - SVN
   No Ubuntu:


sudo apt-get install subversion


   No Windows:

   Basta fazer o download em:

   http://subversion.tigris.org/servlets/ProjectDocumentList?folderID=91
   Após isso, basta dar duplo clique para instalar.




                                                           Capítulo 18 - Apêndice D - Instalação - Mongrel - Página 194
Índice Remissivo

ActiveRecord, 71                         mongrelc luster, 189
afterf ilter, 117                        MRI, 4
aroundf ilter, 117                       MSpec, 6
                                         MVC, 55
BDD, 175
beforef ilter, 117                       Observer, 49
Behavior Driven Development, 175         open-uri, 167
Boolean, 12                              Operadores Aritméticos, 11
Builder, 116                             Operadores Booleanos, 12
                                         OR, 14
Classes abertas, 19                      ORM, 71
CoC, 55
comments, 9                              Palavras Reservadas, 11
Comparable, 34                           Phusion, 7
Copy on Write, 189                       Phusion Passenger, 7
                                         puts, 9
DRY, 55
Duck Typing, 45                          rack, 119
                                         RadRails, 56
Enumerable, 34                           Rake, 72
ERb, 104                                 Ranges, 11
                                         Regexp, 13
for, 13
                                         respondt o, 124
gems, 5                                  RSpec, 175
Gemstone, 7                              Rubinius, 6
                                         Ruby, 4
HAML, 116                                Ruby Enterprise Edition, 7
hpricot, 167                             Ruby.NET, 6
                                         RubyGems, 5
I/O, 37                                  RubySpec, 6
if / elsif / case / when, 12
IronRuby, 6                              scaffold, 62
                                         Search Engine Optimization, 121
JRuby, 6                                 SEO, 121
                                         String, 9
Maglev, 7
                                         Symbol, 11
MetaProgramming, 52
                                         Syntax Sugar, 22
Migrations, 73
modr ails, 7                             tcmalloc, 190

                                   195
Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails




Template Method, 46
Testes, 171
The Great Ruby Shootout, 7

willp aginate, 166




                                                                Índice Remissivo - Índice Remissivo - Página 196

Mais conteúdo relacionado

PDF
Caelum ruby-on-rails-rr71
PDF
Caelum Java
PDF
Caelum ruby-on-rails-rr71
PDF
Java web fj21-- apostila da caelum
PDF
Caelum ruby-on-rails-rr71
PDF
Caelum java-web-vraptor-hibernate-ajax-fj28
PDF
Publicado ruby on-rails-rr71
PDF
Apostila ruby-completa
Caelum ruby-on-rails-rr71
Caelum Java
Caelum ruby-on-rails-rr71
Java web fj21-- apostila da caelum
Caelum ruby-on-rails-rr71
Caelum java-web-vraptor-hibernate-ajax-fj28
Publicado ruby on-rails-rr71
Apostila ruby-completa

Mais procurados (18)

PDF
Caelum csharp-dotnet-fn13
PDF
Caelum java-web-fj21
PDF
Algorimos java
PDF
Caelum html-css-javascript-php
PDF
50718286 apostila-de-asp-net-c-e-visual-basic-net
PDF
Apostila programao orientada a objeto no abap
PDF
Programacao em java
PDF
Linguagem ABAP
DOC
Comparação de Tecnologias para Web - JBoss Seam e Ruby on Rails
PDF
Comparação de Tecnologias para Web - JBoss Seam e Ruby on Rails
PDF
Moodle manual unb
PDF
Manual Moodle
PDF
Squid
PDF
Programacao Orientada A Objetos (Java)
PDF
Shell script
PDF
Aprendendo action script 3.0
PDF
Javascript
Caelum csharp-dotnet-fn13
Caelum java-web-fj21
Algorimos java
Caelum html-css-javascript-php
50718286 apostila-de-asp-net-c-e-visual-basic-net
Apostila programao orientada a objeto no abap
Programacao em java
Linguagem ABAP
Comparação de Tecnologias para Web - JBoss Seam e Ruby on Rails
Comparação de Tecnologias para Web - JBoss Seam e Ruby on Rails
Moodle manual unb
Manual Moodle
Squid
Programacao Orientada A Objetos (Java)
Shell script
Aprendendo action script 3.0
Javascript
Anúncio

Destaque (8)

PDF
Informe final observacion_electoral_venezuela_14_abril_2013 (1)
PPTX
Mata Atlântica
PDF
sports and event bag catalogue
PPTX
PPTX
Apresentação veneza2
PDF
Ii habilidades de conceptualizacion copia
PPSX
E mail e currículo
PPTX
Informe final observacion_electoral_venezuela_14_abril_2013 (1)
Mata Atlântica
sports and event bag catalogue
Apresentação veneza2
Ii habilidades de conceptualizacion copia
E mail e currículo
Anúncio

Semelhante a Caelum ruby-on-rails-rr71 (20)

PDF
Caelum ruby-on-rails-rr71
PDF
Caelum ruby-on-rails-rr71
PDF
Apostila Ruby on rails
PDF
Caelum java-objetos-fj11
PDF
Caelum java-testes-xml-design-patterns-fj16
PDF
caelum-java-objetos-fj11.pdf
PDF
Caelum java-testes-jsf-web-services-design-patterns-fj22
PDF
Caelum java-testes-jsf-web-services-design-patterns-fj22
PDF
Caelum java-testes-jsf-web-services-design-patterns-fj22
PDF
Jspservlets
PDF
Caelum html-css-javascript-php
PDF
PDF
Zope
PDF
Programação Orientada a Objetos com Java
PDF
Introdução ao SciLab
PDF
20220093 scilab-manual
PDF
Apostila java completo
PDF
Caelum java-web-vraptor-hibernate-ajax-fj28
PDF
solução em java
Caelum ruby-on-rails-rr71
Caelum ruby-on-rails-rr71
Apostila Ruby on rails
Caelum java-objetos-fj11
Caelum java-testes-xml-design-patterns-fj16
caelum-java-objetos-fj11.pdf
Caelum java-testes-jsf-web-services-design-patterns-fj22
Caelum java-testes-jsf-web-services-design-patterns-fj22
Caelum java-testes-jsf-web-services-design-patterns-fj22
Jspservlets
Caelum html-css-javascript-php
Zope
Programação Orientada a Objetos com Java
Introdução ao SciLab
20220093 scilab-manual
Apostila java completo
Caelum java-web-vraptor-hibernate-ajax-fj28
solução em java

Caelum ruby-on-rails-rr71

  • 1. RR-71 Desenvolvimento Ágil para Web 2.0 com Ruby on Rails
  • 2. A Caelum atua no mercado com consultoria, desenvolvimento e ensino em computação. Sua equipe participou do desenvolvimento de projetos em vários clientes e, após apresentar os cursos de verão de Java na Universidade de São Paulo, passou a oferecer treinamentos para o mercado. Toda a equipe tem uma forte presença na comunidade através de eventos, artigos em diversas revistas, participação em muitos projetos open source como o VRaptor e o Stella e atuação nos fóruns e listas de discussão como o GUJ. Com uma equipe de mais de 60 profissionais altamente qualificados e de destaque do mercado, oferece treinamentos em Java, Ruby on Rails e Scrum em suas três unidades - São Paulo, Rio de Janeiro e Brasília. Mais de 8 mil alunos já buscaram qualificação nos treinamentos da Caelum tanto em nas unidades como nas próprias empresas com os cursos incompany. O compromisso da Caelum é oferecer um treinamento de qualidade, com material constantemente atualizado, uma metodologia de ensino cuidadosamente desenvolvida e instrutores capacitados tecnicamente e didaticamente. E oferecer ainda serviços de consultoria ágil, mentoring e desenvolvimento de projetos sob medida para empresas. Comunidade Nossa equipe escreve constantemente artigos no Blog da Caelum que já conta com 150 artigos sobre vários assuntos de Java, Rails e computação em geral. Visite-nos e assine nosso RSS: ➡ blog.caelum.com.br Acompanhe também a equipe Caelum no Twitter: ➡ twitter.com/caelumdev/equipe O GUJ é maior fórum de Java em língua portuguesa, com 700 mil posts e 70 mil usuários. As pessoas da Caelum participam ativamente, participe também: ➡ www.guj.com.br Assine também nossa Newsletter para receber as novidades e destaques dos eventos, artigos e promoções da Caelum: ➡ www.caelum.com.br/newsletter No site da Caelum há algumas de nossas Apostilas disponíveis gratuitamente para download e alguns dos artigos de destaque que escrevemos: ➡ www.caelum.com.br/apostilas ➡ www.caelum.com.br/artigos
  • 3. Conheça alguns de nossos cursos FJ-11: FJ-25: Java e Orientação a Persistência com JPA2 e objetos Hibernate FJ-16: FJ-26: Laboratório Java com Testes, Laboratório Web com JSF2 e XML e Design Patterns CDI FJ-19: FJ-31: Preparatório para Certificação Java EE avançado e de Programador Java Web Services FJ-21: FJ-91: Java para Desenvolvimento Arquitetura e Design de Web Projetos Java RR-71: RR-75: Desenvolvimento Ágil para Web Ruby e Rails avançados: lidando 2.0 com Ruby on Rails com problemas do dia a dia Para mais informações e outros cursos, visite: caelum.com.br/cursos ✓ Mais de 8000 alunos treinados; ✓ Reconhecida nacionalmente; ✓ Conteúdos atualizados para o mercado e para sua carreira; ✓ Aulas com metodologia e didática cuidadosamente preparadas; ✓ Ativa participação nas comunidades Java, Rails e Scrum; ✓ Salas de aula bem equipadas; ✓ Instrutores qualificados e experientes; ✓ Apostilas disponíveis no site.
  • 4. Sobre esta apostila Esta apostila da Caelum visa ensinar de uma maneira elegante, mostrando apenas o que é necessário e quando é necessário, no momento certo, poupando o leitor de assuntos que não costumam ser de seu interesse em determinadas fases do aprendizado. A Caelum espera que você aproveite esse material. Todos os comentários, críticas e sugestões serão muito bem-vindos. Essa apostila é constantemente atualizada e disponibilizada no site da Caelum. Sempre consulte o site para novas versões e, ao invés de anexar o PDF para enviar a um amigo, indique o site para que ele possa sempre baixar as últimas versões. Você pode conferir o código de versão da apostila logo no final do índice. Baixe sempre a versão mais nova em: www.caelum.com.br/apostilas Esse material é parte integrante do treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails e distribuído gratuitamente exclusivamente pelo site da Caelum. Todos os direitos são reservados à Caelum. A distribuição, cópia, revenda e utilização para ministrar treinamentos são absolutamente vedadas. Para uso comercial deste material, por favor, consulte a Caelum previamente. www.caelum.com.br 1
  • 5. Índice 1 Agilidade na Web 1 1.1 A agilidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.2 A comunidade Rails . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.3 Bibliografia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.4 Tirando dúvidas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.5 Para onde ir depois? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2 A linguagem Ruby 4 2.1 A história do Ruby e suas características . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2 Instalação do interpretador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.3 Outras implementações de interpretadores Ruby . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.4 Ruby Enterprise Edition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 2.5 Interactive Ruby: ruby no terminal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 3 Classes, objetos e métodos 9 3.1 Váriáveis, Strings e Comentários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 3.2 Exercícios - Variáveis, Atribuições . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 3.3 Tipos e operações básicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 3.4 Exercícios - Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 3.5 Estruturas de controle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 3.6 Exercícios - Estruturas de controle e Regexp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 3.7 Desafios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 i
  • 6. 4 Mais Ruby: classes, objetos e métodos 16 4.1 Mundo orientado a objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 4.2 Métodos comuns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 4.3 Definição de métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 4.4 Exercícios - Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 4.5 Discussão: Enviando mensagens aos objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 4.6 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 4.7 Exercícios - Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 4.8 Desafio: Classes abertas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 4.9 self . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 4.10 Desafio: self e o método puts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 4.11 Atributos e propriedades: acessores e modificadores . . . . . . . . . . . . . . . . . . . . . . . . . 20 4.12 Syntax Sugar: facilitando a sintaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 4.13 Exercícios - Atributos e propriedades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 4.14 Coleções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 4.15 Exemplo: múltiplos parâmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 4.16 Hashes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 4.17 Exercícios - Arrays e Hashes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 4.18 Blocos e Programação Funcional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 4.19 Exercícios - Blocos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 4.20 Para saber mais: Mais sobre blocos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 4.21 Desafio: Usando blocos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 4.22 Manipulando erros e exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 4.23 Exercício: Manipulando exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 4.24 Arquivos com código fonte ruby . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 4.25 Para saber mais: um pouco de IO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 5 Metaprogramação e Padrões de Projeto 39 5.1 Métodos de Classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 5.2 Para saber mais: Singleton Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 5.3 Exercícios - Ruby Object Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 5.4 Design Patterns: Singleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 ii
  • 7. 5.5 Exercicio: Design Pattern - Singleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 5.6 Convenções . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 5.7 Polimorfirmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 5.8 Exercícios - Duck Typing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 5.9 Design Patterns: Template Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 5.10 Exercicio Opcional: Design Pattern - Template Method . . . . . . . . . . . . . . . . . . . . . . . . 47 5.11 Modulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 5.12 Design Patterns: Observer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 5.13 Desafio: Design Pattern - Observer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 5.14 Metaprogramação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 5.15 Exercícios - Metaprogramação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 6 Ruby on Rails 55 6.1 Ruby On Rails . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 6.2 Aprender Ruby? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 6.3 IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 6.4 Criando um novo projeto rails . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 6.5 Exercícios: Iniciando o Projeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 6.6 Estrutura dos diretórios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 6.7 Carregando as dependências . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 6.8 O Banco de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 6.9 Exercícios: Criando o banco de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 6.10 A base da construção: scaffold (andaime) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 6.11 Exercícios: Scaffold . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 6.12 Gerar as tabelas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 6.13 Versão do Banco de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 6.14 Exercícios: Migrar tabela . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 6.15 Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 6.16 Exercícios: Iniciando o servidor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 6.17 Documentação do Rails . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 6.18 Exercício Opcional: Utilizando a documentação . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 iii
  • 8. 7 Active Record 70 7.1 Motivação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 7.2 Exercícios: Controle de Restaurantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 7.3 Modelo - O “M” do MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 7.4 ActiveRecord . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 7.5 Rake . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 7.6 Criando Modelos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 7.7 Migrations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 7.8 Exercícios: Criando os modelos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 7.9 Manipulando nossos modelos pelo console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 7.10 Exercícios: Manipulando registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 7.11 Exercícios Opcionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 7.12 Finders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 7.13 Exercícios: Buscas dinâmicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 7.14 Validações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 7.15 Exercícios: Validações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 7.16 Exercícios - Completando nosso modelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 7.17 O Modelo Qualificação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 7.18 Exercícios - Criando o Modelo de Qualificação . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 7.19 Relacionamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 7.20 Para Saber Mais: Auto-relacionamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 7.21 Para Saber Mais: Cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 7.22 Exercícios - Relacionamentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 7.23 Para Saber Mais - Eager Loading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 7.24 Para Saber Mais - Named Scopes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 7.25 Para Saber Mais - Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 8 Controllers e Views 100 8.1 O “V” e o “C” do MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 8.2 Hello World . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 8.3 Exercícios: Criando o controlador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 8.4 Redirecionamento de Action e Action padrão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 iv
  • 9. 8.5 Trabalhando com a View: O ERB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 8.6 Entendendo melhor o CRUD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 8.7 Exercícios: Controlador do Restaurante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 8.8 Helper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 8.9 Exercícios: Utilizando helpers para criar as views . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 8.10 Partial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 8.11 Exercícios: Customizando o cabeçalho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 8.12 Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 8.13 Exercícios: Criando o header . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 8.14 Outras formas de gerar a View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 8.15 Filtros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 9 Rotas e Rack 119 9.1 Rack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 9.2 Exercícios - Testando o Rack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 9.3 routes.rb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120 9.4 Pretty URLs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 9.5 Named Routes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 9.6 REST - resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 9.7 Actions extras em Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 9.8 Diversas Representações . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 9.9 Para Saber Mais - Nested Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 9.10 Rails e o Rack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 9.11 Exercícios - Criando um rota para uma aplicação Rack . . . . . . . . . . . . . . . . . . . . . . . . 127 10 Completando o Sistema 128 10.1 Um pouco mais sobre o Scaffold . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 10.2 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 10.3 Selecionando Clientes e Restaurante no form de Qualificações . . . . . . . . . . . . . . . . . . . 132 10.4 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 10.5 Exercícios Opcionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 10.6 Mais sobre os controllers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 v
  • 10. 11 Calculations 143 11.1 Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 11.2 Média . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 11.3 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 12 Associações Polimórficas 145 12.1 Nosso problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145 12.2 Alterando o banco de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145 12.3 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147 13 Ajax com Rails 151 13.1 Adicionando comentários nas views . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 13.2 Instalando manualmente o JQuery no projeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 13.3 Instalando o JQuery no projeto usando a gem jquery-rails . . . . . . . . . . . . . . . . . . . . . . 153 13.4 Criando as chamadas AJAX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 13.5 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156 13.6 Adicionando comentários . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 13.7 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162 14 Alguns Plugins e Gems Importantes 166 14.1 Paginação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166 14.2 Exercícios - Título . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 14.3 Hpricot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 14.4 Exercícios - Testando o Hpricot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 14.5 File Uploads: Paperclip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 14.6 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 15 Testes 171 15.1 O Porquê dos testes? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 15.2 Test::Unit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 15.3 Exercícios - Teste do modelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 15.4 Exercícios - Teste do controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 15.5 RSpec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 15.6 Cucumber, o novo Story Runner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 vi
  • 11. 16 Apêndice B - Integrando Java e Ruby 182 16.1 O Projeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 16.2 Testando o JRuby . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 16.3 Exercícios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 16.4 Compilando ruby para .class com Jruby . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183 16.5 Rodando o .class do ruby na JVM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183 16.6 Importando um bytecode(.class) criado pelo jruby . . . . . . . . . . . . . . . . . . . . . . . . . . . 184 16.7 Importando classes do Java para sua aplicação JRuby . . . . . . . . . . . . . . . . . . . . . . . . 184 16.8 Testando o JRuby com Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 17 Apêndice C - Deployment 187 17.1 Webrick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 17.2 CGI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 17.3 FCGI - FastCGI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 17.4 Lighttpd e Litespeed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 17.5 Mongrel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 17.6 Proxies Reversos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 17.7 Phusion Passenger (mod_rails) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 17.8 Ruby Enterprise Edition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 17.9 Exercícios: Deploy com Apache e Passenger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 18 Apêndice D - Instalação 192 18.1 Ruby - Ubuntu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192 18.2 Ruby - Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 18.3 Rails . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 18.4 JDK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 18.5 Aptana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 18.6 Mongrel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 18.7 MySQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 18.8 SVN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 Versão: 13.8.8 vii
  • 12. C APÍTULO 1 Agilidade na Web “Não são os milagres que inclinam o realista para a fé. O verdadeiro realista, caso não creia, sempre encontrará em si força e capacidade para não acreditar no milagre, e se o milagre se apresenta diante dele como fato irrefutável, é mais fácil ele descrer de seus sentidos que admitir o fato” – Fiodór Dostoievski, em Irmãos Karamazov 1.1 - A agilidade Quais são os problemas mais frequentes no desenvolvimento web? Seriam os problemas com AJAX? Escrever SQL? Tempo demais para gerar os CRUDs básicos? Com tudo isso em mente, David Heinemeier Hansson, trabalhando na 37Signals, começou a procurar uma linguagem de programação que pudesse utilizar para desenvolver os projetos de sua empresa. Mais ainda, criou um framework web para essa linguagem, que permitiria a ele escrever uma aplicação web de maneira simples e elegante. Em agosto de 2010 foi lançada a versão final do Rails 3 e a Caelum ministra turmas com o material atualizado para esta versão desde então. O que possibilita toda essa simplicidade do Rails são os recursos poderosos que Ruby oferece e que deram toda a simplicidade ao Rails. Esses recursos proporcionados pela linguagem Ruby são fundamentais de serem compreendidos por todos que desejam se tornar bons desenvolvedores Rails e por isso o começo desse curso foca bastante em apresentar as características da linguagem e seus diferenciais. Um exemplo clássico da importância de conhecer mais a fundo a linguagem Ruby está em desvendar a “magia negra” por trás do Rails. Conceitos como meta programação, onde código é criado dinamicamente, são essenciais para o entendimento de qualquer sistema desenvolvido em Rails. É a meta programação que permite, por exemplo, que tenhamos classes extremamente enxutas e que garante o relacionamento entre as tabelas do banco de dados com nossas classes de modelo sem a necessidade de nenhuma linha de código, apenas usando de convenções. Esse curso apresenta ainda os conceitos de programação funcional, uso de blocos, duck typing, enfim, tudo o que é necessário para a formação da base de conceitos que serão utilizados ao longo do curso e da vida como um desenvolvedor Rails. 1.2 - A comunidade Rails A comunidade Rails é hoje uma das mais ativas e unidas do Brasil. Cerca de 10 eventos acontecem anual- mente com o único propósito de difundir conhecimento e unir os desenvolvedores. Um exemplo dessa força é o Ruby Conf, maior evento de Ruby da America Latina, com presença dos maiores nomes nacionais e internaci- onais de Ruby on Rails, e a presença de uma track dedicada ao Ruby na QCon São Paulo. 1
  • 13. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Além dos eventos, diversos blogs sobre Rails tem ajudado diversos programadores a desvendar esse novo universo: • http://blog.caelum.com.br/ - Blog da Caelum • http://andersonleite.com.br/ - Anderson Leite • http://agilenomundoreal.com.br/ - Guilherme Silveira • http://davidpaniz.com/ - David Paniz • http://yehudakatz.com/ - Yehuda Katz • http://fabiokung.com/ - Fabio Kung • http://akitaonrails.com/ - Fábio Akita • http://blog.plataformatec.com.br/ - José Valim • http://www.nomedojogo.com/ - Carlos Brando • http://caueguerra.com - Cauê Guerra • http://railsenvy.com/ - Rails Envy • http://www.rubyinside.com.br/ - RubyInside Brasil • http://rubyflow.com/ - Rubyflow A Caelum aposta no Rails desde 2007, quando criamos o primeiro curso a respeito. E o ano de 2009 marcou o Ruby on Rails no Brasil, ano em que ele foi adotado por diversas empresas grandes e até mesmo orgãos do governo, como mencionado num post em nosso blog no começo do mesmo ano: http://blog.caelum.com.br/2009/01/19/2009-ano-do-ruby-on-rails-no-brasil/ 1.3 - Bibliografia • Agile Web Development with Rails - Sam Ruby, Dave Thomas, David Heinemeier Hansson Esse é o livro referência no aprendizado de Ruby on Rails, criado pelo autor do framework. Aqui, ele mostra através de um projeto, os principais conceitos e passos no desenvolvimento de uma aplicação completa. Existe uma versão em andamento para Rails 3. • Programming Ruby: The Pragmatic Programmers’ Guide - Dave Thomas, Chad Fowler, Andy Hunt Conhecido como “Pickaxe”, esse livro pode ser considerado a bíblia do programador Ruby. Cobre toda a especificação da linguagem e procura desvendar toda a “magia” do Ruby. • The Pragmatic Programmer: From Journeyman to Master - Andrew Hunt, David Thomas As melhores práticas para ser um bom desenvolvedor: desde o uso de versionamento, ao bom uso do logging, debug, nomenclaturas, como consertar bugs, etc. Existe ainda um post no blog da Caelum sobre livros que todo desenvolvedor Rails deve ler: http://blog. caelum.com.br/2009/08/25/a-trinca-de-ases-do-programador-rails/ Capítulo 1 - Agilidade na Web - Bibliografia - Página 2
  • 14. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 1.4 - Tirando dúvidas Para tirar dúvidas dos exercícios, ou de Ruby e Rails em geral, recomendamos se inscrever na lista do GURU-SP (http://groups.google.com/group/ruby-sp), onde sua dúvida será respondida prontamente. Também recomendamos duas outras listas: • http://groups.google.com/group/rubyonrails-talk • http://groups.google.com/group/rails-br Fora isso, sinta-se à vontade para entrar em contato com seu instrutor e tirar todas as dúvidas que tiver durante o curso. O fórum do GUJ.com.br, conceituado em java, possui também um subfórum de Rails: http://www.guj.com.br/ 1.5 - Para onde ir depois? Além de fazer nossos cursos de Rails, você deve participar ativamente da comunidade. Ela é muito viva e ativa, e as novidades aparecem rapidamente. Se você ainda não tinha hábito de participar de fóruns, listas e blogs, essa é uma grande oportunidade. Há ainda a possibilidade de participar de projetos opensource, e de você criar gems e plugins pro rails que sejam úteis a toda comunidade. Capítulo 1 - Agilidade na Web - Tirando dúvidas - Página 3
  • 15. C APÍTULO 2 A linguagem Ruby “Rails is the killer app for Ruby.” – Yukihiro Matsumoto, Criador da linguagem Ruby Neste capítulo, conheceremos a poderosa linguagem de programação Ruby, base para completo entendi- mento do framework Ruby on Rails. Uma linguagem dinâmica e poderosa como o Ruby vai se mostrar útil não apenas para o uso no Rails, como também para outras tarefas e scripts do dia a dia. Veremos a história, o contexto, suas versões e interpretadores e uma iniciação a sintaxe da linguagem. 2.1 - A história do Ruby e suas características Ruby foi apresentada ao público pela primeira vez em 1995, pelo seu criador: Yukihiro Matsumoto, mun- dialmente conhecido como Matz. É uma linguagem orientada a objetos, com tipagem forte e dinâmica. Cu- riosamente é uma das únicas linguagens nascidas fora do eixo EUA - Europa que atingiram enorme sucesso comercial. Uma de suas principais características é a expressividade que possui. Teve-se como objetivo desde o início que fosse uma linguagem muito simples de ler e ser entendida, para facilitar o desenvolvimento e manutenção de sistemas escritos com ela. Ruby é uma linguagem interpretada e, como tal, necessita da instalação de um interpretador em sua má- quina antes de executar algum programa. Orientação a objetos pura Entre as linguagens de programação orientada a objetos, muito se discute se são puramente orien- tadas a objeto ou não, já que grande parte possui recursos que não se comportam como objetos. Os tipos primitivos de Java são um exemplo desta contradição, já que não são objetos de verdade. Ruby é considerada uma linguagem puramente orientada a objetos, já que tudo em Ruby é um objeto (inclusive as classes, como veremos). 2.2 - Instalação do interpretador Antes da linguagem Ruby se tornar popular, existia apenas um interpretador disponível: o escrito pelo próprio Matz, em C. É um interpretador simples, sem nenhum gerenciamento de memória muito complexo, nem características modernas de interpretadores como a compilação em tempo de execução (conhecida como JIT). Este interpretador é conhecido como Matz’s Ruby Interpreter (MRI), ou CRuby (já que é escrito em C) e é também considerado a implementação de referência para a linguagem Ruby. 4
  • 16. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails A última versão estável é a 1.9.x, também conhecida como YARV e deve ser usada em produção, apesar de ser uma versão de transição até o Ruby 2.0 onde serão inclusas diversas mudanças e novas funcionalidades. Como a versão 1.9.x é recente, vários projetos ainda estão utilizando a versão 1.8.x. A maioria das distribuições Linux possuem o pacote de uma das última versões estáveis pronto para ser instalado. O exemplo mais comum de instalação é para o Ubuntu: sudo apt-get install ruby1.8 ruby1.8-dev O interpretador ruby (MRI) já vem instalado no Mac OS X. Apesar de existirem soluções prontas para a instalação do Ruby em diversas plataformas (one-click- installers), sempre é possível baixá-lo pelo site oficial: http://ruby-lang.org Após a instalação, não deixe de conferir se o interpretador está disponível na sua variável de ambiente PATH: $ ruby --version ruby 1.8.6 (2007-09-24 patchlevel 111) [i486-linux] A saída pode ser um pouco diferente, dependendo do sistema operacional e da versão instalada. Nesta apostila existe um apêndice sobre a instalação e detalhes do Ruby, caso você esteja enfrentando problemas. Ruby possui um gerenciador de pacotes e dependências bastante avançado, flexível e eficiente: Ruby- Gems. Os gems podem ser vistos como bibliotecas reutilizáveis de código Ruby, que podem até conter algum código nativo (em C, Java, .Net). São análogos aos jars no ambiente Java, ou os assemblies do mundo .Net. RubyGems é um sistema gerenciador de pacotes comparável a qualquer um do mundo *NIX, como os .debs do apt-get, o MacPorts (BSD Ports), os rpms com yum, entre outros. Portanto, para sermos capazes de instalar e utilizar as centenas de gems disponíveis, precisamos instalar além do interpretador Ruby, o Rubygems. Basta baixá-lo no endereço abaixo e executar o script de instalação contido no pacote: http://www.rubygems.org/ cd rubygems-1.x.x ruby setup.rb Capítulo 2 - A linguagem Ruby - Instalação do interpretador - Página 5
  • 17. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 2.3 - Outras implementações de interpretadores Ruby Com a popularização da linguagem Ruby (iniciada pelo Ruby on Rails), implementações alternativas da linguagem começaram a ficar em evidência. A maioria delas segue uma tendência natural de serem baseados em uma Máquina Virtual ao invés de serem simples interpretadores. Algumas implementações possuem até compiladores completos, que transformam o código Ruby em alguma linguagem intermediária a ser interpretada por uma máquina virtual. Vale a pena conhecer algumas das principais opções do mercado. O próprio Ruby 1.9 de referência (YARV), evolução do MRI, é baseado em uma máquina virtual: Yet Another Ruby VM. A principal vantagem das máquinas virtuais é facilitar o suporte em diferentes plataformas. Além disso, ter código intermediário permite otimização do código em tempo de execução, feito através da JIT. JRuby foi a primeira implementação completa da versão 1.8.6 do Ruby. O JRuby é a principal implemen- tação em Java da linguagem Ruby e é hoje considerada por muitos como a implementação mais rápida da linguagem. Não é um simples interpretador, já que também opera nos modos AOT - compilação Ahead Of Time e JIT - Just In Time compilation, além do modo interpretador tradicional (Tree Walker ). Teremos um capítulo exclusivo sobre JRuby, mas uma de suas principais vantagens é a interoperabilidade com código Java existente, além de aproveitar todas as vantagens de uma das plataformas de execução de código mais maduras (GC, JIT, Threads nativas, entre outras). Além disso, a própria Oracle e a Sun Microsystems apostam no projeto, já que alguns de seus principais desenvolvedores, Charles Nutter (líder técnico do projeto), Tomas Enebo e Nick Sieger já trabalharam para a Sun. O JRuby também suporta o Rails 3. A comunidade .Net também não ignora o sucesso da linguagem e patrocina o projeto IronRuby, mantido pela própria Microsoft. IronRuby foi um dos primeiros projetos verdadeiramente de código aberto dentro da Microsoft. Ruby.NET é outro projeto que tem como objetivo possibilitar código Ruby ser executado na plataforma .Net. Originalmente conhecido como Gardens Point Ruby.NET Compiler, procura ser um compilador de código Ruby para a CLR do mundo .Net. Criada por Evan Phoenix, Rubinius é um dos projetos que tem recebido mais atenção pela comunidade Ruby, por ter o objetivo de criar a implementação de Ruby com a maior parte possível do código em Ruby. Além disso, trouxe idéias de máquinas virtuais do SmallTalk, possuindo um conjunto de instruções (bytecode) próprio e implementada em C/C++. http://rubini.us O projeto Rubinius possui uma quantidade de testes enorme, escritos em Ruby. O que incentivou a iniciativa de especificar a linguagem Ruby. O projeto RubySpec (http://rubyspec.org/) é um acordo entre os vários im- plementadores da linguagem Ruby para especificar as características da linguagem Ruby e seu comportamento, através de código executável, que funciona como um TCK (Test Compatibility Kit). RubySpec tem origem na suíte de testes de unidade do projeto Rubinius, escritos com uma versão mínima do RSpec, conhecida como MSpec. O RSpec é um framework para descrição de especificações no estilo pregado pelo Behavior Driven Development. Veremos mais sobre isso no capítulo de testes. Avi Bryant é um programador Ruby conhecido, que mudou para Smalltalk e hoje é um defensor fervoroso da linguagem; além de ser um dos criadores do principal framework web em SmallTalk: Seaside. Durante seu keynote na RailsConf de 2007, lançou um desafio à comunidade: Capítulo 2 - A linguagem Ruby - Outras implementações de interpretadores Ruby - Página 6
  • 18. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails “I’m from the future, I know how this story ends. All the people who are saying you can’t implement Ruby on a fast virtual machine are wrong. That machine already exists today, it’s called Gemstone, and it could certainly be adapted to Ruby. It runs Smalltalk, and Ruby essentially is Smalltalk. So adapting it to run Ruby is absolutely within the realm of the possible.” Ruby e Smalltalk são parecidos demais. Avi basicamente pergunta: por que não criar máquinas virtuais para Ruby, aproveitando toda a tecnologia de máquinas virtuais para SmallTalk, que já têm bastante maturidade e estão no mercado a tantos anos? Integrantes da empresa Gemstone, que possui uma das máquinas virtuais para SmallTalk mais famosas - Gemstone/S, estavam na platéia e chamaram o Avi Bryant para provar que isto era possível. Na RailsConf de 2008, o resultado foi que a Gemstone apresentou o produto que estão desenvolvendo, conhecido como Maglev. É uma máquina virtual para Ruby, baseada na existente para Smalltalk. As linguagens são tão parecidas que apenas poucas instruções novas tiveram de ser inseridas na nova máquina virtual. Os números apresentados são surpreendentes. Com tão pouco tempo de desenvolvimento, conseguiram apresentar um ganho de até 30x de performance em alguns micro benchmarks. Apesar de ter feito bastante barulho durante a RailsConf 2008, a Gemstone anda bastante quieta sobre o Maglev e não mostrou mais nada desde então. Muitos criticam esta postura da empresa de ter falado sobre algo tão antes de poderem mostrar, além de terem exibido números que não podem provar. Antonio Cangiano teve acesso a uma versão preliminar do Maglev e publicou um famoso comparativo de performance (benchmark ) em seu blog, conhecido como “The Great Ruby Shootout”, em que o Maglev se mostra em média 1.8x mais rápido que a MRI. Sendo muito mais rápido em alguns benchmarks e muito mais lento em alguns outros. http://antoniocangiano.com/2008/12/09/the-great-ruby-shootout-december-2008/ 2.4 - Ruby Enterprise Edition Para melhorar a performance de aplicações Rails e diminuir a quantidade de memória utilizada, Ninh Bui, Hongli Lai e Tinco Andringa (da Phusion) modificaram o interpretador Ruby e lançaram com o nome de Ruby Enterprise Edition. As principais modificações no REE foram no comportamento do Garbage Collector, fazendo com que fun- cione com o recurso de Copy on Write disponível na maioria dos sistemas operacionais baseados em UNIX (Linux, Solaris, ...). Outra importante modificação foi na alocação de memória do interpretador, com o uso de bibliotecas famo- sas como tcmalloc. Os desenvolvedores da Phusion já ofereceram as modificações (patches) para entrar na implementação oficial, MRI. É ainda um mistério para a comunidade o porquê de tais modificações importantes ainda não terem entrado para a versão oficial do interpretador. http://izumi.plan99.net/blog/index.php/2008/08/17/ _making-ruby’s-garbage-collector-copy-on-write- friendly-part-8/ Copy on Write? tcmalloc? Mais detalhes sobre estes assuntos estão no capítulo sobre Deployment. Capítulo 2 - A linguagem Ruby - Ruby Enterprise Edition - Página 7
  • 19. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails No capítulo sobre deployment, veremos mais sobre o outro produto da empresa Phusion, o Phusion Pas- senger - também conhecido como mod_rails. Hoje, é o produto recomendado para rodar aplicações Rails em produção. 2.5 - Interactive Ruby: ruby no terminal O IRB é um dos principais recursos disponíveis aos programadores Ruby. Funciona como um con- sole/terminal, e os comandos vão sendo interpretados ao mesmo tempo em que vão sendo inseridos, de forma interativa. O irb avalia cada linha inserida e já mostra o resultado imediatamente. Todos os comandos apresentados neste capítulo podem ser executados dentro do irb, ou em arquivos .rb. Por exemplo, poderíamos criar um arquivo chamado teste.rb e executá-lo com o seguinte comando: ruby teste.rb Capítulo 2 - A linguagem Ruby - Interactive Ruby: ruby no terminal - Página 8
  • 20. C APÍTULO 3 Classes, objetos e métodos “Pensa como pensam os sábios, mas fala como falam as pessoas simples” – Aristóteles 3.1 - Váriáveis, Strings e Comentários Ao aprender uma nova linguagem de programação sempre nos deparamos com o famoso “Olá Mundo”. Podemos imprimir uma mensagem com ruby utilizando pelo menos 3 opções: puts, print e p. puts "Olá Mundo" Comentários em Ruby podem ser de uma linha apenas: # Imprime uma mensagem puts "Olá mundo" Ou comentários de blocos: =begin Imprime uma mensagem =end puts "Olá mundo" Comentários de bloco Nos comentários de bloco, tanto o “=begin” quanto o “=end” devem ficar no início da linha, tota- lemnte a esquerda. Os comentários de blocos não costumam ser muito usádos Ruby, a própria documentação do Rails usa apenas comentários de linha. Um outro tipo importante nos programas Ruby são os objetos do tipo String. As Strings literais em Ruby podem ser delimitadas por aspas simples ou aspas duplas (e outras formas especiais que veremos mais adi- ante). A principal característica das Strings em Ruby é que são mutáveis, diferente de Java, por exemplo. >> mensagem = "Bom dia, " => "Bom dia," >> mensagem << " tudo bem?" => "Bom dia, tudo bem?" >> puts(mensagem) Bom dia, tudo bem? => nil A concatenação de Strings (operador +) gera novas Strings, é o mesmo comportamento do Java. O operador “<<” é usado para a operação append de Strings. 9
  • 21. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Uma alternativa mais interessante para criar Strings com valor dinâmico é a interpolação: resultado = 6 * 5 texto = "O resultado é #{resultado}. Algo maior seria #{resultado + 240}" Qualquer expressão (código Ruby) pode ser interpolada em uma String. Porém, apenas Strings delimitadas por aspas duplas aceitam interpolação. Prefira sempre a interpolação ao invés da concatenação (+), ou do append (<<). É mais limpo e mais rápido. 3.2 - Exercícios - Variáveis, Atribuições 1) Vamos fazer alguns testes com o Ruby, escrevendo o código e executando no terminal. O arquivo utlizado se chamará restaurante, pois nossa futura aplicação web será um sistema de qualificação de restaurantes. • Crie um diretório no desktop com o nome ruby • Dentro deste diretório crie o arquivo restaurante_basico.rb Ao final de cada exercício voce pode rodar o arquivo no terminal com o comando ruby restau- rante_basico.rb. 2) Imprimir uma mensagem de “Olá Mundo” em Ruby é bem simples. No arquivo restaurante.rb programe o código abaixo. # ’Olá Mundo’ em ruby print "Ola mundo com print" puts "Ola mundo com puts" p "Ola mundo com p" Qual a diferença entre cada um? Escreva suas conclusões nos comentários. 3) Variáveis em ruby são tipadas implicitamente. Vamos criar algumas variáveis e imprimir usando interpola- ção. nome = "Fazano" puts "O nome do restaurante é #{nome}" puts nome.class 4) Em ruby, no geral, as variáveis possuem comportamento mutável, mas para isso normalmente usamos o método com nome terminado com o operador “!"(bang). puts nome # Fazano # comportamento imutável sem ! nome.upcase puts nome # Fazano # comportamento mutável nome.upcase! puts nome # FAZANO Capítulo 3 - Classes, objetos e métodos - Exercícios - Variáveis, Atribuições - Página 10
  • 22. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 3.3 - Tipos e operações básicas Ruby permite avaliar expressões aritméticas tradicionais: >> 3*(2+5)/8 => 2 Estão disponíveis os operadores tradicionais: +, -, /, *, ** (potência) e % (resto da divisão inteira). Os valores podem ainda ser atribuídos a variáveis: >> resultado = 4 ** 2 => 16 >> puts(resultado) 16 => nil puts é o método usado para imprimir valores na saída padrão (stdout) e nil é o objeto nulo do Ruby. Ruby fornece uma maneira de trabalharmos com sequências de uma forma bem simples: (1..3) # range representando números de 1 a 3. (‘a’..’z’) # range representando letras minúsculas do alfabeto (0...5) # range representando números de 1 a 4. Palavras Reservadas alias and BEGIN begin break case class def defined do else elsif END end ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield Símbolos também são texto, como as Strings. Só que devem ser precedidos do caracter ’:’, ao invés de aspas e pertencem à classe Symbol: >> puts :simbolo simbolo => nil >> :simbolo.class => Symbol As principais diferenças são: • São imutáveis. Uma vez criado, um símbolo não pode ser alterado. Se precisarmos de um novo valor, precisa criar um novo objeto símbolo. Capítulo 3 - Classes, objetos e métodos - Tipos e operações básicas - Página 11
  • 23. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails • São compartilhados. Símbolos com o mesmo valor, mesmo que em locais diferentes do código, compar- tilham do mesmo objeto. Isto é, qualquer lugar da aplicação que contenha, por exemplo, :writable, se referem a um mesmo objeto do tipo Symbol. Por causa destas características, símbolos são análogos às Strings do Java. As Strings do Ruby estão mais para o StringBuilder do Java. Por serem imutáveis e compartilhados, objetos Symbol geralmente são usados como identificadores e para nomenclatura (labels). Durante o curso usaremos muito este recurso. 3.4 - Exercícios - Tipos 1) Em Ruby tudo é objeto. Vamos fazer alguns testes curiosos e descobrir os tipos: # Tipos 3.times{ puts "O 3 é um objeto!" } puts 3.class puts 33333333333333333333333.class 2) Podemos fazer as operações básicas em ruby de forma simples: # imprime conta puts 3*(2+5)/8 3) Vamos testar o recurso de ranges do ruby imprimindo uma sequência de números e letras. Obs: Utilizaremos uma notação avançada aqui, não se preocupe, ela será explicada logo adiante. # ranges puts (0..10).each { |x| puts x } puts (’a’..’z’).each { |x| puts x } 3.5 - Estruturas de controle Para utilizar estruturas de controle em ruby, precisamos antes conhecer os operadores boobleanos, true e false. Os operadores booleanos aceitam quaisquer expressões aritméticas: >> 3 > 2 => true >> 3+4-2 <= 3*2/4 => false Os operadores booleanos são: ==, >, <, >= e <=. Expressões booleanas podem ainda ser combinadas com os operadores && (and) e || (or). O if do ruby aceita qualquer expressão booleana, no entanto, cada objeto em Ruby possui um “valor booleano”. Os únicos objetos de valor booleano false são o próprio false e o nil. Portanto, qualquer valor pode ser usado como argumento do if: >> variavel = nil => nil >> if(variavel) Capítulo 3 - Classes, objetos e métodos - Exercícios - Tipos - Página 12
  • 24. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails >> puts("so iria imprimir se variavel != null") >> end => nil >> if(3 == 3) >> puts("3 é 3") >> end 3 é 3 => nil Teste também o switch: def proucura_sede_copa_do_mundo( ano ) case ano when 1895..1993 "Não lembro... :)" when 1994 "Estados Unidos" when 1998 "França" end end puts proucura_sede_copa_do_mundo(1994) O código acima funciona como uma série de if/elsif : if 1994 == ano "Estados Unidos" elsif 1998 == ano "França" elsif 1895..1993 == ano "Não lembro... :)" end Utilizar um laço de repetições pode poupar muito trabalho. Em ruby o código é bem direto: for i in (1..3) x = i end Ruby possui bom suporte a expressões regulares, fortemente influenciado pelo Perl. Expressões regulares literais são delimitadas por / (barra). >> /rio/ =~ "são paulo" => nil >> /paulo/ =~ "são paulo" => 4 O operador =~ faz a função de match e retorna a posição da String onde o padrão foi encontrado, ou nil caso a String não bata com a expressão regular. Expressões regulares aparecem com uma frequência maior em linguagens dinâmicas, e, também por sua sintaxe facilitada no Ruby, utilizaremos bastante. Capítulo 3 - Classes, objetos e métodos - Estruturas de controle - Página 13
  • 25. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Rubular.com Um site muito interessante para testar Expressões Regulares é o http://rubular.com/ MatchData Há também o método match, que retorna um objeto do tipo MatchData, ao invés da posição do match. O objeto retornado pelo método match contém diversas informações úteis sobre o resultado da expressão regular, como o valor de agrupamentos (captures) e posições (offset) em que a expressão regular bateu. Operador ou igual O operador ||= atribui um valor apenas a variável esteja vazia. é muito utilizado para carregar valores de maneira “lazy”. nome ||= "anonimo" Nesse caso, se nome é nulo, ele será preenchido com "anonimo . 3.6 - Exercícios - Estruturas de controle e Regexp 1) Nosso restaurante pode ter notas boas se a mesma for superior a 7, ou ruim caso contrário. # estruturas de controle: if nota = 10 if nota > 7 puts "Boa nota!" else puts "Nota ruim!" end Teste com notas diferentes e verifique as saídas no terminal. 2) Implemente um for em ruby: # estruturas de controle: for for i in (1..3) x = i end puts x 3) Teste o operado de expressões regulares “” puts /rio/ =~ "são paulo" # nil puts /paulo/ =~ "são paulo" # 3 Abra o site http://rubular.com/ e teste outras expressões regulares! 4) O operador “||=” é considerado uma forma elegande de fazer um if. Verifique se uma variável já foi preen- chinda, caso não estiver, vamos atribuir um valor a ela. Capítulo 3 - Classes, objetos e métodos - Exercícios - Estruturas de controle e Regexp - Página 14
  • 26. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails restaurante ||= "Fogo de Chao" puts restaurante 3.7 - Desafios 1) Sem tentar executar o código abaixo, responda: Ele funciona? Por que? resultado = 10 + 4 texto = "O valor é " + resultado puts(texto) 2) E o código abaixo, deveria funcionar? Por que? puts(1+2) 3) Baseado na sua resposta da primeira questão, por que o código abaixo funciona? resultado = 10 + 3 texto = "O valor é: #{resultado}" 4) Qual a saída deste código? resultado = 10 ** 2 puts(’o resultado é: #{resultado}’) 5) (Para Casa) Pesquise sobre outras maneiras de criar Strings literais em Ruby. 6) Por que a comparação entre símbolos é muito mais rápida que entre Strings? simbolo1 = :abc simbolo2 = :abc simbolo1 == simbolo2 # => true texto1 = "abc" texto2 = "abc" texto1 == texto2 # => true Capítulo 3 - Classes, objetos e métodos - Desafios - Página 15
  • 27. C APÍTULO 4 Mais Ruby: classes, objetos e métodos “Uma imagem vale mais que mil palavras” – Napoleão Bonaparte 4.1 - Mundo orientado a objetos Ruby é uma linguagem puramente orientada a objetos, bastante influenciada pelo Smalltalk. Desta forma, tudo em Ruby é um objeto, até mesmo os tipos básicos que vimos até agora. Uma maneira simples de visualizar isso é através da chamada de um método em qualquer um dos objetos: "strings são objetos".upcase() :um_simbolo.object_id() Até os números inteiros são objetos, da classe Fixnum: 10.class() 4.2 - Métodos comuns Uma das funcionalidades comuns a diversas linguagens orientadas a objeto está na capacidade de, dado um objeto, descobrir de que tipo ele é. No ruby, existe um método chamado class(), que retorna o tipo do objeto, enquanto object_id(), retorna o número da referência, ou identificador único do objeto dentro da memória heap. Outro método comum a essas linguagens, é aquele que “transforma” um objeto em uma String, geralmente usado para log. O Ruby também disponibiliza esse método, através da chamada ao to_s(). Adicionalmente aos tipos básicos, podemos criar nossos próprios objetos, que já vem com esses métodos que todo objeto possui (class, object_id). Para criar um objeto em Ruby, basta invocar o método new na classe que desejamos instanciar. O exemplo a seguir mostra como instanciar um objeto: # criando um objeto objeto = Object.new() 4.3 - Definição de métodos def é uma palavra chave do Ruby para a definição (criação) de métodos, que podem, claro, receber parâ- metros: 16
  • 28. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails def pessoa.vai(lugar) puts "indo para " + lugar end Mas, e o retorno de um método? Como funciona? Para diminuir o excesso de código que as linguagens costumam introduzir (chamado de ruído sintático), o Ruby optou por retornar o resultado da execução da última instrução executada no método. O exemplo a seguir mostra um método que devolve uma String: def pessoa.vai(lugar) "indo para " + lugar end Para visualizar esse retorno funcionando, podemos acessar o método e imprimir o retorno do mesmo: puts pessoa.vai("casa") Podemos ainda refatorar o nosso método para usar interpolação: def pessoa.vai(lugar) "indo para #{lugar}" end Para receber vários argumentos em um método, basta separá-los por vírgula: def pessoa.troca(roupa, lugar) "trocando de #{roupa} no #{lugar}" end A invocação desses métodos é feita da maneira tradicional: pessoa.troca(’camiseta’, ’banheiro’) Alguns podem até ter um valor padrão, fazendo com que sejam opcionais: def pessoa.troca(roupa, lugar=’banheiro’) "trocando de #{roupa} no #{lugar}" end # invocacao sem o parametro: pessoa.troca("camiseta") # invocacao com o parametro: pessoa.troca("camiseta", "sala") 4.4 - Exercícios - Métodos 1) Métodos são uma das formas com que os objetos se comunicam. Vamos utilizar os conceitos vistos no capítulo anterior porém indo um pouco mais além na orientação a objetos agora. • Crie mais um arquivo no seu diretório ruby chamado restaurante_avancado. Ao final de cada exercício voce pode rodar o arquivo no terminal com o comando ruby restau- rante_avancado.rb. Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exercícios - Métodos - Página 17
  • 29. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 2) Vamos simular um método que atribui uma nota a um restaurante. # declaração do método def qualifica(nota) puts "A nota do restaurante foi #{nota}" end # chamada do método qualifica(10) 3) Podemos ter parametros opcionais em ruby utilizando um valor padrão. def qualifica(nota, msg="Obrigado") puts "A nota do restaurante foi #{nota}. #{msg}" end # chamadas com parametros opcionais qualifica(10) qualifica(1, "Comida ruim.") 4.5 - Discussão: Enviando mensagens aos objetos 1) Na orientação a objetos a chamada de um método é análoga ao envio de uma mensagem ao objeto. Cada objeto pode reagir de uma forma diferente à mesma mensagem, ao mesmo estímulo. Isso é o polimorfismo. Seguindo a idéia de envio de mensagens, uma maneira alternativa de chamar um método é usar o método send(), que todo objeto em Ruby possui. pessoa.send(:fala) O método send recebe como argumento o nome do método a ser invocado, que pode ser um símbolo ou uma string. De acordo com a orientação a objetos é como se estivéssemos enviando a mensagem “fala” ao objeto pessoa. Além da motivação teórica, você consegue enxergar um outro grande benefício dessa forma de invocar métodos, através do send()? Qual? 4.6 - Classes Para não precisar adicionar sempre todos os métodos em todo objeto que criamos, Ruby possui classes, que atuam como fábricas (molde) de objetos. Classes possibilitam a criação de objetos já incluindo alguns métodos. class Pessoa def fala puts "Sei Falar" end def troca(roupa, lugar="banheiro") "trocando de #{roupa} no #{lugar}" end end Capítulo 4 - Mais Ruby: classes, objetos e métodos - Discussão: Enviando mensagens aos objetos - Página 18
  • 30. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails p = Pessoa.new # o objeto apontado por p já nasce com os métodos fala e troca. Todo objeto em Ruby possui o método class, que retorna a classe que originou este objeto (note que os parênteses podem ser omitidos na chamada e declaração de métodos): p.class # => Pessoa O diferencial de classes em Ruby é que são abertas. Ou seja, qualquer classe pode ser alterada a qualquer momento na aplicação. Basta “reabrir” a classe e fazer as mudanças: class Pessoa def novo_metodo # ... end end Caso a classe Pessoa já exista estamos apenas reabrindo sua definição para adicionar mais código. Não será criada uma nova classe e nem haverá um erro dizendo que a classe já existe. 4.7 - Exercícios - Classes 1) Nosso método qualifica não pertence a nenhuma classe atualmente. Crie a classe Restaurante e instancie o objeto. class Restaurante def qualifica(nota, msg="Obrigado") puts "A nota do restaurante foi #{nota}. #{msg}" end end 2) Crie dois objetos, com chamadas diferentes. restaurante_um = Restaurante.new restaurante_dois = Restaurante.new restaurante_um.qualifica(10) restaurante_dois.qualifica(1, "Ruim!") 4.8 - Desafio: Classes abertas 1) Qualquer classe em Ruby pode ser reaberta e qualquer método redefinido. Inclusive classes e métodos da biblioteca padrão, como Object e Fixnum. Podemos redefinir a soma de números reabrindo a classe Fixnum? Isto seria útil? class Fixnum def +(outro) self - outro # fazendo a soma subtrair Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exercícios - Classes - Página 19
  • 31. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails end end 4.9 - self Um método pode invocar outro método do próprio objeto. Para isto, basta usar a referência especial self, que aponta para o para o próprio objeto. É análogo ao this de outras linguagens como Java e C#. Todo método em Ruby é chamado em algum objeto, ou seja, um método é sempre uma mensagem enviada a um objeto. Quando não especificado, o destino da mensagem é sempre self: class Conta def transfere_para(destino, quantia) debita quantia # mesmo que self.debita(quantia) destino.deposita quantia end end 4.10 - Desafio: self e o método puts 1) Vimos que todo método é sempre chamado em um objeto. Quando não especificamos o objeto em que o método está sendo chamado, Ruby sempre assume que seja em self. Como tudo em Ruby é um objeto, todas as operações devem ser métodos. Em especial, puts não é uma operação, muito menos uma palavra reservada da linguagem. puts "ola!" Em qual objeto é chamado o método puts? Por que podemos chamar puts em qualquer lugar do programa? (dentro de classes, dentro de métodos, fora de tudo, ...) 2) Se podemos chamar puts em qualquer self, por que o código abaixo não funciona? (Teste!) obj = "uma string" obj.puts "todos os objetos possuem o método puts?" 3) (opcional) Pesquise onde (em que classe ou algo parecido) está definido o método puts. Uma boa dica é usar a documentação oficial da biblioteca padrão: http://ruby-doc.org 4.11 - Atributos e propriedades: acessores e modificadores Atributos, também conhecidos como variáveis de instância, em Ruby são sempre privados e começam com @. Não há como alterá-los de fora da classe; apenas os métodos de um objeto podem alterar os seus atributos (encapsulamento!). class Pessoa def muda_nome(novo_nome) @nome = novo_nome Capítulo 4 - Mais Ruby: classes, objetos e métodos - self - Página 20
  • 32. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails end def diz_nome "meu nome é #{@nome}" end end p = Pessoa.new p.muda_nome "João" p.diz_nome # => "João" Podemos fazer com que algum código seja executado na criação de um objeto. Para isso, todo objeto pode ter um método especial, chamado de initialize: class Pessoa def initialize puts "Criando nova Pessoa" end end Pessoa.new # => "Criando nova Pessoa" Os initializers são métodos privados (não podem ser chamados de fora da classe) e podem receber parâ- metros. Veremos mais sobre métodos privados adiante. class Pessoa def initialize(nome) @nome = nome end end joao = Pessoa.new("João") Métodos acessores e modificadores são muito comuns e dão a idéia de propriedades. Existe uma convenção para a definição destes métodos, que a maioria dos desenvolvedores Ruby segue (assim como Java tem a convenção para getters e setters): class Pessoa def nome # acessor @nome end def nome=(novo_nome) @nome = novo_nome end end pessoa = Pessoa.new pessoa.nome=("José") puts pessoa.nome Capítulo 4 - Mais Ruby: classes, objetos e métodos - Atributos e propriedades: acessores e modificadores - Página 21
  • 33. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails # => "José" 4.12 - Syntax Sugar: facilitando a sintaxe Desde o início, Matz teve como objetivo claro fazer com que Ruby fosse uma linguagem extremamente legível. Portanto, sempre que houver oportunidade de deixar determinado código mais legível, Ruby o fará. Um exemplo importante é o modificador que acabamos de ver (nome=). Os parenteses na chamada de métodos são quase sempre opcionais, desde que não haja ambiguidades: pessoa.nome= "José" Para ficar bastante parecido com uma simples atribuição, bastaria colocar um espaço antes do ’=’. Priori- zando a legibilidade, Ruby abre mão da rigidez sintática em alguns casos, como este: pessoa.nome = "José" Apesar de parecer, a linha acima não é uma simples atribuição, já que na verdade o método nome= está sendo chamado. Este recurso é conhecido como Syntax Sugar, já que o Ruby aceita algumas exceções na sintaxe para que o código fique mais legível. A mesma regra se aplica às operações aritméticas que havíamos visto. Os números em Ruby também são objetos! Experimente: 10.class # => Fixnum Os operadores em Ruby são métodos comuns. Tudo em ruby é um objeto e todas as operações funcionam como envio de mensagens. 10.+(3) Ruby tem Syntax Sugar para estes métodos operadores matemáticos. Para este conjunto especial de métodos, podemos omitir o ponto e trocar por um espaço. Como com qualquer outro método, os parenteses são opcionais. 4.13 - Exercícios - Atributos e propriedades 1) Crie um initialize no Restaurante. class Restaurante def initialize puts "criando um novo restaurante" end # não apague o método ’qualifica’ end Rode o exemplo e verifique a chamada ao ínitialize. 2) Cada restaurante da nossa aplicação precisa de um nome diferente. Vamos criar o atributo e suas propriedades de acesso. class Restaurante def initialize(nome) Capítulo 4 - Mais Ruby: classes, objetos e métodos - Syntax Sugar: facilitando a sintaxe - Página 22
  • 34. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails puts "criando um novo restaurante: #{nome}" end # não apague o método ’qualifica’ end # crie dois nomes diferentes restaurante_um = Restaurante.new("Fazano") restaurante_dois = Restaurante.new("Fogo de Chao") 3) Embora nossos objetos tenham agora recebido um nome, esse nome não foi guardado em nenhuma variável. class Restaurante def initialize(nome) puts "criando um novo restaurante: #{nome}" @nome = nome end # altere o método qualifica def qualifica(nota, msg="Obrigado") puts "A nota do #{@nome} foi #{nota}. #{msg}" end end 4) Repare que a váriável nome é uma variável de instância de Restaurante. Em ruby, o “@” definiu esse comportamento. Agora vamos fazer algo parecido com o atributo nota e suas propriedades de acesso. class Restaurante def initialize(nome) puts "criando um novo restaurante: #{nome}" @nome = nome end # altere o método qualifica def qualifica(msg="Obrigado") puts "A nota do #{@nome} foi #{@nota}. #{msg}" end # propriedades def nota=(nota) @nota = nota end def nota @nota end end restaurante_um = Restaurante.new("Fazano") restaurante_dois = Restaurante.new("Fogo de Chao") Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exercícios - Atributos e propriedades - Página 23
  • 35. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails restaurante_um.nota = 10 restaurante_dois.nota = 1 restaurante_um.qualifica restaurante_dois.qualifica("Comida ruim.") 5) Seria muito trabalhoso definir todas as propriedades de acesso a nossa variáveis. Refatore a classe Restaurante para utilizar o attr_accessor :nota Seu arquivo final deve ficar assim: class Restaurante attr_accessor :nota def initialize(nome) puts "criando um novo restaurante: #{nome}" @nome = nome end def qualifica(msg="Obrigado") puts "A nota do #{@nome} foi #{@nota}. #{msg}" end end restaurante_um = Restaurante.new("Fazano") restaurante_dois = Restaurante.new("Fogo de Chao") restaurante_um.nota = 10 restaurante_dois.nota = 1 restaurante_um.qualifica restaurante_dois.qualifica("Comida ruim.") 4.14 - Coleções Arrays em Ruby são instâncias da classe Array, não sendo simplesmente uma estrutura de dados, mas possuindo diversos métodos auxiliares que nos ajudam no dia-a-dia. Um exemplo simples e encontrado em objetos de tipo Array em várias linguagens é o que permite a inclusão de elementos e size que nos retorna a quantidade de elementos lá dentro. lista = Array.new lista << "RR-71" lista << "RR-75" lista << "FJ-91" puts lista.size # => 3 A tarefa mais comum ao iteragir com array é a de resgatar os elementos e para isso usamos [] passando um índice como parametro: puts lista[1] Capítulo 4 - Mais Ruby: classes, objetos e métodos - Coleções - Página 24
  • 36. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails # => "RR-75" puts lista[0] # => "RR-71" Muitas vezes já sabemos de antemão o que desejamos colocar dentro da nossa array e o Ruby fornece uma maneira literal de declará-la: lista = [1, 2, "string", :simbolo, /$regex^/] puts lista[2] # => string Um exemplo que demonstra uma aparição de arrays é a chamada ao método methods, que retorna uma array com os nomes de todos os métodos que o objeto sabe responder naquele instante. Esse método é definido na classe Object então todos os objetos o possuem: cliente = "Petrobras" puts cliente.methods 4.15 - Exemplo: múltiplos parâmetros Em alguns instantes desejamos receber um número arbitrário de argumentos em um método, por exemplo a lista de produtos que estamos comprando em um serviço: def compra(produto1, produto2, produto3, produtoN) end Para receber um número qualquer de parâmetros usamos a sintaxe * do Ruby: def compra(*produtos) # produtos é uma array puts produtos.size end Note que nesse caso, em Ruby receber uma array ou um número indeterminado de argumentos resulta no mesmo código interno ao método pois a variável produtos funciona como uma array. A mudança ocorre na sintaxe de chamada a esse método. Na versão mostrada acima, invocamos o método compra com diversos parâmetros: compra("Notebook", "Pendrive", "Cafeteira") Já no caso de definir o método recebendo uma array, somos obrigados a definir uma array no momento de invocá-lo: def compra(produtos) # produtos é uma array puts produtos.size end compra( ["Notebook", "Pendrive", "Cafeteira"] ) O operador * é chamado de splat. Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exemplo: múltiplos parâmetros - Página 25
  • 37. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 4.16 - Hashes Mas nem sempre desejamos trabalhar com arrays cuja maneira de encontrar o que está lá dentro é através de um número. Por exemplo, ao ler um arquivo de configuração de um servidor desejamos saber qual a porta e se ele deve ativar o suporte ssh: porta = 80 ssh = false nome = Caelum.com.br Nesse caso não desejamos acessar uma array através de inteiros (Fixnum), mas sim o valor correspondente as chaves “porta”, “ssh” e “nome”. Ruby também tem uma estrutura indexada por qualquer objeto, onde as chaves podem ser de qualquer tipo, o que permite atingir nosso objetivo. A classe Hash é quem dá suporte a essa funcionalidade, sendo análoga aos objetos HashMap, HashTable, arrays indexados por String e dicionários de outras linguagens. config = Hash.new config["porta"] = 80 config["ssh"] = false config["nome"] = "Caelum.com.br" puts config.size # => 3 puts config["ssh"] # => false Por serem únicos e imutáveis, símbolos são ótimos candidatos a serem chaves em Hashes, portanto pode- ríamos trabalhar com: config = Hash.new config[:porta] = 80 Ao invocar um método com um número maior de parâmetros, o código fica pouco legível, já que Ruby não possui tipagem explícita, apesar de esta não ser a única causa. Imagine que tenho uma conta bancária em minhas mãos e desejo invocar o método de transferência, que requer a conta destino, a data na qual o valor será transferido e o valor. Então tento invocar: aluno = Conta.new escola = Conta.new # Time.now gera um objeto Time que representa "agora" aluno.transfere(escola, Time.now, 50.00) No momento de executar o método descobrimos que a ordem dos parâmetros era incorreta, o valor deveria vir antes da data, de acordo com a definição do método: class Conta def transfere(destino, valor, data) # executa a transferencia end Capítulo 4 - Mais Ruby: classes, objetos e métodos - Hashes - Página 26
  • 38. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails end Mas só descobrimos esse erro ao ler a definição do método na classe original, e para contornar esse problema, existe um movimento que se tornou comum com a popularização do Rails 2, passando parâmetro através de hash: aluno.transfere( {:destino => escola, :data => Time.now, :valor => 50.00} ) Note que o uso do Hash implicou em uma legibilidade maior apesar de uma proliferação de palavras: def transfere(argumentos) destino = argumentos[:destino] data = argumentos[:data] valor = argumentos[:valor] # executa a transferência end Isso acontece pois a semântica de cada parâmetro fica explícita para quem lê o código, sem precisar olhar a definição do método para lembrar o que eram cada um dos parâmetros. Combinando Hashes e não Hashes Variações nos símbolos permitem melhorar ainda mais a legibilidade, por exemplo: class Conta def transfere(valor, argumentos) destino = argumentos[:para] data = argumentos[:em] # executa a transferência end end aluno.transfere(50.00, {:para => escola, :em => Time.now}) Para quem utiliza Ruby 1.9, ao criar um Hash onde a chave é um símbolo, podemos utilizar uma outra sintaxe que por vezes se torna mais legível: aluno.transfere(50.00, {para: escola, em: Time.now}) Além dos parênteses serem sempre opcionais, quando um Hash é o último parâmetro de um método, as chaves podem ser omitidas (Syntax Sugar ). aluno.transfere :destino => escola, :valor => 50.0, :data => Time.now 4.17 - Exercícios - Arrays e Hashes 1) No seu diretório ruby crie mais um arquivo chamado listas.rb. Teste um array adicionando dois elementos. nomes = [] nomes[0] = "Fazano" nomes << "Fogo de Chao" Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exercícios - Arrays e Hashes - Página 27
  • 39. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails for nome in nomes puts nome end 2) Vamos juntar os conhecimentos de classes e métodos para criar uma franquia onde podemos adicionar uma lista de restaurantes. Para isso teremos que criar na inicialização um array de restaurantes. class Franquia def initialize @restaurantes = [] end def adiciona(restaurante) @restaurantes << restaurante end def mostra for restaurante in @restaurantes puts restaurante.nome end end end class Restaurante attr_accessor :nome end restaurante_um = Restaurante.new restaurante_um.nome = "Fazano" restaurante_dois = Restaurante.new restaurante_dois.nome = "Fogo de Chao" franquia = Franquia.new franquia.adiciona restaurante_um franquia.adiciona restaurante_dois franquia.mostra 3) O método adiciona recebe apenas um restaurante. Podemos usar a syntax com * e refatorar o método para permitir multiplos restaurantes como parâmentro. # refatore o método adiciona def adiciona(*restaurantes) for restaurante in restaurantes @restaurantes << restaurante end end Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exercícios - Arrays e Hashes - Página 28
  • 40. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails # adicione ambos de uma só vez franquia.adiciona restaurante_um, restaurante_dois 4) Hashes são muito úteis para passar valores indentificados nos parâmentros. Na classe restaurante adicione o método fechar_compra e faça a chamada. def fechar_conta(dados) puts "Conta fechado no valor de #{dados[:valor]} e com nota #{dados[:nota]}. Comentário: #{dados[:comentario]}" end restaurante_um.fechar_conta :valor => 50, :nota => 9, :comentario => ’Gostei!’ 4.18 - Blocos e Programação Funcional Imagine o exemplo a seguir que soma o saldo das contas de um banco: class Banco def initialize(contas) @contas = contas end def status saldo = 0 for conta in @contas saldo += conta end saldo end end banco = Banco.new([200, 300, 400]) banco.status Esse processo é executado em diversos pontos da nossa aplicação e todos eles precisam exatamente desse comportamento. Em um dia ensolarado, um ponto de nossa aplicação passa a necessitar da impressão dos saldos parciais, isso é que cada soma seja impressa. Como fazer isso sem alterar os outros tantos pontos de execução e sem duplicação de código? O primeiro passo é perceber a necessidade que temos de inserir um código novo, desejamos incluir o seguinte código: for conta in @contas saldo += conta puts saldo # essa linha é nova end Então na chamada específica desse método, passemos esse código como “parâmetro": Capítulo 4 - Mais Ruby: classes, objetos e métodos - Blocos e Programação Funcional - Página 29
  • 41. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails banco.status do |saldo| puts saldo end Isso não é um parâmetro, e sim um bloco de código, o código que desejamos executar. Note que esse bloco recebe um parâmetro chamado *saldo* e que esse parâmetro é o saldo parcial que desejamos imprimir. Para facilitar a leitura podemos renomea-lo para *saldo_parcial*: banco.status do |saldo_parcial| puts saldo_parcial end Imagine que o bloco funciona exatamente como a definição de uma função em ruby: ele pode receber parâmetros e ser invocado. Falta invocá-lo no código do banco, para dar a chance de execução a cada chamada do laço: class Banco # initialize... def status(&block) saldo = 0 for conta in @contas saldo += conta block.call(saldo) end saldo end end Note que block é um objeto que ao ter o método call invocado, chamará o bloco que foi passado, concluindo nosso primeiro objetivo: dar a chance de quem se interessar no saldo parcial, fazer algo com ele. Qualquer outro tipo de execução, como outros cálculos, que eu desejar fazer para cada saldo, posso fazê-lo passando blocos distintos. Ainda faltou manter compatibilidade com aquelas chamadas que não possuem bloco. Para isso, basta verificarmos se foi passado algum bloco como parâmetro para nossa função, e somente nesse caso invocá-lo. Isto é, se o bloco foi dado (block_given?), então invoque o bloco: for conta in @contas saldo += conta if block_given? block.call(saldo) end end Outra sintaxe de bloco Existe uma outra sintaxe que podemos utilizar para passar blocos que envolve o uso de chaves: banco.status { |saldo_parcial| puts saldo_parcial } Capítulo 4 - Mais Ruby: classes, objetos e métodos - Blocos e Programação Funcional - Página 30
  • 42. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Como vimos até aqui, o método que recebe um bloco pode decidir se deve ou não chamá-lo. Para chamar o bloco associado, existe uma outra abordagem com a palavra yield: if block_given? yield(saldo) end Nessa abordagem, não se faz necessário receber o argumento &block portanto o código do Banco seria: class Banco # initialize... def status saldo = 0 for conta in @contas saldo += conta if block_given? yield(saldo) end end saldo end end Entender quando usar blocos costuma parecer complicado no início, não se preocupe . Você pode enxergá- los como uma oportunidade do método delegar parte da responsabilidade a quem o chama, permitindo custo- mizações em cada uma de suas chamadas (estratégias diferentes, ou callbacks). A biblioteca padrão do Ruby faz alguns usos muito interessantes de blocos. Podemos analizar a forma de iterar em coleções, que é bastante influenciada por técnicas de programação funcional. Dizer que estamos passando uma função (pedaço de código) como parâmetro a outra função é o mesmo que passar blocos na chamada de métodos. Para iterar em uma Array possuímos o método each, que chama o bloco de código associado para cada um dos seus items, passando o item como parâmetro ao bloco: lista = ["rails", "rake", "ruby", "rvm"] lista.each do |programa| puts programa end A construção acima não parece trazer muitos ganhos se comparada a forma tradicional e imperativa de iterar em um array (for). Imagine agora uma situação onde queremos colocar o nome de todos os funcionários em maiúsculo, isto é, aplicar uma função para todos os elementos de uma array, construindo uma array nova. funcionarios = ["Guilherme", "Sergio", "David"] nomes_maiusculos = [] for nome in funcionarios nomes_maiusculos << nome.upcase end Poderíamos usar o método each: Capítulo 4 - Mais Ruby: classes, objetos e métodos - Blocos e Programação Funcional - Página 31
  • 43. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails funcionarios = ["Guilherme", "Sergio", "David"] nomes_maiusculos = [] funcionarios.each do |nome| nomes_maiusculos << nome.upcase end Mas as duas abordagens envolvem o conceito de dizer a linguagem que queremos adicionar um elemento a uma lista existente: o trabalho é imperativo. Lembrando que o bloco, assim como uma função qualquer, possui retorno, seria muito mais compacto se pudéssemos exprimir o desejo de criar a array diretamente: funcionarios = ["Guilherme", "Sergio", "David"] nomes_maiusculos = funcionarios.cria_uma_array O código dessa função deve iterar por cada elemento, adicionando eles dentro da nossa array, *exatamente* como havíamos feito antes: class Array def cria_uma_array array = [] self.each do |elemento| array << elemento.upcase end array end end Mas podemos reclamar que o método upcase nem sempre vai funcionar: a cada chamada de cria_uma_array queremos executar um comportamento diferente. E essa é a dica para utilização de blocos: passe um bloco que customiza o comportamento do método cria_uma_array: nomes_maiusculos = funcionarios.cria_uma_array do |nome| nome.upcase end E faça o cria_uma_array invocar esse bloco: class Array def cria_uma_array array = [] self.each do |elemento| array << yield(elemento) end end end Esse método que criamos já existe e se chama map (ou collect), que coleta os retornos de tomas as chamadas do bloco associado: funcionarios = ["Guilherme", "Sergio", "David"] Capítulo 4 - Mais Ruby: classes, objetos e métodos - Blocos e Programação Funcional - Página 32
  • 44. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails nomes_maiusculos = funcionarios.map do |nome| nome.upcase end Na programação imperativa tradicional precisamos de no mínimo mais duas linhas, para o array auxiliar e para adicionar os items maiúsculos no novo array. Diversos outros métodos do módulo Enumerable seguem a mesma idéia: find, find_all, grep, sort, inject. Não deixe de consultar a documentação, que pode ajudar a criar código mais compacto. Só tome cuidado pois código mais compacto nem sempre é mais legível e fácil de manter. 4.19 - Exercícios - Blocos 1) Refatore o método mostra do Restaurante para iterar sobre os elementos usando blocos. def mostra @restaurantes.each do |r| puts r.nome end end 2) Crie um método relatorio que envia a lista de restaurantes da franquia. Repare que esse método não são o que ocorrerá com cada item da lista. Ele disponibiliza os itens e é o bloco passado que define o que fazer com eles. def relatorio @restaurantes.each do |r| yield r end end # chamada com blocos franquia.relatorio do |r| puts "Restaurante cadastrado: #{r.nome}" end 4.20 - Para saber mais: Mais sobre blocos Analise e rode o código abaixo, olhe na documentação o método sort_by e teste o next. caelum = [ {:ruby => ’rr-71’, :java => ’fj-11’}, {:ruby => ’rr-75’, :java => ’fj-21’} ] caelum.sort_by { |curso| curso[:ruby] }.each do |curso| puts "Curso de RoR na Caelum: #{ curso[:ruby] }" end caelum.sort_by { |curso| curso[:ruby] }.each do |curso| Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exercícios - Blocos - Página 33
  • 45. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails next if curso[:ruby] == ’rr-71’ puts "Curso de RoR na Caelum: #{ curso[:ruby] }" end 4.21 - Desafio: Usando blocos 1) Queremos imprimir o nome de todos os alunos de uma turma com o código a seguir: fj91 = Turma.new("Guilherme", "Paulo", "Paniz") fj91.each do |nome| puts nome end Crie a sua classe Turma que durante a invocação do método each, itera por todos os nomes passados em seu construtor. Tente lembrar dos conceitos de blocos e programação funcional para resolver. A biblioteca padrão do Ruby faz usos bastante interessante de módulos como mixins. Os principais exemplos são os módulos Enumerable e Comparable. 4.22 - Manipulando erros e exceptions Uma exception é um tipo especial de objeto que extende ou é uma instância da classe Exception. Lançar uma exception significa que algo não esperado ou errado ocorreu no fluxo do programa. Raising é a palavra usada em ruby para lançamento de exceptions. Para tratar uma exception é necessário criar um código a ser executado caso o programa receba o erro. Para isso existe a palavra rescue. Exceptions comuns A lista abaixo mostra as exceptions mais comuns em ruby e quando são lançadas, todas são filhas de Exception. Nos testes seguintes você pode usar essas exceptions. • RuntimeError : É a exception padrão lançada pelo método raise. • NoMethodError : Quando um objeto recebe como paramêtro de uma mensagem um nome de método que não pode ser encontrado. • NameError : O interpretador não encontra uma variável ou método com o nome passado. • IOError : Causada ao ler um stream que foi fechado, tentar escrever em algo read-only e situações similares. • Errno::error : É a família dos erros de entrada e saída (IO). • TypeError : Um método recebe como argumento algo que não pode tratar. • ArgumentError : Causada por número incorreto de argumentos. Capítulo 4 - Mais Ruby: classes, objetos e métodos - Desafio: Usando blocos - Página 34
  • 46. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 4.23 - Exercício: Manipulando exceptions 1) Em um arquivo ruby crie o código abaixo para testar exceptions. O método gets recupera o valor digitado. Teste também outros tipos de exceptions e digite um número inválido para testar a exception. print "Digite um número:" numero = gets.to_i begin resultado = 100 / numero rescue puts "Número digitado inválido!" exit end puts "100/#{numero} é #{resultado} " 2) (opcional) Exceptions podem ser lançadas com o comando raise. Crie um método que lança uma exception do tipo ArgumentError e capture-a com rescue. def verifica_idade(idade) unless idade > 18 raise ArgumentError, "Você precisa ser maior de idade para jogar jogos violentos." end end verifica_idade(17) 3) (opcional) É possível utilizar sua própria exception criando uma classe e extendendo de Exception. class IdadeInsuficienteException < Exception end def verifica_idade(idade) raise IdadeInsuficienteException, "Você precisa ser maior de idade para jogar jogos violentos." unless idade > 18 end Para testar o rescue dessa exception invoque o método com um valor inválido: begin verifica_idade(13) rescue IdadeInsuficienteException => e puts "Foi lançada a exception: #{e}" end Capítulo 4 - Mais Ruby: classes, objetos e métodos - Exercício: Manipulando exceptions - Página 35
  • 47. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Throw e catch Ruby possui também throw e catch que podem ser utilizados com símbolos e a sintaxe lembra a de Erlang, onde catch é uma função que, se ocorrer algum throw com aquele label, retorna o valor do throw atrelado: def pesquisa_banco(nome) if nome.size<10 throw :nome_invalido, "Nome invalido, digite novamente" end # executa a pesquisa "cliente #{nome}" end def executa_pesquisa(nome) catch :nome_invalido do cliente = pesquisa_banco(nome) return cliente end end puts executa_pesquisa("ana") # => "Nome invalido, digite novamente" puts executa_pesquisa("guilherme silveira") # => cliente guilherme silveira 4.24 - Arquivos com código fonte ruby Todos os arquivos fonte, contendo código Ruby devem ter a extensão .rb para que o interpretador seja capaz de carregá-lo. Existem exceções onde a leitura dos arquivos é feita por outras bibliotecas e, nesses casos, o arquivo possui outras extensões. Para organizar seu código, é natural dividi-lo em vários arquivos e diretórios, bastando usar o método require para incluir o fonte de outro arquivo. Imagine o arquivo conta.rb: class Conta attr_reader :saldo def initialize(saldo) @saldo = saldo end end Agora podemos acessar uma conta bastando primeiro importar o arquivo que a define: require ’conta’ puts Conta.new(500).saldo Capítulo 4 - Mais Ruby: classes, objetos e métodos - Arquivos com código fonte ruby - Página 36
  • 48. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Caso a extensão .rb seja omitida, a extensão adequada será usada (.rb, .so, .class, .dll, etc). O Ruby procura pelo arquivo em alguns diretórios predefinidos (Ruby Load Path), incluindo o diretório atual. Assim como qualquer outra linguagem isso resulta em um possível Load Hell, onde não sabemos exata- mente de onde nossos arquivos estão sendo carregados. Tome bastante cuidado para a configuração de seu ambiente. Caminhos relativos ou absolutos podem ser usados para incluir arquivos em outros diretórios, sendo que o absoluto não é recomendado devido ao atrelamento claro com uma estrutura fixa que pode não ser encontrada ao portar o código para outra máquina: require ’modulo/funcionalidades/coisa_importante’ require ’/usr/local/lib/my/libs/ultra_parser’ Constantes do sistema A constante $:, ou $LOAD_PATH contém diretórios do Load Path: $: # => ["/Library/Ruby/Site/1.8", ..., "."] Existem diversas outras constantes que começam com $, todas elas que são resquícios de PERL e que, em sua grande maioria dentro do ambiente Rails, possuem alternativas mais compreensíveis como LOAD_PATH. O comando require carrega o arquivo apenas uma vez. Para executar a interpretação do conteúdo do arquivo diversas vezes, utilize o método load. load ’conta.rb’ load ’conta.rb’ # executado duas vezes! Portanto no irb (e em Ruby em geral) para recarregar um arquivo que foi alterado é necessário executar um load e não um require - que não faria nada. 4.25 - Para saber mais: um pouco de IO Para manipular arquivos de texto existe a classe File, que permite manipula-los de maneira bastante sim- ples, utilizando blocos: print "Escreva um texto: " texto = gets File.open( "caelum.txt", "w" ) do |f| f << texto end E para imprimir seu conteúdo: Dir[’caelum.txt’].each do |file_name| idea = File.read( file_name ) puts idea end Podemos lidar de maneira similar com requisições HTTP utilizando o código abaixo e imprimir o conteúdo do resultado de uma requisição: Capítulo 4 - Mais Ruby: classes, objetos e métodos - Para saber mais: um pouco de IO - Página 37
  • 49. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails require ’net/http’ Net::HTTP.start( ’www.caelum.com.br’, 80 ) do |http| print( http.get( ’/’ ).body ) end Capítulo 4 - Mais Ruby: classes, objetos e métodos - Para saber mais: um pouco de IO - Página 38
  • 50. C APÍTULO 5 Metaprogramação e Padrões de Projeto “A ciência nunca resolve um problema sem criar mais dez” – George Bernard Shaw 5.1 - Métodos de Classe Classes em Ruby também são objetos: Pessoa.class # => Class c = Class.new instancia = c.new Variáveis com letra maiúscula representam constantes em Ruby, que até podem ser modificadas, mas o interpretador gera um warning. Portanto, Pessoa é apenas uma constante que aponta para um objeto do tipo Class. Se classes são objetos, podemos definir métodos de classe como em qualquer outro objeto: class Pessoa # ... end def Pessoa.pessoas_no_mundo 100 end Pessoa.pessoas_no_mundo # => 100 Há um idiomismo para definir os métodos de classe dentro da própria definição da classe, onde self aponta para o próprio objeto classe. class Pessoa def self.pessoas_no_mundo 100 end # ... end 39
  • 51. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 5.2 - Para saber mais: Singleton Classes A definição class << object define as chamadas singleton classes em ruby. Por exemplo, uma classe normal em ruby poderia ser: class Pessoa def fala puts ’oi’ end end Podemos instanciar e invocar o método normalmente: p = Pessoa.new p.fala # imprime ’oi’ Entretanto, também é possível definir métodos apenas para esse objeto “p”, pois tudo em ruby, até mesmo as classes, são objetos, fazendo : class Pessoa def p.anda puts ’andando’ end end O método “anda” é chamado de singleton method do objeto “p”. Um singleton method “vive” em uma singleton class. Todo objeto em ruby possui 2 classes: • a classe a qual foi instanciado • sua singleton class A singleton class é exclusiva para guardar os métodos desse objeto, sem compartilhar com outras instâncias da mesma classe. Existe uma notação especial para definir uma singleton class: class << Pessoa def anda puts ’andando’ end end Definindo o código dessa forma temos o mesmo que no exemplo anterior, porém definindo o método anda explicitamente na singleton class.É possível ainda definir tudo na mesma classe: class Pessoa class << self def anda puts ’andando’ end end end Capítulo 5 - Metaprogramação e Padrões de Projeto - Para saber mais: Singleton Classes - Página 40
  • 52. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Mais uma vez o método foi definido apenas para um obejto, no caso , o objeto “Pessoa”, podendo ser executado com: Pessoa.anda 5.3 - Exercícios - Ruby Object Model 1) Crie um novo arquivo chamado metaprogramacao.rb. Independente da instância seria interessante saber o número total de restaurantes criados. Na mesma classe restaurante, crie uma variável de classe chamada total. class Restaurante def initialize(nome) puts "criando um novo restaurante: #{nome}" @@total ||= 0 @@total = @@total + 1 puts "Restaurantes criados: #{@@total}" @nome = nome end end Execute novamente e analise o resultado. 2) Crie um método self chamado relatorio que mostra a quantidade total de restaurantes instanciados. (Opcional: Com esse método, você pode limpar um pouco o initialize). def self.relatorio puts "Foram criados #{@@total} restaurantes" end # Faça mais uma chamada Restaurante.relatorio Método de Classe é diferente de static do Java Se você trabalha com java pode confundir o self com o static. Cuidado! O método definido como self roda apenas na classe, não funciona nas instâncias. Voce pode testar fazendo: Restaurante.relatorio restaurante_um.relatorio A invocação na instância dará um: NoMethodError: undefined method ‘relatorio’ for #<Restau- rante:0x100137b48 @nome="Fazano”, @nota=10> 3) Caso sua classe possua muitos métodos de classe, é recomendado agrupá-los. Muitos códigos ruby utilizaram essa técnica, inclusive no próprio Rails Sua classe ficará então assim: class Restaurante # initialize, qualifica ... class << self def relatorio Capítulo 5 - Metaprogramação e Padrões de Projeto - Exercícios - Ruby Object Model - Página 41
  • 53. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails puts "Foram criados #{@@total} restaurantes" end end end Execute e veja que o comportamento é o mesmo. 5.4 - Design Patterns: Singleton Como criar uma classe com a garantia de ser instanciada apenas uma vez ? Essa classe deveria ser capaz de verificar se alguma vez já foi instânciada e saber devolver sempre a mesma referência. Como visto anteriormente, em ruby, variáveis com @ são de instância e variáveis com @@ são variáveis de classe. Utilizando a idéia acima podemos criar uma classe simples de relatório, onde desejamos que apenas uma seja de fato criada. class Relatorio @@instance = Relatorio.new def self.instance return @@instance end end Dessa forma conseguimos criar o relatório apenas uma vez. Mas a implementação ainda apresenta pro- blemas. Ainda é possível instanciar o Relatório mais de uma vez. Para resolver esse problema e implentar a classe Relatório como um Singleton realmente, precisamos tornar privado o new da nossa classe. Dessa forma, apenas será possível acessar o Relatorio a partir do método instance. class Relatorio @@instance = Relatorio.new def self.instance return @@instance end private_class_method :new end # ambos relatorios referenciam o mesmo objeto relatorio1 = Relatorio.instance relatorio2 = Relatorio.instance Existe ainda uma maneira mais otimizada e produtiva de chegar no mesmo resultado. O ruby já vem com um módulo chamado Singleton. Basta inclui-lo na classe para ter o mesmo resultado. Você verá mais sobre módulos no decorrer do curso. require ’singleton’ class Relatorio Capítulo 5 - Metaprogramação e Padrões de Projeto - Design Patterns: Singleton - Página 42
  • 54. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails include Singleton end 5.5 - Exercicio: Design Pattern - Singleton 1) Crie o Relatório de forma a retornar sempre a mesma instância: class Relatorio @@instance = Relatorio.new def self.instance return @@instance end private_class_method :new end # ambos relatorios referenciam o mesmo objeto relatorio1 = Relatorio.instance relatorio2 = Relatorio.instance puts relatorio1 == relatorio2 2) Faça o mesmo teste, mas conhecendo agora o módulo Singleton do ruby: require ’singleton’ class Relatorio include Singleton end # ambos relatorios referenciam o mesmo objeto relatorio1 = Relatorio.instance relatorio2 = Relatorio.instance puts relatorio1 == relatorio2 5.6 - Convenções Métodos que retornam booleanos costumam terminar com ?, para que pareçam perguntas aos objetos: texto = "nao sou vazio" texto.empty? # => false Já vimos esta convenção no método respond_to?. Métodos que tem efeito colateral (alteram o estado do objeto, ou que costumem lançar exceções) geralmente terminam com ! (bang): conta.cancela! Capítulo 5 - Metaprogramação e Padrões de Projeto - Exercicio: Design Pattern - Singleton - Página 43
  • 55. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails A comparação entre objetos é feita através do método == (sim, é um método!). A versão original do método apenas verifica se as referências são iguais, ou seja, se apontam para os mesmos objetos. Podemos reescrever este comportamento e dizer como comparar dois objetos: class Pessoa def ==(outra) self.cpf == outra.cpf end end Na definição de métodos, procure sempre usar os parênteses. Para a chamada de métodos, não há con- venção. Prefira o que for mais legível. Nomes de variável e métodos em Ruby são sempre minúsculos e separados por ’_’ (underscore). Variáveis com nomes maiúsculo são sempre constantes. Para nomes de classes, utilize as regras de CamelCase, afinal nomes de classes são apenas constantes. 5.7 - Polimorfirmo Ruby também tem suporte a herança simples de classes: class Animal def come "comendo" end end class Pato < Animal def quack "Quack!" end end pato = Pato.new pato.come # => "comendo" Classes filhas herdam todos os métodos definidos na classe mãe. A tipagem em Ruby não é explícita, por isso não precisamos declarar quais são os tipos dos atributos. Veja este exemplo: class PatoNormal def faz_quack "Quack!" end end class PatoEstranho def faz_quack "Queck!" end end Capítulo 5 - Metaprogramação e Padrões de Projeto - Polimorfirmo - Página 44
  • 56. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails class CriadorDePatos def castiga(pato) pato.faz_quack end end pato1 = PatoNormal.new pato2 = PatoEstranho.new c = CriadorDePatos.new c.castiga(pato1) # => "Quack!" c.castiga(pato2) # => "Queck!" Para o criador de patos, não interessa que objeto será passado como parâmetro. Para ele basta que o objeto saiba fazer quack. Esta característica da linguagem Ruby é conhecida como Duck Typing. “If it walks like a duck and quacks like a duck, I would call it a duck.” 5.8 - Exercícios - Duck Typing 1) Para fazer alguns testes de herança e polimorfismo abra o diretório ruby e crie um novo arquivo chamado duck_typing.rb. Nesse arquivo faça o teste do restaurante herdando um método da classe Franquia. class Franquia def info puts "Restaurante faz parte da franquia" end end class Restaurante < Franquia end restaurante = Restaurante.new restaurante.info Execute o arquivo no terminal e verifique a utilização do método herdado. 2) Podemos em ruby fazer a sobreescrita do método e invocar o método da classe mãe. class Franquia def info puts "Restaurante faz parte da franquia" end end class Restaurante < Franquia def info super puts "Restaurante Fazano" end end Capítulo 5 - Metaprogramação e Padrões de Projeto - Exercícios - Duck Typing - Página 45
  • 57. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails restaurante = Restaurante.new restaurante.info 3) Como a linguagem ruby é implicitamente tipada, não temos a cgarantia de receber um objeto do tipo que esperamos. Isso faz com que acreditamos que o objeto é de um tipo específico caso ele possua um método esperado. Faça o teste abaixo: class Franquia def info puts "Restaurante faz parte da franquia" end end class Restaurante < Franquia def info super puts "Restaurante Fazano" end end # metodo importante # recebe franquia e invoca o método info def informa(franquia) franquia.info end restaurante = Restaurante.new informa restaurante 5.9 - Design Patterns: Template Method As operações de um sistema podem ser de diversos tipos e o que determida qual operação será realizada pode ser um simples variável. Dependendo da variável uma coisa pode ocorrer enquanto outra vez é necessário fazer outra. Para exemplificar melhor, vamos usar a classe Relatorio. Nosso relatório mostrará um conteúdo inicialmente em HTML. class Relatorio def imprime puts "<html>Dados do restaurante</html>" end end O que acontece caso um paramêtro defina o formato dos dados que o relatório precisa ser criado? class Relatorio def imprime(formato) if formato == :texto puts "*** Dados do restaurante ***" elsif formato == :html puts "<html>Dados do restaurante</html>" Capítulo 5 - Metaprogramação e Padrões de Projeto - Design Patterns: Template Method - Página 46
  • 58. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails else puts "formato desconhecido!" end end Para solucionar esse problema de forma orientada a objetos poderiamos criar uma classe abstrata que define o comportamento de um relatório, ou seja, que define que um relatório de ter um head, um body, um footer, etc. Mas como criar uma classe abstrata em Ruby ? Embora não exista a palavra chave reservada “abstract” o conceito permanece presente na linguagem. Vejamos: class Relatorio def imprime imprime_cabecalho imprime_conteudo end end A classe Relatorio agora possui os métodos que definem um relatório. Obviamente esses métodos podem ser invocados. A solução para isso normalmente é lançar uma exception nesses métodos não implementados. Agora que temos nossa classe abstrata, podemos criar subclasses de Relatorio que contém a implementação de cada um dos tipos, por exemplo para HTML: class HTMLRelatorio < Relatorio def imprime_cabecalho puts "<html>" end def imprime_conteudo puts "Dados do relatorio" end end class TextoRelatorio < Relatorio def imprime_cabecalho puts "***" end def imprime_conteudo puts "Dados do relatorio" end end Agora para usar nossos relatórios podemos fazer: relatorio = HTMLRelatorio.new relatorio.imprime relatorio = TextoRelatorio.new relatorio.imprime 5.10 - Exercicio Opcional: Design Pattern - Template Method Capítulo 5 - Metaprogramação e Padrões de Projeto - Exercicio Opcional: Design Pattern - Template Method - Página 47
  • 59. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 1) Crie a classe que define as obrigações de um relatório: class Relatorio def imprime imprime_cabecalho imprime_conteudo end end 2) Para termos implementações diferentes, crie um relatório HTML e um de texto puro: class HTMLRelatorio < Relatorio def imprime_cabecalho puts "<html>" end def imprime_conteudo puts "Dados do relatorio" end end class TextoRelatorio < Relatorio def imprime_cabecalho puts "***" end def imprime_conteudo puts "Dados do relatorio" end end 3) Utilize os relátorios com a chamada ao método imprime: relatorio = HTMLRelatorio.new relatorio.imprime relatorio = TextoRelatorio.new relatorio.imprime 5.11 - Modulos Modulos podem ser usados como namespaces: module Caelum module Validadores class ValidadorDeCpf # ... end class ValidadorDeRg Capítulo 5 - Metaprogramação e Padrões de Projeto - Modulos - Página 48
  • 60. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails # ... end end end validador = Caelum::Validadores::ValidadorDeCpf.new Ou como mixins, conjunto de métodos a ser incluso em outras classes: module Comentavel def comentarios @comentarios ||= [] end def recebe_comentario(comentario) self.comentarios << comentario end end class Revista include Comentavel # ... end revista = Revista.new revista.recebe_comentario("muito ruim!") puts revista.comentarios 5.12 - Design Patterns: Observer Como executar operações caso algo ocorra no sistema. Temos uma classe Restaurante e queremos manter avisados todos os objetos do sistema que se interessem em modificações nele. Nossa classe Franquia precisa executar o método alerta no caso class Franquia def alerta puts "Um restaurante foi qualificado" end end class Restaurante def qualifica(nota) puts "Restaurante recebeu nota #{nota}" end end Capítulo 5 - Metaprogramação e Padrões de Projeto - Design Patterns: Observer - Página 49
  • 61. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails restaurante = Restaurante.new restaurante.qualifica(10) Poderiamos chamar o método alerta direto ao final do método qualifica ou poderiamos passar como para- metro do método um observer para rodar. Porém essas maneiras acoplariam muito nosso código, por exemplo, não funcionariam para alertar mais de um observer. Uma saída é criar uma lista de observadores e executá-los ao final da operação. Para isso podemos ter um método que permite adicionar quantos objetos forem necessários serem alertados. class Restaurante def initialize @observers = [] end def adiciona_observer(observer) @observer << observer end def notifica # percorre todos os observers chamando o método alerta end # qualifica end restaurante = Restaurante.new restaurante.qualifica(10) Poder ser observado não é uma característica única de um objeto. Podemos utilizar essa estratégia de avisar componentes por todo o software. Por que não colocar o comportamento em uma classe responsável por isso. Utilizando herança tornaríamos nosso código observável. Ao invés de utilizar a herança novamente podemos utilizar os módulos para isso. Todo comportamento que faz do objeto ser um observer será colocado nesse módulo. module Observer def initialize @observers = [] end def adiciona_observer(observer) @observer << observer end def notifica # percorre todos os observers chamando o método alerta end end Capítulo 5 - Metaprogramação e Padrões de Projeto - Design Patterns: Observer - Página 50
  • 62. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails class Restaurante include Observer def qualifica(nota) puts "Restaurante recebeu nota #{nota}" notifica end end Modulo Observer O módulo acima já existe em ruby e é chamado de Observer. http://ruby-doc.org/core/classes/ Observable.html 5.13 - Desafio: Design Pattern - Observer 1) Crie um novo arquivo e implemente o Design Pattern Observer para Restaurante e Franquia. 5.14 - Metaprogramação Por ser uma linguagem dinâmica, Ruby permite adicionar outros métodos e operações aos objetos em tempo de execução. Imagine que tenho uma pessoa: pessoa = Object.new() O que aconteceria, se eu tentasse invocar um método inexistente nesse objeto? Por exemplo, se eu tentar executar pessoa.fala() O interpretador retornaria com uma mensagem de erro uma vez que o método não existe. Mas e se eu desejasse, em tempo de execução, adicionar o comportamento (ou método) fala para essa pessoa. Para isso, tenho que definir que uma pessoa possui o método fala: pessoa = Object.new() def pessoa.fala() puts "Sei falar" end Agora que tenho uma pessoa com o método fala, posso invocá-lo: pessoa = Object.new() def pessoa.fala() puts "Sei falar" end pessoa.fala() Capítulo 5 - Metaprogramação e Padrões de Projeto - Desafio: Design Pattern - Observer - Página 51
  • 63. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Tudo isso é chamado meta-programação, um recurso muito comum de linguagens dinâmicas. Meta- programação é a capacidade de gerar/alterar código em tempo de execução. Note que isso é muito diferente de um gerador de código comum, onde geraríamos um código fixo, que deveria ser editado na mão e a aplicação só rodaria esse código posteriormente. Levando o dinamismo de Ruby ao extremo, podemos criar métodos que definem métodos em outros objetos: class Aluno # nao sabe nada end class Professor def ensina(aluno) def aluno.escreve "sei escrever!" end end end juca = Aluno.new juca.respond_to? :escreve # => false professor = Professor.new professor.ensina juca juca.escreve # => "sei escrever!" A criação de métodos acessores é uma tarefa muito comum no desenvolvimento orientado a objetos. Os métodos são sempre muito parecidos e os desenvolvedores costumam usar recursos de geração de códigos das IDEs para automatizar esta tarefa. Já vimos que podemos criar código Ruby que escreve código Ruby (métodos). Aproveitando essa possi- bilidade do Ruby, existem alguns métodos de classe importantes que servem apenas para criar alguns outros métodos nos seus objetos. class Pessoa attr_accessor :nome end p = Pessoa.new p.nome = "Joaquim" puts p.nome # => "Joaquim" A chamada do método de classe attr_acessor, define os métodos nome e nome= na classe Pessoa. A técnica de código gerando código é conhecida como metaprogramação, ou metaprogramming, como já definimos. Outro exemplo interessante de metaprogramação é como definimos a visibilidade dos métodos em Ruby. Por padrão, todos os métodos definidos em uma classe são públicos, ou seja, podem ser chamados por qualquer um. Capítulo 5 - Metaprogramação e Padrões de Projeto - Metaprogramação - Página 52
  • 64. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Não existe nenhuma palavra reservada (keyword) da linguagem para mudar a visibilidade. Isto é feito com um método de classe. Toda classe possui os métodos private, public e protected, que são métodos que alteram outros métodos, mudando a sua visibilidade (código alterando código == metaprogramação). Como visto, por padrão todos os métodos são públicos. O método de classe private altera a visibilidade de todos os métodos definidos após ter sido chamado: class Pessoa private def vai_ao_banheiro # ... end end Todos os métodos após a chamada de private são privados. Isso pode lembrar um pouco C++, que define regiões de visibilidade dentro de uma classe (seção pública, privada, ...). Um método privado em Ruby só pode ser chamado em self e o self deve ser implícito. Em outras palavras, não podemos colocar o self explicitamente para métodos privados, como em self.vai_ao_banheiro. Caso seja necessário, o método public faz com que os métodos em seguida voltem a ser públicos: class Pessoa private def vai_ao_banheiro # ... end public def sou_um_metodo_publico # ... end end O último modificador de visibilidade é o protected. Métodos protected só podem ser chamados em self (implícito ou explícito). Por isso, o protected do Ruby acaba sendo semelhante ao protected do Java e C++, que permitem a chamada do método na própria classe e em classes filhas. 5.15 - Exercícios - Metaprogramação 1) Alguns restaurantes poderão receber um método a mais chamado “cadastrar_vips”. Para isso precisaremos abrir em tempo de execução a classe Restaurante. # faça a chamada e verifique a exception NoMethodError restaurante_um.cadastrar_vips # adicione esse método na classe Franquia def expandir(restaurante) def restaurante.cadastrar_vips Capítulo 5 - Metaprogramação e Padrões de Projeto - Exercícios - Metaprogramação - Página 53
  • 65. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails puts "Restaurante #{self.nome} agora com área VIP!" end end # faça a franquia abrir a classe e adicionar o método franquia.expandir restaurante_um restaurante_um.cadastrar_vips 2) Um método útil para nossa franquia seria a verificação de nome de restaurantes cadastrados. vamos fazer isso usando method_missing. # Adicione na classe Franquia def method_missing(name, *args) @restaurantes.each do |r| return "O restaurante #{r.nome} já foi cadastrado!" if r.nome.eql? *args end return "O restaurante #{args[0]} não foi cadastrado ainda." end # Faça as chamadas e analise os resultados puts franquia.já_cadastrado?("Fazano") puts franquia.já_cadastrado?("Boteco") Capítulo 5 - Metaprogramação e Padrões de Projeto - Exercícios - Metaprogramação - Página 54
  • 66. C APÍTULO 6 Ruby on Rails “A libertação do desejo conduz à paz interior” – Lao-Tsé Aqui faremos um mergulho no Rails e, em um único capítulo, teremos uma pequena aplicação pronta: com banco de dados, interface web, lógica de negócio e todo o necessário para um CRUD, para que nos capítulos posteriores possamos ver cada parte do Rails com detalhes e profundidade, criando uma aplicação bem mais completa. 6.1 - Ruby On Rails David Heinemeier Hansson criou o Ruby on Rails para usar em um de seus projetos na 37signals, o Base- camp. Desde então, passou a divulgar o código e incentivar o uso do mesmo, e em 2006 começou a ganhar muita atenção da comunidade de desenvolvimento Web. O Rails foi criado pensando na agilidade e praticidade que ele proporcionaria na hora de escrever os aplica- tivos para Web. No Brasil a Caelum vem utilizando o framework desde 2007, e grandes empresas como Abril e Locaweb adotaram o framework em uma grande quantidade de projetos. Como pilares da agilidade em Rails, estão os conceitos de Don’t Repeat Yourself (DRY), e Convention over Configuration (CoC). O primeiro conceito diz que você não deve repetir código e sim modularizá-lo. Ou seja, você escreve trechos de código que serão reutilizáveis e evita o Copy And Paste de código. Já o segundo, diz que só devemos precisar fazer uma configuração nos casos excepcionais: ao utilizar os padrões oferecidos pelo Rails, você configura apenas o que estiver fora do padrão, diminuindo bastante a quantidade de configuração necessária para a grande maioria das aplicações. A arquitetura de desenvolvimento em Rails é baseada no conceito de separar tudo em três camadas: o MVC (Model View Controller ). MVC é um padrão arquitetural onde os limites entre seus modelos, suas lógicas e suas visualizações são bem definidos, sendo muito mais simples fazer um reparo, uma mudança ou uma manutenção, já que essas três partes de comunicam de maneira bem desacoplada. 55
  • 67. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Meta-Framework Rails na verdade não é um único framework, mas sim um conjunto de frameworks, alguns dos quais discutiremos adiante: • Rails • ActionDispatch • ActiveSupport Outros frameworks que faziam parte do núcleo do Rails antigamente foram removidos desse nú- cleo para diminuir o acoplamento com ele e permitir que vocês os substitua sem dificuldade, mas continuam funcionando e sendo usandos. Aqui estão alguns deles: • ActiveRecord • ActionController • ActionView • ActionMailer Projetos que usam o Ruby on Rails Há uma extensa lista de aplicações que usam o Ruby on Rails e, entre elas estão o Twitter, Yellow- Pages.com, Typo (blog open source) e o Spokeo (ferramenta de agrupamento de sites de relacio- namentos). Uma lista completa de sites usando RubyOnRails com sucesso pode ser encontrada nestes dois endereços: http://rails100.pbwiki.com http://blog.obiefernandez.com/content/2008/03/big-name-compan.html 6.2 - Aprender Ruby? Ruby on Rails é escrito em Ruby, mas você não precisa conhecer profundamente a linguagem para começar a programar com ele. Essa necessidade surge com o tempo, à medida que precisamos utilizar recursos mais complexos. Como vimos, a linguagem é dinâmica e interpretada, sendo que facilita o desenvolvimento das aplicações em alguns pontos básicos como, por exemplo, não obrigar o desenvolvedor a compilar o código ou a reiniciar um servidor para que a atualização feita entre em produção. 6.3 - IDE O Aptana RadRails é um ambiente de desenvolvimento integrado (Integrated Development Environment – IDE) criado por Kyle Shank para facilitar ainda mais o desenvolvimento para o Ruby On Rails. Capítulo 6 - Ruby on Rails - Aprender Ruby? - Página 56
  • 68. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Existem diversas funções como execução de testes automatizados, suporte para debug, syntax highlighting, integração com diversas ferramentas, wizards, servidores, auto-complete, logs, perspectivas do banco de dados etc. O RadRails fornece tudo o que é preciso para desenvolver em Ruby on Rails: desde a criação do projeto até seu fechamento. Outras IDEs Existem diversas IDEs para trabalhar com Rails, sendo as mais famosas: • RubyMine (baseada no IntelliJ IDEA) • RadRails • MS Visual Studio 2008 • Ruby in Steel • NetBeans • ScITE • InType • RoRed A maior parte dos desenvolvedores ruby rails não usam IDE alguma. Apenas bons editores de texto, como o TextMate (Mac), Emacs, VI, GEdit, Kate, OpenKomodo, entre outros. Justamente pela baixa adoção de IDEs no comunidade rails optamos por utilizar o GEdit. Capítulo 6 - Ruby on Rails - IDE - Página 57
  • 69. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 6.4 - Criando um novo projeto rails Quando instalamos o rails em nossa máquina, ganhamos o comando ‘rails’. Através desse comando pode- mos executar rotinas importantes nos nossos projetos. Uma dessas rotinas é a de criação de um projeto rails, onde precisamos usar o parametro new mais o nome do projeto. rails new meu_projeto Ainda nesse comando para criar novos projetos rails existe um outro parâmetro opcional onde podemos mudar o banco de dados padrão que será usado no nosso projeto. Criando o projeto com o comando igual ao de cima, o projeto usará o banco de dados SQLite, mas no projeto que vamos fazer vamos mudar para usar o banco de dados MySql. Para fazer essa alteração basta usar o parâmetro ‘-d mysql’. rails new meu_projeto -d mysql 6.5 - Exercícios: Iniciando o Projeto 1) Inicie o GEdit: a) Abra o GEdit através do link “Text Editor” no seu desktop b) Clicar no menu Edit e escolher a opção Preferences c) Na nova janela clicar na aba Plugins e selecionar File Browser Pane d) Clicar no menu View e então selecionar Side Pane Capítulo 6 - Ruby on Rails - Criando um novo projeto rails - Página 58
  • 70. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 2) Inicie um novo projeto: a) Abra o terminal b) Executar o seguinte comando rails new agenda -d mysql 6.6 - Estrutura dos diretórios Cada diretório tem uma função específica e bem clara na aplicação. Ao manter selecionado no wizard de criação do projeto a opção “Generate Rails application skeleton”, o Rails gera toda a estrutura do seu programa, criando os seguintes importantes diretórios: Capítulo 6 - Ruby on Rails - Estrutura dos diretórios - Página 59
  • 71. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails • app -> 95% da aplicação e dos códigos criados ficam aqui (inclusive todo o MVC, dividido em diretórios). • config -> Configurações da aplicação. • db -> Banco de Dados, Migrações e Esquemas. • doc -> Documentação do sistema. • lib -> Bibliotecas. • log -> Informações de log. • public -> Arquivos públicos (CSS, imagens, etc), que serão servidos pela WEB. • script -> Scripts pré-definidos do Rails (console, server). • test -> Testes de unidade, funcionais e de integração. • tmp -> Qualquer coisa temporária como, por exemplo, cache e informações de sessões. Capítulo 6 - Ruby on Rails - Estrutura dos diretórios - Página 60
  • 72. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails • vendor -> Plugins e programas externos. 6.7 - Carregando as dependências Justamente por essa característica de metaframework que Rails possui, na migração para o rails 3, decidi- ram utilizar o Bunlder como responsável por gerenciar as dependências do seu projeto. Todo projeto que usa o Bundler deve ter um arquivo Gemfile na raíz do projeto. O comando rails new nome_projeto que você acabou de executar já criou este arquivo. A partir de agora qualquer biblioteca externa que você queira utilizar deve ser descrita no Gemfile do seu projeto e sempre que for tentar rodar qualquer comando dentro do seu pro- jeto o Bundler vai verificar se todas as dependências estão instaladas corretamente no seu computador. Caso alguma dessas dependências não esteja estala, basta utilizar o comando bundle install pelo terminal que o próprio Bundler se encarregará de baixar e instalar o que estive faltando. Em alguns capitulo futuros iremos utli- zar algumas outras bibliotecas e pra isso vamos precisar alterar o Gemfile, mas por enquanto o arquivo padrão que o rails gerou será suficiente para continuarmos. Principais comando do Bundler • bundle check - verifica se todas as dependências necessárias estão instaladas • bundle install - instala todas as dependências faltantes • bundle update - atualiza todas as dependências para a versão mais nova disponível • bundle list - lista todas as dependências configuradas para o projeto corrente 6.8 - O Banco de Dados Uma das características do Rails é a facilidade de se comunicar com diversos bancos de modo transparente ao programador. Um exemplo dessa facilidade é que ao gerar a aplicação, ele criou também um arquivo de configuração do banco, pronto para se conectar ao MySQL. O arquivo está localizado em config/database.yml. Nada impede a alteração manual dessa configuração para outros tipos de bancos. Nesse arquivo, configuramos três conexões diferentes: development, test e production, associados respec- tivamente a agenda_development, agenda_test e agenda_production. Como esperado, development é usado na fase de desenvolvimento da aplicação e production em produção. A configuração para test se refere ao banco utilizado para os testes que serão executados, e deve ser mantido separado dos outros pois o framework apagará as tabelas após a execução. Antes de começar a utilizar nosso banco de dados, devemos criá-los. 6.9 - Exercícios: Criando o banco de dados 1) Pelo terminal entre no diretorio do projeto. Execute a rake task db:create:all para criar todas as tabelas no seu banco de dados. $ rake db:create:all Capítulo 6 - Ruby on Rails - Carregando as dependências - Página 61
  • 73. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 2) Verifique que as três novas bases de dados agora foram criadas. Abra o terminal e logue como usuário root: $ mysql -u root mysql> show databases; 6.10 - A base da construção: scaffold (andaime) Usando Rails, temos a opção de utilizar uma tarefa chamada scaffold, cuja tradução se equivale aos andai- mes de um prédio em construção: criar a base para a construção de sua aplicação. Essa tarefa gera toda a parte de MVC (Model View Controller) relativa ao modelo dado, conectando tudo o que é necessário para, por exemplo, lógicas de listagem, inserção, edição e busca, junto com suas respectivas visualizações. Entre as partes do seu sistema que são geradas, existem os helpers, testes e o layout do site. Repare também na estrutura de arquivos que é criada para o modelo de pessoas: o Rails coloca em seu devido lugar cada um dos controladores e visualizações. No scaffold, existe também uma opção para passar como parâmetro o modelo a ser criado. Com isso, o Rails se encarrega de gerar o modelo e o script de criação da tabela no banco de dados para você. 6.11 - Exercícios: Scaffold 1) Execute o scaffold do seu modelo pessoa: a) Entre novamente no terminal; b) Digite o seguinte comando no terminal: $ rails generate scaffold Pessoa nome:string data_de_nascimento:date altura:float Veja os diversos arquivos que são criados Capítulo 6 - Ruby on Rails - A base da construção: scaffold (andaime) - Página 62
  • 74. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails c) Também gera um arquivo para criação das tabelas no banco de dados d) E um arquivo routes.rb, que veremos mais adiante Capítulo 6 - Ruby on Rails - Exercícios: Scaffold - Página 63
  • 75. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails e) (opcional) Criamos campos string, date e float. Quais outros tipos são suportados ? Abra a documentação do Rails (api.rubyonrails.org) e procure pela classe ActiveRecordConnectionAdaptersTable. 6.12 - Gerar as tabelas Já definimos o modelo e seus atributos, agora vamos executar o processo de geração das tabelas. Basta chamar o comando migrate que o rails executa o script de migração gerado pelo scaffold. O comando em questão é uma “Rake Task”. Para executá-la basta usar o comando rake db:migrate no terminal Repare também que os campos no MySQL correspondem exatamente ao que foi definido no código de migração. O Rails gerou também, por conta própria, o campo id, fazendo o papel de chave primária de nossa tabela. Capítulo 6 - Ruby on Rails - Gerar as tabelas - Página 64
  • 76. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 6.13 - Versão do Banco de Dados Ao chamar a Rake Task “migrate” pela primeira vez, será criada uma outra tabela chamada schema_migrations. Essa tabela contém uma única coluna (version), que indica quais foram as migrações executadas até agora, utilizando para isso o timestamp da última migration executada. Versões anteriores Nas versões anteriores do Rails, esta tabela se chamava schema_info e tinha apenas uma co- luna, com exatamente uma linha. Ela servia para indicar qual a versão do esquema do banco de dados que utilizávamos. Esse número era o mesmo que o começo do nome do arquivo do script de migração. No nosso caso, como possuímos um único script, o nome começaria com 001 (001_create_pessoas.rb) e a versão do banco também seria 1. Por exemplo, ao rodar a task de migração em um projeto que possui 20 scripts, cujo banco fora gerado ainda na versão 15, o Rails executaria os scripts 16, 17, 18, 19 e 20. Existe uma versão chamada 0, que retorna para o banco de dados em sua situação antes de ser atualizado pela primeira vez. Através dessa tarefa, também podemos voltar o esquema do banco de dados para versões anteriores, bastando indicar nos argumentos da tarefa qual a versão que desejamos utilizar. Quando voltamos a versões anteriores do esquema, o rake chama o método down do script, por isso é importante ter certeza que ele faz a operação inversa do método up. 6.14 - Exercícios: Migrar tabela 1) Migre a tabela para o banco de dados: a) Entre o terminal b) Execute a rake task db:migrate $ rake db:migrate c) Verifique a tabela no mysql mysql -u root use agenda_development; Capítulo 6 - Ruby on Rails - Versão do Banco de Dados - Página 65
  • 77. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails show tables; desc pessoas; 6.15 - Server Precisamos de um servidor para rodar nossa aplicação web. Quando instalamos o Rails na nossa máquina ele também instala um servidor, que, por padrão, usa a porta 3000. Este servidor é capaz de interpretar scripts em Ruby que as páginas utilizem. Por padrão o Webrick é utilizado, sendo a opção mais simples. Veremos mais detalhes e opções no capítulo sobre deployment. Podemos iniciar o servidor através do comando rails server no terminal $ rails server Após a inicialização do mesmo, basta abrir um browser e acessar o endereço http://localhost:3000 Ao gerar o scaffold, o Rails criou algumas lógicas e suas respectivas visualizações (views). Capítulo 6 - Ruby on Rails - Server - Página 66
  • 78. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Por exemplo, ao visitar “http://localhost:3000/pessoas”, você é redirecionado para a listagem de pessoas. 6.16 - Exercícios: Iniciando o servidor 1) a) Inicie o servidor com o comando: rails server b) Acesse a aplicação pela url: http://localhost:3000/pessoas 6.17 - Documentação do Rails O RDoc (documentação gerada a partir dos código fonte ruby) da versão corrente do Ruby on Rails está disponível em: http://api.rubyonrails.org Há diversos outros sites que fornecem outras versões da documentação, ou modos alternativos de exibição e organização. • http://www.noobkit.com • http://www.railsmanual.com • http://rails.raaum.org Capítulo 6 - Ruby on Rails - Exercícios: Iniciando o servidor - Página 67
  • 79. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails • http://www.railsapi.org • http://www.railsbrain.com • http://www.gotapi.com • http://delynnberry.com/projects/rails-chm-documentation O RubyGems também oferece a documentação para cada um dos gems que estão instalados, para isso basta iniciar o servidor de documentação embutido: $ gem server Starting gem server on http://localhost:8808/ Este comando inicia um servidor WebRick na porta 8808. Basta acessar pelo browser para ver o RDoc de todos os gems instalados. A última alternativa é gerar a documentação através do rake: rails docs rake doc:rails Depois de executar a task doc:rails, a documentação estará disponível no diretório docs/api/. A documen- tação do ruby (bem como a biblioteca padrão) pode ser encontrada em: http://ruby-doc.org Existem ainda excelentes guias e tutoriais oficiais disponíveis. É obrigatório para todo desenvolvedor Rails passar por estes guias: http://guides.rubyonrails.org Além desses guias, existe um site que lista as principais gems que podem ser usadas para cada tarefa: http://ruby-toolbox.com/ A comunidade Ruby e Rails também costuma publicar diversos excelentes screencasts (vídeos) com aulas e/ou palestras sobre diversos assuntos relacionados a Ruby e Rails. A lista está sempre crescendo, porém aqui estão alguns dos principais: • http://railscasts.com - vídeos pequenos e de graça, normalmente de 15min a 45min. Mantidos por Ryan Bates. • http://peepcode.com - vídeos maiores, verdadeiras vídeo-aulas; alguns chegam a 2h. São pagos, porém muitos consideram o valor simbólico (~$9 por vídeo). • http://www.confreaks.com - famosos por gravar diversas conferências sobre Ruby e Rails. • http://rubytu.be/ - reúne screencasts de diversas fontes. Capítulo 6 - Ruby on Rails - Documentação do Rails - Página 68
  • 80. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 6.18 - Exercício Opcional: Utilizando a documentação 1) Ao inserir uma nova pessoa, o campo ano apresentado no formulário mostra um ano muito atual. Como alterar ? Verifique no arquivo app/views/pessoas/_form.html.erb que estamos usando um método chamado date_select: <%= f.date_select :data_de_nascimento %> Podemos procurar esse método na documentação, ele está em :ActionViewHelpersDateHelper e uma das opções que ele fornece é: • :start_year - Set the start year for the year select. Default is Time.now.year - 5. Como utilizar essa informação? basta passar por hash, como abaixo: <%= f.date_select :data_de_nascimento, :start_year => 1970 %> Capítulo 6 - Ruby on Rails - Exercício Opcional: Utilizando a documentação - Página 69
  • 81. C APÍTULO 7 Active Record “Não se deseja aquilo que não se conhece” – Ovídio Nesse capítulo começaremos a desenvolver um sistema utilizando Ruby on Rails com recursos mais avan- çados. 7.1 - Motivação Queremos criar um sistema de qualificação de restaurantes. Esse sistema terá clientes que qualificam os restaurantes visitados com uma nota, além de informar quanto dinheiro gastaram. Os clientes terão a possibili- dade de deixar comentários para as qualificações feitas por eles mesmos ou a restaurantes ainda não visitados. Além disso, os restaurantes terão pratos, e cada prato a sua receita. O site http://www.tripadvisor.com possui um sistema similar para viagens, onde cada cliente coloca co- mentários sobre hotéis e suas visitas feitas no mundo inteiro. 7.2 - Exercícios: Controle de Restaurantes 1) Crie um novo projeto chamado vota_prato: a) No terminal, garanta que não está no diretoria do projeto anterior. b) Digite o comando rails new vota_prato -d mysql c) Observe o log de criação do projeto: 70
  • 82. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 7.3 - Modelo - O “M” do MVC Models são os modelos que serão usados nos sistemas: são as entidades que serão armazenadas em um banco. No nosso sistema teremos modelos para representar um Cliente, um Restaurante e uma Qualificação, por exemplo. O componente de Modelo do Rails é um conjunto de classes que usam o ActiveRecord, uma classe ORM que mapeia objetos em tabelas do banco de dados. O ActiveRecord usa convenções de nome para determinar os mapeamentos, utilizando uma série de regras que devem ser seguidas para que a configuração seja a mínima possível. Capítulo 7 - Active Record - Modelo - O “M” do MVC - Página 71
  • 83. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails ORM ORM (Object-Relational Mapping) é um conjunto de técnicas para a transformação entre os mode- los orientado a objetos e relacional. 7.4 - ActiveRecord É um framework que implementa o acesso ao banco de dados de forma transparente ao usuário, fun- cionando como um Wrapper para seu modelo. Utilizando o conceito de Conventions over Configuration, o ActiveRecord adiciona aos seus modelos as funções necessárias para acessar o banco. ActiveRecord::Base é a classe que você deve estender para associar seu modelo com a tabela no Banco de Dados. 7.5 - Rake Rake é uma ferramenta de build, escrita em Ruby, e semelhante ao make e ao ant, em escopo e propósito. Rake tem as seguintes funcionalidades: • Rakefiles (versão do rake para os Makefiles) são completamente definidas em sintaxe Ruby. Não existem arquivos XML para editar, nem sintaxe rebuscada como a do Makefile para se preocupar. • É possível especificar tarefas com pré-requisitos. • Listas de arquivos flexíveis que agem como arrays, mas sabem como manipular nomes de arquivos e caminhos (paths). • Uma biblioteca de tarefas pré-compactadas para construir rakefiles mais facilmente. Para criar nossas bases de dados, podemos utilizar a rake task db:create:all. Para isso, vá ao terminal e dentro do diretorio do projeto digite: $ rake db:create:all Repare que o Rails cria três bancos de dados: vota_prato_development, vota_prato_test e vota_prato_production. Para ver todas as tasks rake disponíveis no seu projeto podemos usar o comando (na raiz do seu projeto): Capítulo 7 - Active Record - ActiveRecord - Página 72
  • 84. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails rake -T 7.6 - Criando Modelos Agora iremos criar o modelo do Restaurante. Para isso, temos um gerador específico para model através do comando rails generate model restaurante. Repare que o Rails gerou uma série de arquivos para nós. 7.7 - Migrations Migrations ajudam a gerenciar a evolução de um esquema utilizado por diversos bancos de dados. Foi a solução encontrada para o problema de como adicionar uma coluna no banco de dados local e propagar essa mudança para os demais desenvolvedores de um projeto e para o servidor de produção. Com as migrations, podemos descrever essas transformações em classes que podem ser controladas por sistemas de controle de versão (por exemplo, SVN) e executá-las em diversos bancos de dados. Capítulo 7 - Active Record - Criando Modelos - Página 73
  • 85. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Sempre que executarmos a tarefa Generator -> model, o Rails se encarrega de criar uma migration inicial, localizado em db/migrate. ActiveRecord::Migration é a classe que você deve estender ao criar uma migration. Quando geramos nosso modelo na seção anterior, Rails gerou para nós uma migration (db/migrate/<timestamp>_create_restaurantes.rb). Vamos agora editar nossa migration com as infor- mações que queremos no banco de dados. Queremos que nosso restaurante tenha um nome e um endereço. Para isso, devemos acrescentar: t.string :nome, :limit => 80 t.string :endereco Sua migration deve ter ficado parecida com esta: Supondo que agora lembramos de adicionar a especialidade do restaurante. Como fazer? Basta usar o outro gerador (Generator ) do rails que cria migration. Por exemplo: $ rails generate migration add_column_especialidade_to_restaurante Capítulo 7 - Active Record - Migrations - Página 74
  • 86. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Como as migrations são sempre incrementais, basta incluirmos a coluna faltante: def self.up add_column :restaurantes, :especialidade, :string, :limit => 40 end def self.down remove_column :restaurantes, :especialidade end 7.8 - Exercícios: Criando os modelos 1) Crie nosso banco de dados a) Entre no terminal, no diretório do projeto b) execute rake db:create:all No terminal, acesse o mysql. mysql -u root show databases; Capítulo 7 - Active Record - Exercícios: Criando os modelos - Página 75
  • 87. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 2) Crie o modelo do Restaurante a) Novamente no Terminal, no diretório do projeto b) execute rails generate model restaurante 3) Edite seu script de migração do modelo “restaurante” para criar os campos nome e endereço: a) Abra o arquivo “db/migrate/<timestamp>_create_restaurantes.rb” b) Adicione as linhas: t.string :nome, :limit => 80 t.string :endereco 4) Migre as tabelas para o banco de dados: a) Vá ao Terminal b) Execute rake db:migrate Capítulo 7 - Active Record - Exercícios: Criando os modelos - Página 76
  • 88. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails c) Olhe no banco de dados mysql -u root use vota_prato_development; desc restaurantes; 5) Adicione a coluna especialidade ao nosso modelo “restaurante": a) Vá novamente ao Terminal b) Digite: rails generate migration add_column_especialidade_restaurante c) Abra o arquivo “db/migrate/<timestamp>_add_column_especialidade_restaurante.rb” d) Adicione as linhas: def self.up add_column :restaurantes, :especialidade, :string, :limit => 40 end def self.down remove_column :restaurantes, :especialidade end Seu arquivo deve ter ficado assim: Capítulo 7 - Active Record - Exercícios: Criando os modelos - Página 77
  • 89. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails e) Para efetivar a mudança no banco de dados execute rake db:migrate no Terminal f) Olhe no banco de dados g) Utilizamos add_column e remove_column na nossa migration para adicionar uma nova co- luna. O que mais poderia ser feito ? Abra a documentação e procure pelo módulo ActiveRe- cordConnectionAdaptersSchemaStatements. 7.9 - Manipulando nossos modelos pelo console Podemos utilizar o console para escrever comandos Ruby, e testar nosso modelo. A grande vantagem disso, é que não precisamos de controladores ou de uma view para testar se nosso modelo funciona de acordo com Capítulo 7 - Active Record - Manipulando nossos modelos pelo console - Página 78
  • 90. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails o esperado e se nossas regras de validação estão funcionando. Outra grande vantagem está no fato de que se precisarmos manipular nosso banco de dados, ao invés de termos de conhecer a sintaxe sql e digitar a query manualmente, podemos utilizar código ruby e manipular através do nosso console. Para criar um novo restaurante, podemos utilizar qualquer um dos jeitos abaixo: r = Restaurante.new r.nome = "Fasano" r.endereco = "Av. dos Restaurantes, 126" r.especialidade = "Comida Italiana" r.save r = Restaurante.new do |r| r.nome = "Fasano" r.endereco = "Av. dos Restaurantes, 126" r.especialidade = "Comida Italiana" end r.save r = Restaurante.new :nome => "Fasano", :endereco => "Av. dos Restaurantes, 126", :especialidade => "Comida Italiana" r.save Restaurante.create :nome => "Fasano", :endereco => "Av. dos Restaurantes, 126", :especialidade => "Comida Italiana" Repare que o create já salva o novo restaurante no banco de dados, não sendo necessário o comando save. Note que o comando save efetua a seguinte ação: se o registro não existe no banco de dados, cria um novo registro; se já existe, atualiza o registro existente. Existe também o comando save!, que tenta salvar o registro, mas ao invés de apenas retornar “false” se não conseguir, lança a exceção RecordNotSaved. Para atualizar um registro diretamente no banco de dados, podemos fazer: Restaurante.update(1, {:nome => "1900"}) Para atualizar multiplos registros no banco de dados: Restaurante.update_all( "especialidade = ’Massas’" ) Ou, dado um objeto r do tipo Restaurante, podemos utilizar: r.update_attribute(:nome, "1900") r.update_attributes :nome => "1900", :especialidade => "Pizzas" Existe ainda o comando update_attributes!, que chama o comando save! ao invés do comando save na hora de salvar a alteração. Para remover um restaurante, também existem algumas opções. Todo ActiveRecord possui o método destroy: restaurante = ... restaurante.destroy Capítulo 7 - Active Record - Manipulando nossos modelos pelo console - Página 79
  • 91. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Para remover o restaurante de id 1: Restaurante.destroy(1) Para remover os restaurantes de ids 1, 2 e 3: restaurantes = [1,2,3] Restaurante.destroy(restaurantes) Para remover todos os restaurantes: Restaurante.destroy_all Podemos ainda remover todos os restaurantes que obedeçam determinada condição, por exemplo: Restaurante.destroy_all(:especialidade => "italiana") Os métodos destroy sempre fazem primeiro o find(id) para depois fazer o destroy(). Se for necessário evitar o SELECT antes do DELETE, podemos usar o método delete(): Restaurante.delete(1) 7.10 - Exercícios: Manipulando registros Teste a manipulação de registros pelo console. 1) Insira um novo restaurante a) Para ter acesso ao Console, basta digitar rails console no Terminal b) Digite: r = Restaurante.new :nome => "Fasano", :endereco => "Av. dos Restaurantes, 126", :especialidade => "Comida Italiana" c) Olhe seu banco de dados: mysql -u root use vota_prato_development; select * from restaurantes; Capítulo 7 - Active Record - Exercícios: Manipulando registros - Página 80
  • 92. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails d) Volte para o Console e digite: r.save e) Olhe seu banco de dados novamente: mysql -u root use vota_prato_development; select * from restaurantes; 2) Atualize seu restaurante a) Digite: r.update_attributes :nome => "1900" b) Olhe seu banco de dados novamente: mysql -u root use vota_prato_development; select * from restaurantes; 3) Vamos remover o restaurante criado: a) Digite Restaurante.destroy(1) b) Olhe seu banco de dados e veja que o restaurante foi removido mysql -u root use vota_prato_development; select * from restaurantes; 7.11 - Exercícios Opcionais 1) Teste outras maneiras de efetuar as operações do exercício anterior. 7.12 - Finders O ActiveRecord possui o método “find” para realizar buscas. Esse método, aceita os seguintes parâmetros: Restaurante.all # retorna todos os registros Restaurante.first # retorna o primeiro registro Restaurante.last # retorna o último registro Ainda podemos passar para o método find uma lista com os id’s dos registros que desejamos: r = Restaurante.find(1) varios = Restaurante.find(1,2,3) Capítulo 7 - Active Record - Exercícios Opcionais - Página 81
  • 93. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Além desses, podemos definir condições para nossa busca (como o SELECT do MySQL). Existem diversas formas de declararmos essas condições: Restaurante.where("bla = 1 and xpto = 3") Restaurante.where(["bla = ? and xpto = ?", 1, 3]) Restaurante.where(["bla = :b and xpto = :c", {:b => 1, :c => 3}]) Restaurante.where({ :bla => 1, :xpto => 3 }]) Essas quatro formas fazem a mesma coisa. Procuram por registros com o campo bla = 1 e o campo xpto = 3. Existem ainda os chamados dynamic finders: Restaurante.where(["nome = ? AND especialidade = ?", "Fasano", "italiana"]) poderia ser escrito como: find_all_by_nome_and_especialidade("Fasano", "italiana") Temos ainda o “find_or_create_by”, que retorna um objeto se ele existir, caso contrário, cria o objeto no banco de dados e retorna-o: Restaurante.find_or_create_by_nome("Fasano") Para finalizar, podemos chamar outros métodos encadeados para fazer querys mais complexas: • .order - define a ordenação. Ex: “created_at DESC, nome”. • .group - nome do atributo pelo qual os resultados serão agrupados. Efeito idêntico ao do comando SQL GROUP BY. • .limit - determina o limite do número de registros que devem ser retornados • .offset - determina o ponto de início da busca. Ex: para offset = 5, iria pular os registros de 0 a 4. • .include - permite carregar relacionamentos na mesma consulta usando LEFT OUTER JOINS. Exemplo mais completo: Restaurante.where(’nome like :nome’, {:nome => ’%teste%’}).order(’nome DESC’).limit(20) Para Sabe Mais - Outras opções para os finders Existem mais opções, como o “:lock”, que podem ser utilizadas, mas não serão abordadas nesse curso. Você pode consultá-las na documentação da API do Ruby on Rails. 7.13 - Exercícios: Buscas dinâmicas 1) Vamos testar os métodos de busca: a) Abra o console (rails console no Terminal) b) Digite: Restaurante.first Capítulo 7 - Active Record - Exercícios: Buscas dinâmicas - Página 82
  • 94. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails c) Aperte enter d) Digite: Restaurante.all e) Aperte enter f) Digite: Restaurante.find(1) g) Aperte enter h) Digite: Restaurante.where(["nome = ? AND especialidade = ?", "Fasano", "Comida Italiana"]) i) Aperte enter j) Digite: Restaurante.find_all_by_nome_and_especialidade("Fasano", "Comida Italiana") k) Aperte enter l) Digite: Restaurante.order("especialidade DESC").limit(1) m) Aperte enter 7.14 - Validações Ao inserir um registro no banco de dados é bem comum a entrada de dados inválidos. Existem alguns campos de preenchimento obrigatório, outros que só aceitem números, que não podem conter dados já existentes, tamanho máximo e mínimo etc. Para ter certeza que um campo foi preenchido antes de salvar no banco de dados, é necessário pensar em três coisas: “como validar a entrada?”, “qual o campo a ser validado?” e “o que acontece ao tentar salvar uma entrada inválida?”. Para validar esses registros, podemos implementar o método validate em qualquer ActiveRecord, porém o Rails disponibiliza alguns comandos prontos para as validações mais comuns. São eles: • validates_presence_of: verifica se um campo está preenchido; • validates_size_of: verifica o comprimento do texto do campo; • validates_uniqueness_of: verifica se não existe outro registro no banco de dados que tenha a mesma informação num determinado campo; • validates_numericality_of: verifica se o preenchimento do campo é numérico; • validates_associated: verifica se o relacionamento foi feito corretamente; • etc... Capítulo 7 - Active Record - Validações - Página 83
  • 95. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Todos estes métodos disponibilizam uma opção (:message) para personalizar a mensagem de erro que será exibida caso a regra não seja cumprida. Caso essa opção não seja utilizada, será exibida uma mensagem padrão. Toda mensagem de erro é gravada num hash chamado errors, presente em todo ActiveRecord. Além dos validadores disponibilizados pelo rails, podemos utilizar um validador próprio: validate :garante_alguma_coisa def garante_alguma_coisa errors.add_to_base("Deve respeitar nossa regra") unless campo_valido? end Repare que aqui, temos que incluir manualmente a mensagem de erro padrão do nosso validador. Se quisermos que o nome do nosso restaurante comece com letra maiúscula, poderíamos fazer: validate :primeira_letra_deve_ser_maiuscula private def primeira_letra_deve_ser_maiuscula errors.add("nome", "primeira letra deve ser maiúscula") unless nome =~ /[A-Z].*/ end Além dessas alternativas, no Rails 3 incluiram uma nova maneira de criar validações que facilita os casos onde temos vários validadores para o mesmo campo, como por exemplo: validates :nome, :presence => true, :uniqueness => true, :length => { :maximum => 50 } equivalente a: validates_presence_of :nome validates_uniqueness_of :nome validates_length_of :nome, :maximum => 50 Modificadores de acesso Utilizamos aqui, o modificador de acesso private. A partir do ponto que ele é declarado, todos os métodos daquela classe serão privados, a menos que tenha um outro modificador de acesso que modifique o acesso a outros métodos. Validadores prontos Esse exemplo podería ter sido reescrito utilizando o validador “validates_format_of”, que verifica se um atributo confere com uma determinada expressão regular. Encoding de arquivos no Ruby e as classes de Model Devido ao encoding dos arquivos no Ruby 1.9 ser como padrão ASCII-8BIT, ao utilizarmos algum caracter acentuado no código fonte, é necessário indicarmos um encoding que suporte essa acen- tuação. Geralmente, esse encoding será o UTF-8. Portanto, temos que adicionar no começo do arquivo fonte a linha: #encoding: utf-8 Capítulo 7 - Active Record - Validações - Página 84
  • 96. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 7.15 - Exercícios: Validações 1) Para nosso restaurante implementaremos a validação para que o campo nome, endereço e especialidade não possam ficar vazios, nem que o sistema aceite dois restaurantes com o mesmo nome e endereço. a) Abra o modelo do restaurante (app/models/restaurante.rb) b) inclua as validações: validates_presence_of :nome, :message => "deve ser preenchido" validates_presence_of :endereco, :message => "deve ser preenchido" validates_presence_of :especialidade, :message => "deve ser preenchido" validates_uniqueness_of :nome, :message => "nome já cadastrado" validates_uniqueness_of :endereco, :message => "endereço já cadastrado" c) Por utilizarmos acentuação em nosso arquivo de modelo, adicione a diretiva (comentário) que indica qual o encoding em que o Ruby deve interpretar no início do seu arquivo. #encoding: utf-8 2) Inclua a validação da primeira letra maiúscula: validate :primeira_letra_deve_ser_maiuscula private def primeira_letra_deve_ser_maiuscula errors.add("nome", "primeira letra deve ser maiúscula") unless nome =~ /[A-Z].*/ end 3) Agora vamos testar nossos validadores: a) Abra o Terminal b) Entre no Console (rails console) c) Digite: r = Restaurante.new :nome => "fasano", :endereco => "Av. dos Restaurantes, 126" r.save d) Verifique a lista de erros, digitando: r.valid? # verifica se objeto passa nas validações r.errors.empty? # retorna true/false indicando se há erros ou não r.errors.count # retorna o número de erros r.errors.on "nome" # retorna apenas o erro do atributo nome r.errors.each {|field, msg| puts "#{field} - #{msg}" } Capítulo 7 - Active Record - Exercícios: Validações - Página 85
  • 97. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 7.16 - Exercícios - Completando nosso modelo 1) Vamos criar o nosso modelo Cliente, bem como sua migration: a) No terminal, digite: rails generate model cliente b) Abra o arquivo “db/migrate/<timestamp>_create_clientes.rb” c) Adicione as linhas: create_table :clientes do |t| t.string :nome, :limit => 80 t.integer :idade t.timestamps end d) Vamos efetivar a migration usando o comando rake db:migrate Capítulo 7 - Active Record - Exercícios - Completando nosso modelo - Página 86
  • 98. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails e) Olhe no console o que foi feito f) Olhe no banco de dados! 2) Vamos agora fazer as validações no modelo “cliente”: a) Abra o arquivo “app/models/cliente.rb” b) Adicione as seguintes linhas: validates_presence_of :nome, :message => " - deve ser preenchido" validates_uniqueness_of :nome, :message => " - nome já cadastrado" validates_numericality_of :idade, :greater_than => 0, :less_than => 100, :message => " - deve ser um número entre 0 e 100" 3) Vamos criar o modelo Prato, bem como sua migration: Capítulo 7 - Active Record - Exercícios - Completando nosso modelo - Página 87
  • 99. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails a) Vamos excutar o generator de model do rails novamente. b) rails generate model prato no Terminal c) Abra o arquivo “db/migrate/<timestamp>_create_pratos.rb” d) Adicione as linhas: t.string :nome, :limit => 80 e) Volte para o Terminal f) execute rake db:migrate g) Olhe no console o que foi feito h) Olhe no banco de dados! 4) Vamos agora fazer as validações no modelo “prato”: a) Abra o arquivo “app/models/prato.rb” b) Adicione as seguintes linhas: validates_presence_of :nome, :message => " - deve ser preenchido" validates_uniqueness_of :nome, :message => " - nome já cadastrado" 5) Vamos criar o modelo Receita, bem como sua migration: a) Vá ao Terminal b) Execute rails generate model receita c) Abra o arquivo “db/migrate/<timestamp>_create_receitas.rb” d) Adicione as linhas: t.integer :prato_id t.text :conteudo e) Volte ao Terminal f) Execute rake db:migrate g) Olhe no console o que foi feito h) Olhe no banco de dados! 6) Vamos agora fazer as validações no modelo “receita”: a) Abra o arquivo “app/models/receita.rb” b) Adicione as seguintes linhas: validates_presence_of :conteudo, :message => " - deve ser preenchido" Capítulo 7 - Active Record - Exercícios - Completando nosso modelo - Página 88
  • 100. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 7.17 - O Modelo Qualificação Antes de criarmos nosso modelo de Qualificação, repare que o Rails pluraliza os nomes de nossos modelos de forma automática. Por exemplo, o nome da tabela do modelo Cliente ficou clientes. No entanto, qualificacao é uma palavra que tem sua pluralização irregular (não basta adicionar um ‘s’ no final da palavra), e o Rails deve gerar a seguinte palavra pluralizada: ‘qualificacaos’, uma vez que estamos utilizando o português e ele possui regras de pluralização apenas para o inglês. Para corrigir isso, vamos ter de editar o arquivo “config/initializers/inflections.rb” e inserir manualmente o plural da palavra ‘qualificacao’. Repare que nesse mesmo arquivo temos diversos exemplos comentados de como podemos fazer isso. Quando inserirmos as linhas abaixo no final do arquivo, o Rails passará a utilizar esse padrão para a plura- lização: ActiveSupport::Inflector.inflections do |inflect| inflect.irregular ’qualificacao’, ’qualificacoes’ end 7.18 - Exercícios - Criando o Modelo de Qualificação 1) Vamos corrigir a pluralização da palavra ‘qualificacao’ a) Abra o arquivo “config/initializers/inflections.rb” b) Adicione as seguintes linhas ao final do arquivo: ActiveSupport::Inflector.inflections do |inflect| inflect.irregular ’qualificacao’, ’qualificacoes’ end brazilian-rails Existe um plugin chamado Brazilian Rails que é um conjunto de gems para serem usadas com Ruby e com o Ruby on Rails e tem como objetivo unir alguns recursos úteis para os desenvolvedores brasileiros. 2) Vamos continuar com a criação do nosso modelo Qualificacao e sua migration. Capítulo 7 - Active Record - O Modelo Qualificação - Página 89
  • 101. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails a) No Terminal digite b) rails generate model qualificacao c) Abra o arquivo “db/migrate/<timestamp>_create_qualificacoes.rb” d) Adicione as linhas: t.integer :cliente_id t.integer :restaurante_id t.float :nota t.float :valor_gasto e) Adicione ainda as seguintes linhas depois de “create_table”: CUIDADO! Essas linhas não fazem parte do create_table, mas devem ficar dentro do método self.up. add_index(:qualificacoes, :cliente_id) add_index(:qualificacoes, :restaurante_id) f) Volte ao Terminal g) Execute rake db:migrate Capítulo 7 - Active Record - Exercícios - Criando o Modelo de Qualificação - Página 90
  • 102. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails h) Olhe no console o que foi feito i) Olhe no banco de dados 3) Vamos agora fazer as validações no modelo “qualificacao”: a) Abra o arquivo “app/models/qualificacao.rb” b) Adicione as seguintes linhas: validates_presence_of :nota, :message => " - deve ser preenchido" validates_presence_of :valor_gasto, :message => " - deve ser preenchido" validates_numericality_of :nota, :greater_than_or_equal_to => 0, :less_than_or_equal_to => 10, :message => " - deve ser um número entre 0 e 10" validates_numericality_of :valor_gasto, :greater_than => 0, :message => " - deve ser um número maior que 0" Capítulo 7 - Active Record - Exercícios - Criando o Modelo de Qualificação - Página 91
  • 103. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails c) Abra o Console (digite rails console no Terminal). No Console do Rails digite: "qualificacao".pluralize 7.19 - Relacionamentos Capítulo 7 - Active Record - Relacionamentos - Página 92
  • 104. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Para relacionar diversos modelos, precisamos informar ao Rails o tipo de relacionamento entre eles. Quando isso é feito, alguns métodos são criados para podermos manipular os elementos envolvidos nesse relaciona- mento. Os relacionamentos que Rails disponibiliza são os seguintes: • belongs_to - usado quando um modelo tem como um de seus atributos o id de outro modelo (many-to-one ou one-to-one). Quando dissermos que uma qualificação belongs_to um restaurante, ainda ganharemos os seguintes métodos: – Qualificacao.restaurante (similar ao Restaurante.find(restaurante_id)) – Qualificacao.restaurante=(restaurante) (similar ao qualificacao.restaurante_id = restaurante.id) – Qualificacao.restaurante? (similar ao qualificacao.restaurante == algum_restaurante) • has_many - associação que provê uma maneira de mapear uma relação one-to-many entre duas entida- des. Quando dissermos que um restaurante has_many qualificações, ganharemos os seguintes métodos: – Restaurante.qualificacoes (semelhante ao Qualificacao.find :all, :conditions => ["restaurante_id = ?”, id]) – Restaurante.qualificacoes<< – Restaurante.qualificacoes.delete – Restaurante.qualificacoes= • has_and_belongs_to_many - associação muitos-para-muitos, que é feita usando uma tabela de mapea- mento. Quando dissermos que um prato has_and_belongs_to_many restaurantes, ganharemos os seguintes métodos: – Prato.restaurantes – Prato.restaurantes<< – Prato.restaurantes.delete – Prato.restaurantes= Além disso, precisaremos criar a tabela pratos_restaurantes, com as colunas prato_id e restau- rante_id. Por convenção, o nome da tabela é a concatenação do nome das duas outras tabelas, seguindo a ordem alfabética. • has_one - lado bidirecional de uma relação um-para-um. Quando dissermos que um prato has_one receita, ganharemos os seguintes métodos: – Prato.receita, (semelhante ao Receita.find(:first, :conditions => “prato_id = id”)) – Prato.receita= Capítulo 7 - Active Record - Relacionamentos - Página 93
  • 105. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 7.20 - Para Saber Mais: Auto-relacionamento Os relacionamentos vistos até agora foram sempre entre dois objetos de classes diferentes. Porém existem relacionamentos entre classes do mesmo tipo, por exemplo, uma Categoria de um site pode conter outras cate- gorias, onde cada uma contém ainda suas categorias. Esse relacionamento é chamado auto-relacionamento. No ActiveRecord temos uma forma simples para fazer essa associação. class Category < ActiveRecord::Base has_many :children, :class_name => "Category", :foreign_key => "father_id" belongs_to :father, :class_name => "Category" end 7.21 - Para Saber Mais: Cache Todos os resultados de métodos acessados de um relacionamento são obtidos de um cache e não nova- mente do banco de dados. Após carregar as informações do banco, o ActiveRecord só volta se ocorrer um pedido explicito. Exemplos: restaurante.qualificacoes # busca no banco de dados restaurante.qualificacoes.size # usa o cache restaurante.qualificacoes.empty? # usa o cache restaurante.qualificacoes(true).size # força a busca no banco de dados restaurante.qualificacoes # usa o cache 7.22 - Exercícios - Relacionamentos 1) Vamos incluir os relacionamentos necessários para nossos modelos: a) Abra o arquivo “app/models/cliente.rb” b) Adicione a seguinte linha: has_many :qualificacoes c) Abra o arquivo “app/models/restaurante.rb” d) Adicione a seguinte linha: has_many :qualificacoes has_and_belongs_to_many :pratos Capítulo 7 - Active Record - Para Saber Mais: Auto-relacionamento - Página 94
  • 106. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails e) Abra o arquivo “app/models/qualificacao.rb” f) Adicione as seguintes linhas: belongs_to :cliente belongs_to :restaurante g) Abra o arquivo “app/models/prato.rb” h) Adicione as seguintes linhas: has_and_belongs_to_many :restaurantes has_one :receita Capítulo 7 - Active Record - Exercícios - Relacionamentos - Página 95
  • 107. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails i) Abra o arquivo “app/models/receita” j) Adicione a seguinte linha: belongs_to :prato 2) Vamos criar a tabela para nosso relacionamento has_and_belongs_to_many: a) Va para o Terminal b) Digite: rails generate migration createPratosRestaurantesJoinTable c) Abra o arquivo “db/migrate/<timestamp>_create_pratos_restaurantes_join_table.rb” d) O rails não permite que uma tabela de ligação para um relacionamento has_and_belongs_to_many possua chave primária auto incremento. Por isso, vamos fazer com que o rails não gere essa chave. Basta passar o parâmetro :id=>false para o método create_table. Dessa forma, teremos que digitar o seguinte no self.up: create_table :pratos_restaurantes, :id => false do |t| t.integer :prato_id t.integer :restaurante_id end e) E o seguinte no self.down drop_table :pratos_restaurantes Capítulo 7 - Active Record - Exercícios - Relacionamentos - Página 96
  • 108. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails f) Volte ao Terminal e execute a migration (rake db:migrate) g) Olhe no console o que foi feito h) Olhe no banco de dados 3) Vamos incluir as validações que garantam que os relacionamentos foram feitos corretamente: a) Abra o arquivo “app/models/qualificacao.rb” b) Adicione as seguintes linhas: validates_presence_of :cliente_id, :restaurante_id validates_associated :cliente, :restaurante c) Abra o arquivo “app/models/receita.rb” d) Adicione as seguintes linhas: validates_presence_of :prato_id validates_associated :prato e) Abra o arquivo “app/models/prato.rb” f) Adicione as seguintes linhas: validate :validate_presence_of_more_than_one_restaurante private def validate_presence_of_more_than_one_restaurante errors.add("restaurantes", "deve haver ao menos um restaurante") if restaurantes.empty? end 4) Faça alguns testes no terminal para testar essas novas validações. Capítulo 7 - Active Record - Exercícios - Relacionamentos - Página 97
  • 109. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 7.23 - Para Saber Mais - Eager Loading Podemos cair em um problema grave caso o número de qualificações para um restaurante seja muito grande. Imagine que um determinado restaurante do nosso sistema possua com 100 qualificações. Queremos mostrar todas as qualificações desse restaurante, então fazemos um for: for qualificacao in Qualificacao.all puts "restaurante: " + qualificacao.restaurante.nome puts "cliente: " + qualificacao.cliente.nome puts "qualificacao: " + qualificacao.nota end Para iterar sobre as 100 qualificações do banco de dados, seriam geradas 201 buscas! Uma busca para to- das as qualificações, 100 buscas para cada restaurante mais 100 buscas para cada cliente! Podemos melhorar um pouco essa busca. Podemos pedir ao ActiveRecord que inclua o restaurante quando fizer a busca: Qualificacao.find(:all, :include => :restaurante) Bem melhor! Agora a quantidade de buscas diminuiu para 102! Uma busca para as qualificações, outra para todos os restaurantes e mais 100 para os clientes. Podemos utilizar a mesma estratégia para otimizar a busca de clientes: Qualificacao.includes(:restaurante, :cliente) Com essa estratégia, teremos o número de buscas muito reduzido. A quantidade total agora será de 1 + o número de associações necessárias. Poderíamos ir mais além, e trazer uma associação de uma das associações existentes em qualificação: Qualificacao.includes(:cliente, {:restaurante => {:pratos => :receita}}) 7.24 - Para Saber Mais - Named Scopes Para consultas muito comuns, podemos usar o recurso de Named Scopes oferecido pelo ActiveRecord, que permite deixarmos alguns tipos de consultas comuns “preparadas”. Imagine que a consulta de restaurantes de especialidade “massa” seja muito comum no nosso sistema. Podemos facilitá-la criando um named scope na classe Restaurante: class Restaurante < ActiveRecord::Base scope :massas, where({ :especialidade => ’massas’ }) end As opções mais comuns do método find também estão disponíveis para named scopes, como :conditions, :order, :select e :include. Com o named scope definido, a classe ActiveRecord ganha um método de mesmo nome, através do qual podemos recuperar os restaurantes de especialidade "massas de forma simples: Restaurante.massas Restaurante.massas.first Restaurante.massas.last Restaurante.massas.where(["nome like ?", ’%x%’]) Capítulo 7 - Active Record - Para Saber Mais - Eager Loading - Página 98
  • 110. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails O método associado ao named scope criado retorna um objeto da classe ActiveRecordNamedScope Scope, que age como um Array, mas aceita a chamada de alguns métodos das classes ActiveRecord, como o find para filtrar ainda mais a consulta. Podemos ainda definir diversos named scopes e combiná-los de qualquer forma: class Restaurante < ActiveRecord::Base scope :massas, where(:especialidade => ’massas’ }) scope :recentes, where([ "created_at > ?", 3.months.ago ]) scope :pelo_nome, order(’nome’) end Restaurante.massas # todos de especialidade = ’massas’ Restaurante.recentes # todos de created_at > 3 meses atras # especialidade = ’massas’ e created_at > 3 meses atras Restaurante.massas.recentes Restaurante.recentes.massas Restaurante.massas.pelo_nome.recentes 7.25 - Para Saber Mais - Modules As associações procuram por relacionamentos entre classes que estejam no mesmo módulo. Caso precise de relacionamentos entre classes em módulos distintos, é necessário informar o nome completo da classe no relacionamento: module Restaurante module RH class Pessoa < ActiveRecord::Base; end end module Financeiro class Pagamento < ActiveRecord::Base belongs_to :pessoa, :class_name => "Restaurante::RH::Pessoa" end end end Capítulo 7 - Active Record - Para Saber Mais - Modules - Página 99
  • 111. C APÍTULO 8 Controllers e Views “A Inteligência é quase inútil para quem não tem mais nada” – Carrel, Alexis Nesse capítulo, você irá aprender o que são controllers e como utilizá-los para o benefício do seu projeto, além de aprender a trabalhar com a camada visual de sua aplicação. 8.1 - O “V” e o “C” do MVC O “V” de MVC representa a parte de view (visualização) da nossa aplicação, sendo ela quem tem contato com o usuário, recebe as entradas e mostra qualquer tipo de saída. Há diversas maneiras de controlar as views, sendo a mais comum delas feita através dos arquivos HTML.ERB, ou eRuby (Embedded Ruby), páginas HTML que podem receber trechos de código em Ruby. Controllers são classes que recebem uma ação de uma View e executam algum tipo de lógica ligada a um ou mais modelos. Em Rails esses controllers estendem a classe ApplicationController. As urls do servidor são mapeadas da seguinte maneira: /controller/action/id. Onde “controller” representa uma classe controladora e “action” representa um método do mesmo. “id” é um parâmetro qualquer (opcional). 8.2 - Hello World Antes de tudo criaremos um controller que mostrará um “Hello World” para entender melhor como funciona essa idéia do mapeamento de urls. Vamos usar o generator do rails para criar um novo controller que se chamará “HelloWorld”. Veja que o Rails não gera apenas o Controller, mas também outros arquivos. 100
  • 112. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Apos habilitar o rota padrão do rails tente acessar a página http://localhost:3000/hello_world Na URL acima passamos apenas o controller sem nenhuma action, por isso recebemos uma mesagem de erro. Além de não dizer qual a action na URL, não escrevemos nenhuma action no controller. Criaremos um método chamado hello no qual escreveremos na saída do cliente a frase “Hello World!”. Cada método criado no controller é uma action, que pode ser acessada através de um browser. Para escrever na saída, o Rails oferece o comando render, que recebe uma opção chamada “text” (String). Tudo aquilo que for passado por esta chave será recebido no browser do cliente. 8.3 - Exercícios: Criando o controlador 1) Crie um controller que mostre na tela a mensagem “Hello World” a) Va ao Terminal b) Execute rails generate controller HelloWorld c) Entre no seu novo controller (app/controllers/hello_world_controller.rb) Capítulo 8 - Controllers e Views - Exercícios: Criando o controlador - Página 101
  • 113. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails d) Inclua o método “hello": def hello render :text => "Hello World!" end e) Descomente a última linha do arquivo config/routes.rb para habilitar a rota padrão do rails. No próximo capítulo falaremos mais sobre esse assunto. # This is a legacy wild controller route that’s not recommended for RESTful applications. # Note: This route will make all actions in every controller accessible via GET requests. match ’:controller(/:action(/:id(.:format)))’ f) O último passo antes de testar no browser é iniciar o server. g) Execute no Terminal: rails server h) Confira o link http://localhost:3000/hello_world/hello. Capítulo 8 - Controllers e Views - Exercícios: Criando o controlador - Página 102
  • 114. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 8.4 - Redirecionamento de Action e Action padrão Mas não há necessidade de toda vez escolher qual action será executada. Temos a opção de escrever uma action padrão que será invocada sempre que nenhuma outra for definida na url sendo acessada. Para definir uma action padrão temos que dar o nome do método de index: def index render :text => "Action Padrão!" end Dentro de uma action, podemos redirecionar a saída para uma outra action. No exemplo do Hello World, ao chamar o comando redirect_to e passar como argumento a action desejada (:action => “hello ), o Rails fará o redirecionamento no cliente. def index redirect_to(:action => "hello") end Ao acessar http://localhost:3000/hello_world, o servidor nos redireciona para a página http://localhost: 3000/hello_world/hello, mostrando um “Hello World” igual ao anterior. Ao invés de fazer o redirecionamento, podemos chamar outra action diretamente. Assim não vamos ser redirecionados e a URL continuará a mesma. def index hello end Redirecionamento no servidor e no cliente O redirecionamento no servidor é conhecido como forward e a requisição é apenas repassada a um outro recurso (página, controlador) que fica responsável em tratar a requisição. Há uma outra forma que é o redirecionamento no cliente (redirect). Nesta modalidade, o servidor responde a requisição original com um pedido de redirecionamento, fazendo com que o nave- gador dispare uma nova requisição para o novo endereço. Neste caso, a barra de endereços do navegador muda. Capítulo 8 - Controllers e Views - Redirecionamento de Action e Action padrão - Página 103
  • 115. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 8.5 - Trabalhando com a View: O ERB ERb ERb é uma implementação de eRuby que já acompanha a linguagem Ruby. Seu funcionamento é similar ao dos arquivos JSP/ASP: arquivos html com injeções de código. A idéia é que o HTML serve como um template, e outros elementos são dinâmicamente inseridos em tempo de renderização. Para uma página aceitar código Ruby, ela deve estar entre “<%” e “%>”. Há uma variação deste operador, o “<%=”, que não só executa códigos Ruby, mas também imprime o resultado na página HTML. É importante notar que todos os atributos de instância (@variavel) de um controlador estão disponíveis em sua view. Além disso, ela deve ter o mesmo nome do controlador, o que significa que a view da nossa action index do controlador restaurantes_controller.rb deve estar em app/views/restaurantes/index.html.erb. Precisamos de uma view que vá possibilitar inserir os valores de um novo restaurante: <form action=’/restaurantes/create’> Nome: <input type=’text’ name=’nome’/> <input type=’submit’ value=’Create’/> </form> E agora, para receber este valor nome no controlador, basta usar o hash params. (Repare que agora usamos outra action, create, para buscar os dados do formulário apresentado anteriormente): class RestaurantesController < ApplicationController def create nome = params[’nome’] end end O problema desta abordagem é que precisaríamos recuperar os valores enviados pelo formulário, um a um. Para um formulário com 15 campos, teríamos 15 linhas! Para simplificar esta tarefa, o Rails oferece a possibilidade de utilizar algo parecido com um hash para os valores dos atributos: <form action=’/restaurantes/create’> Nome: <input type=’text’ name=’restaurante[nome]’ /> Endereço: <input type=’text’ name=’restaurante[endereco]’ /> Especialidade: <input type=’text’ name=’restaurante[especialidade]’ /> <input type=’submit’ value=’Create’/> </form> Desta forma, podemos receber todos os valores como um hash nos controladores: class RestaurantesController < ApplicationController def create valores = params[’restaurante’] end end O mais interessante é que as classes ActiveRecord já aceitam um hash com os valores iniciais do objeto, tanto no método new, no método create (que já salva), quanto no método update_attributes: Capítulo 8 - Controllers e Views - Trabalhando com a View: O ERB - Página 104
  • 116. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Restaurante.create(params[’restaurante’]) 8.6 - Entendendo melhor o CRUD Agora, queremos ser capazes de criar, exibir, editar e remover restaurantes. Como fazer? Primeiro, temos de criar um controller para nosso restaurante. Pela view Generators, vamos criar um con- troller para restaurante. Rails, por padrão, utiliza-se de sete actions “CRUD”. São eles: • list: exibe todos os items • show: exibe um item específico • new: formulário para a criação de um novo ítem • create: cria um novo ítem • edit: formulário para edição de um ítem • update: atualiza um ítem existente • destroy: remove um ítem existente Desejamos listar todos os restaurantes do nosso Banco de Dados, e portanto criaremos a action list. Como desejamos que o comportamento padrão do nosso controlador restaurante seja exibir a listagem de restaurantes, podemos renomeá-la para index. Assim como no console buscamos todos os restaurantes do banco de dados com o comando find, também podemos fazê-lo em controllers (que poderão ser acessados pelas nossas views, como veremos mais adiante). Basta agora passar o resultado da busca para uma variável: def index @restaurantes = Restaurante.order("nome") end Para exibir um restaurante específico, precisamos saber qual restaurante buscar. Essa informação vem no “id” da url, e contem o id do restaurante que desejamos. Para acessá-la, podemos usar como parâmetro do método find params[id], que recupera as informações passadas no id da url. Agora, podemos criar nossa action show: def show @restaurante = Restaurante.find(params[:id]) end Para incluir um novo restaurante, precisamos primeiro retornar ao browser um restaurante novo, sem infor- mação alguma. Vamos criar nossa action new def new @restaurante = Restaurante.new end Uma vez que o usuário do nosso sistema tenha preenchido as informações do novo restaurante e deseje salvá-las, enviará uma requisição à nossa action create, passando como parâmetro na requisição, o novo restaurante a ser criado. Vamos criar nossa action: Capítulo 8 - Controllers e Views - Entendendo melhor o CRUD - Página 105
  • 117. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails def create @restaurante = Restaurante.new(params[:restaurante]) @restaurante.save end Para editar um restaurante, devemos retornar ao browser o restaurante que se quer editar, para só depois salvar as alterações feitas: def edit @restaurante = Restaurante.find(params[:id]) end Uma vez que o usuário tenha atualizado as informações do restaurante e deseje salvá-las, enviará uma requisição à nossa action update passando no id da url o id do restaurante a ser editado, bem como o restaurante que será “colado” em seu lugar: def update @restaurante = Restaurante.find(params[:id]) @restaurante.update_attributes(params[:restaurante]) end Para remover um restaurante, o usuário enviará uma requisição à nossa action destroy passando no id da url o id do restaurante a ser excluído: def destroy @restaurante = Restaurante.find(params[:id]) @restaurante.destroy end 8.7 - Exercícios: Controlador do Restaurante 1) Gere um controller para o modelo restaurante: a) Va ao Terminal; b) Execute rails generate controller restaurantes 2) Crie as actions CRUD para o controller criado: a) Abra o seu controller de Restaurantes (app/controllers/restaurantes_controllers.rb) b) Insira no controller a actions CRUD: class RestaurantesController < ApplicationController def index @restaurantes = Restaurante.order("nome") end def show @restaurante = Restaurante.find(params[:id]) end def new @restaurante = Restaurante.new Capítulo 8 - Controllers e Views - Exercícios: Controlador do Restaurante - Página 106
  • 118. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails end def create @restaurante = Restaurante.new(params[:restaurante]) if @restaurante.save redirect_to(:action => "show", :id => @restaurante) else render :action => "new" end end def edit @restaurante = Restaurante.find(params[:id]) end def update @restaurante = Restaurante.find(params[:id]) if @restaurante.update_attributes(params[:restaurante]) redirect_to(:action => "show", :id => @restaurante) else render :action => "edit" end end def destroy @restaurante = Restaurante.find(params[:id]) @restaurante.destroy redirect_to(:action => "index") end end 8.8 - Helper Helpers são módulos que disponibilizam métodos para serem usados em nossas views. Eles provêm atalhos para os códigos mais usados e nos poupam de escrever muito código. O propósito de um helper é simplificar suas views. Quando criamos um controller, o Rails automaticamente cria um helper para esse controller em app/helpers/. Todo método escrito num helper, estará automaticamente disponível em sua view. Existe um Helper especial, o application_helper.rb, cujos métodos ficam disponíveis para todas as views. Quando trabalhamos com formulários, usamos os chamados FormHelpers, que são módulos especial- mente projetados para nos ajudar nessa tarefa. Todo FormHelper está associado a um ActiveRecord. Existem também os FormTagHelpers, que contém um _tag em seu nome. FormTagHelpers, não estão necessaria- mente associados a ActiveRecord algum. Abaixo, uma lista dos FormHelpers disponíveis: • check_box Capítulo 8 - Controllers e Views - Helper - Página 107
  • 119. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails • fields_for • file_field • form_for • hidden_field • label • password_field • radio_button • text_area • text_field E uma lista dos FormTagHelpers: • check_box_tag • field_set_tag • file_field_tag • form_tag • hidden_field_tag • image_submit_tag • password_field_tag • radio_button_tag • select_tag • submit_tag • text_area_tag • text_field_tag Agora, podemos reescrever nossa view: <%= form_tag :action => ’create’ do %> Nome: <%= text_field :restaurante, :nome %> Endereço: <%= text_field :restaurante, :endereco %> Especialidade: <%= text_field :restaurante, :especialidade %> <%= submit_tag ’Criar’ %> <% end %> Repare que como utilizamos o form_tag, que não está associado a nenhum ActiveRecord, nosso outro Helper text_field não sabe qual o ActiveRecord que estamos trabalhando, sendo necessário passar para cada um deles o parâmetro :restaurante, informando-o. Capítulo 8 - Controllers e Views - Helper - Página 108
  • 120. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Podemos reescrever mais uma vez utilizando o FormHelper form_for, que está associado a um ActiveRecord: <%= form_for :restaurante, :url => { :action => ’create’ } do |f| %> Nome: <%= f.text_field :nome %> Endereço: <%= f.text_field :endereco %> Especialidade: <%= f.text_field :especialidade %> <%= submit_tag ’Criar’ %> <% end %> Repare agora que não foi preciso declarar o nome do nosso modelo para cada text_field, uma vez que nosso Helper form_for já está associado a ele. Helper Method Existe também o chamado helper_method, que permite que um método de seu controlador vire um Helper e esteja disponível na view para ser chamado. Exemplo: class TesteController < ApplicationController helper_method :teste def teste "algum conteudo dinamico" end end E em alguma das views deste controlador: <%= teste %> 8.9 - Exercícios: Utilizando helpers para criar as views 1) Vamos criar as views do restaurante: a) Crie o arquivo app/views/restaurantes/index.html.erb. b) Digite o conteúdo abaixo: <h1>Listagem de Restaurantes</h1> <table> <tr> <th>Nome</th> <th>Endereço</th> <th>Especialidade</th> </tr> <% @restaurantes.each do |restaurante| %> <tr> <td><%= restaurante.nome %></td> <td><%= restaurante.endereco %></td> <td><%= restaurante.especialidade %></td> <td><%= link_to ’Mostrar’, { :action => ’show’, :id => restaurante } %></td> Capítulo 8 - Controllers e Views - Exercícios: Utilizando helpers para criar as views - Página 109
  • 121. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails <td><%= link_to ’Editar’, { :action => ’edit’, :id => restaurante } %></td> <td><%= link_to ’Deletar’, { :action => ’destroy’, :id => restaurante } %></td> </tr> <% end %> </table> <br/> <%= link_to ’Novo’, { :action => ’new’ } %> c) Teste agora entrando em: http://localhost:3000/restaurantes (Não esqueça de iniciar o servidor) Capítulo 8 - Controllers e Views - Exercícios: Utilizando helpers para criar as views - Página 110
  • 122. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails d) Crie o arquivo app/views/restaurantes/show.html.erb e) Digite o conteúdo abaixo: <h1>Exibindo Restaurante</h1> <p> <b>Nome: </b> <%= @restaurante.nome %> </p> <p> <b>Endereço: </b> <%= @restaurante.endereco %> </p> <p> <b>Especialidade: </b> <%= @restaurante.especialidade %> </p> <%= link_to ’Editar’, { :action => ’edit’, :id => @restaurante } %> <%= link_to ’Voltar’, { :action => ’index’ } %> Capítulo 8 - Controllers e Views - Exercícios: Utilizando helpers para criar as views - Página 111
  • 123. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails f) Crie o arquivo app/views/restaurantes/new.html.erb g) Digite o conteúdo abaixo: <h1>Adicionando Restaurante</h1> <% if @restaurante.errors.any? %> <ul> <% @restaurante.errors.full_messages.each do |msg| %> <li><%= msg %></li> <% end %> </ul> <% end %> <%= form_for :restaurante, :url => { :action => ’create’ } do |f| %> Nome: <%= f.text_field :nome %><br/> Endereço: <%= f.text_field :endereco %><br/> Especialidade: <%= f.text_field :especialidade %><br/> <%= submit_tag ’Criar’ %> <% end %> <%= link_to ’Voltar’, { :action => ’index’ } %> h) Crie o arquivo app/views/restaurantes/edit.html.erb i) Digite o conteúdo abaixo: <h1>Editando Restaurante</h1> Capítulo 8 - Controllers e Views - Exercícios: Utilizando helpers para criar as views - Página 112
  • 124. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails <% if @restaurante.errors.any? %> <ul> <% @restaurante.errors.full_messages.each do |msg| %> <li><%= msg %></li> <% end %> </ul> <% end %> <%= form_for :restaurante, :url => { :action => ’update’, :id => @restaurante } do |f| %> Nome: <%= f.text_field :nome %><br/> Endereço: <%= f.text_field :endereco %><br/> Especialidade: <%= f.text_field :especialidade %><br/> <%= submit_tag ’Atualizar’ %> <% end %> <%= link_to ’Voltar’, { :action => ’index’ } %> j) Teste suas views: http://localhost:3000/restaurantes Não esqueça que existe uma validação para primeira letra maiúscula no nome do restaurante. 8.10 - Partial Agora, suponha que eu queira exibir em cada página do restaurante um texto, por exemplo: “Controle de Restaurantes”. Poderíamos escrever esse texto manualmente, mas vamos aproveitar essa necessidade para conhecer um pouco sobre Partials. Partials são fragmentos de html.erb que podem ser incluídas em uma view. Eles permitem que você reutilize sua lógica de visualização. Para criar um Partial, basta incluir um arquivo no seu diretório de views (app/views/restaurantes) com o seguinte nome: _meupartial. Repare que Partials devem obrigatóriamente começar com _. Para utilizar um Partial em uma view, basta acrescentar a seguinte linha no ponto que deseja fazer a inclusão: render :partial => "meupartial" 8.11 - Exercícios: Customizando o cabeçalho 1) Vamos criar um partial: a) Crie o arquivo: app/views/restaurantes/_titulo.html.erb b) Coloque o seguinte conteúdo: <h1>Controle de Restaurantes</h1><br/> Capítulo 8 - Controllers e Views - Partial - Página 113
  • 125. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails c) Abra todos os arquivos criados no exercício anterior (app/views/restaurantes/* ) d) Insira a seguinte linha no início: <%= render :partial => "titulo" %> Seu app/views/restaurantes deve estar com os seguintes arquivos: e) Teste suas views: http://localhost:3000/restaurantes 8.12 - Layout Como vimos, quando criamos um Partial, precisamos declará-lo em todas as páginas que desejamos utilizá- los. Existe uma alternativa melhor quando desejamos utilizar algum conteúdo estático que deve estar presente em todas as páginas: o layout. Cada controller pode ter seu próprio layout, e uma alteração nesse arquivo se refletirá por to- das as views desse controller. Os arquivos de layout devem ter o nome do controller, por exemplo app/views/layouts/restaurantes.html.erb. Um arquivo de layout “padrão” tem o seguinte formato: <html> <head> Capítulo 8 - Controllers e Views - Layout - Página 114
  • 126. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails <title>Um título</title> </head> <body> <p style="color: green"><%= flash[:notice] %></p> <%= yield %> </body> </html> Tudo o que está nesse arquivo pode ser modificado, com exceção do <%= yield %>, que renderiza cada view do nosso controlador. Também deixaremos a linha <p style="color: green”><%= flash[:notice] %></p>, pois ela é a responsável por exibir as mensagens do escopo flash. Podemos utilizar ainda o layout application.html.erb. Para isso, precisamos criar o arquivo app/views/layouts/application.html.erb e apagar os arquivos de layout dos controladores que queremos que utilizem o layout do controlador application. Com isso, se desejarmos ter um layout único para toda nossa aplicação, por exemplo, basta ter um único arquivo de layout. 8.13 - Exercícios: Criando o header 1) Nesse exercício, vamos utilizar o layout application para alterar o título de todas as janelas de nossa aplica- ção: a) Abra o arquivo app/views/layouts/application.html.erb b) Altere o title para Programa de Qualificação de Restaurantes c) Adicione <p style="color: green”><%= flash[:notice] %></p> no body <!DOCTYPE html> <html> <head> <title>Programa de Qualificação de Restaurantes</title> <%= stylesheet_link_tag :all %> <%= javascript_include_tag :defaults %> <%= csrf_meta_tag %> </head> <body> <p style="color: green"><%= flash[:notice] %></p> <%= yield %> </body> </html> Capítulo 8 - Controllers e Views - Exercícios: Criando o header - Página 115
  • 127. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails d) Teste suas views: http://localhost:3000/restaurantes. Repare no título das janelas. 8.14 - Outras formas de gerar a View O Rails já vem com suporte a outros handlers para geração de views. Além do ERB, podemos também usar o Builder e o RJS, que veremos mais adiante. O Builder é adequado quando a view a ser gerada é um arquivo XML, já que permite a criação de um xml usando sintaxe Ruby. Veja um exemplo: # app/views/authors/show.xml.builder xml.author do xml.name(’Alexander Pope’) end O xml resultante é: <author> <name>Alexander Pope</name> </author> Outra alternativa muito popular para a geração das views é o HAML: http://haml.hamptoncatlin.com #content .left.column Capítulo 8 - Controllers e Views - Outras formas de gerar a View - Página 116
  • 128. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails %h2 Welcome to our site! %p= print_information .right.column= render :partial => "sidebar" E o equivalente com ERB: <div id=’content’> <div class=’left column’> <h2>Welcome to our site!</h2> <p> <%= print_information %> </p> </div> <div class="right column"> <%= render :partial => "sidebar" %> </div> </div> 8.15 - Filtros O módulo ActionController::Filters define formas de executar código antes e depois de todas as actions. Para executar código antes das actions: class ClientesController < ApplicationController before_filter :verifica_login private def verifica_login redirect_to :controller => ’login’ unless usuario_logado? end end De forma análoga, podemos executar código no fim do tratamento da requisição: class ClientesController < ApplicationController after_filter :avisa_termino private def avisa_termino logger.info "Action #{params[:action]} terminada" end end Por fim, o mais poderoso de todos, que permite execução de código tanto antes, quanto depois da action a ser executada: class ClientesController < ApplicationController around_filter :envolvendo_actions private def envolvendo_actions Capítulo 8 - Controllers e Views - Filtros - Página 117
  • 129. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails logger.info "Antes de #{params[:action]}: #{Time.now}" yield logger.info "Depois de #{params[:action]}: #{Time.now}" end end Os filtros podem também ser definidos diretamente na declaração, através de blocos: class ClientesController < ApplicationController around_filter do |controller, action| logger.info "#{controller} antes: #{Time.now}" action.call logger.info "#{controller} depois: #{Time.now}" end end Caso não seja necessário aplicar os filtros a todas as actions, é possível usar as opções :except e :only: class ClientesController < ApplicationController before_filter :verifica_login, :only => [:create, :update] # ... end Logger As configurações do log podem ser feitas através do arquivo config/environment.rb, ou especifica- mente para cada environment nos arquivos da pasta config/environments. Entre as configurações que podem ser customizadas, estão qual nível de log deve ser exibido e para onde vai o log (stdout, arquivos, email, ...). Rails::Initializer.run do |config| # ... config.log_level = :debug config.log_path = ’log/debug.log’ # ... end Mais detalhes sobre a customização do log podem ser encotrados no wiki oficial do Rails: http://wiki.rubyonrails.org/rails/show/HowtoConfigureLogging Capítulo 8 - Controllers e Views - Filtros - Página 118
  • 130. C APÍTULO 9 Rotas e Rack “Não é possível estar dentro da civilização e fora da arte” – Rui Barbosa O modo como urls são ligadas a controladores e actions pode ser customizado no Rails. O módulo res- ponsável por esta parte é o que foi criado com o seu projeto NomeDoProjeto::Application.routes e as rotas podem ser customizadas no arquivo config/routes.rb. 9.1 - Rack O rack é uma abstração das requisições e respostas HTTP da maneira mais simples possível. Criando uma API unificada para servidores, frameworks, e softwares (os conhecidos middleware) em apenas uma chamada de método. A grande motivação da criação do Rack é que, diferente do mundo java onde existe uma especificação que abstrai todo o HTTP, no mundo ruby cada framework havia criado a sua forma de tratar as requisições e respostas. Por isso, escrever um servidor ou mesmo permitir que o framework X pudesse rodar em um servidor que já existisse era um trabalho realmente complicado. Graças ao surgimento do rack e da sua padronização hoje é possível que qualquer servidor que conheça rack consiga executar qualquer aplicação que se comunique com o HTTP através do rack. Mais do que isso, hoje também é possível fazer uma “aplicação” web em apenas uma linha. Exemplo: run Proc.new {|env| [200, {"Content-Type" => "text/html"}, ["Hello World"]]} Basta salvar esse arquivo, por exemplo como hello.ru, e subir nosso servidor pelo Terminal com o seguinte comando: rackup hello.ru Para criar uma “aplicação” em rack tudo o que precisamos é criar um método que retorne [httpStatusCode, headers, body], como no exemplo acima. O comando rackup é criado quando instalamos a gem ‘rack’ e serve para iniciar aplicações feitas em rack. Elas nada mais são que um arquivo ruby, mas devem ser salvos com a extensão .ru (RackUp) e devem chamar o método run. 9.2 - Exercícios - Testando o Rack 1) Vamos fazer uma aplicação rack. 119
  • 131. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails a) Crie um arquivo chamado “helloRack.ru” b) Adicione as seguintes linhas: run Proc.new {|env| [200, {"Content-Type" => "text/html"}, ["Hello World"]]} c) Inicie a aplicação com o comando rackup helloRack.ru d) Teste no browser pela url: http://localhost:9292/ 9.3 - routes.rb Veja abaixo como criar uma nova rota na nossa aplicação através do arquivo config/routes.rb: VotaPrato::Application.routes.draw do match ’inicio’, :controller => ’restaurantes’, :action => ’index’ end match cria uma nova rota e tem 2 formas de ser utilizado. Na nova maneira, ele recebe um único parâmetro que deve ser um hash, onde a chave do primerio elemento é a rota que queremos mapear, e o valor para essa chave deve ser uma string com o nome do controlador e da action separado por um caracter ‘#’, como no exemplo abaixo: match ’inicio’ => ’restaurantes#index’ Nesse exemplo o método match recebeu um hash onde a primeira chave é ‘inicio’ (rota a ser mapeada) e o valor para essa chave é ‘restaurantes#index’, ou seja, quando acessar localhost:3000/inicio o Rails vai executar a action index no controller restaurantes. A outra abordagem é usar o método match recebendo dois parâmetros: • url • hash com o conjunto de parâmetros de requisição a serem preenchidos No exemplo acima, para a url “localhost:3000/inicio” o método index do controlador de restaurantes (RestaurantesController) é chamado. Capítulo 9 - Rotas e Rack - routes.rb - Página 120
  • 132. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Qualquer parâmetro de requisição pode ser preenchido por uma rota. Tais parâmetros podem ser recupera- dos posteriormente através do hash de parâmetros da requisição, params[’nome’]. Os parâmetros :controller e :action são especiais, representam o controlador e a action a serem execu- tados. Uma das características mais interessantes do rails é que as urls das rotas podem ser usadas para capturar alguns dos parâmetros: match ’categorias/:nome’, :controller => ’categorias’, :action => ’show’ Neste caso, o parâmetro de requisição params[’nome’] é extraído da própria url! Rotas padrão Antigamente o Rails criava uma rota padrão. Hoje em dia ela continua no arquivo config/routes.rb, mas vem comentada por padrão: match ‘:controller(/:action(/:id(.:format)))’ Esta rota padrão que nos permitiu usar o formato de url que temos usado até agora. O nome do controlador e a action a ser executada são retirados da própria url chamada. Você pode definir quantas rotas forem necessárias. A ordem define a prioridade: rotas definidas no início tem mais prioridade que as do fim. 9.4 - Pretty URLs A funcionalidade de roteamento embutida no Rails é bastante poderosa, podendo até substituir mod_rewrite em muitos casos. As rotas permitem uma grande flexibilidade para criação de urls que se beneficiem de técnicas de Search Engine Optimization (SEO). Um exemplo interessante seria para um sistema de blog, que permitisse a exibição de posts para determi- nado ano: match ’blog/:ano’ => ’posts#list’ Ou ainda para um mês específico: match ’blog/:ano/:mes’ => ’posts#list’ Os parâmetros capturados pela url podem ter ainda valores default: match ’blog(/:ano)’ => ’posts#list’, :ano => 2011 Para o último exemplo, a url ‘http://localhost:3000/blog’ faria com que a action list do controlador PostsController fosse chamada, com o params[’ano’] sendo 2011. 9.5 - Named Routes Cada uma das rotas pode ter um nome único: match ’blog/:ano’ => ’posts#list’, :as => ’posts’ O funcionamento é o mesmo de antes, com a diferença que usando o ‘:as’ demos um nome à rota. Para cada uma das Named Routes são criados automaticamente dois helpers, disponíveis tanto nos contro- ladores quanto nas views: Capítulo 9 - Rotas e Rack - Pretty URLs - Página 121
  • 133. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails • posts_path => ‘/blog/:ano’ • posts_url => ‘http://localhost:3000/blog/:ano’ A convenção para o nome dos helpers é sempre nome_da_rota_path e nome_da_rota_url. Você pode ainda ver o roteamento para cada uma das urls disponíveis em uma aplicação rails com a ajuda de uma task do rake: rake routes 9.6 - REST - resources REST é um modelo arquitetural para sistemas distribuídos. A idéia básica é que existe um conjunto fixo de operações permitidas (verbs) e as diversas aplicações se comunicam aplicando este conjunto fixo de operações em recursos (nouns) existentes, podendo ainda pedir diversas representações destes recursos. A sigla REST vem de Representational State Transfer e surgiu da tese de doutorado de Roy Fielding, descre- vendo as idéias que levaram a criação do protocolo HTTP. A web é o maior exemplo de uso de uma arquitetura REST, onde os verbos são as operações disponíveis no protocolo (GET, POST, DELETE, PUT, HEADER, ...), os recursos são identificados pelas URLs e as representações podem ser definidas através de Mime Types. Ao desenhar aplicações REST, pensamos nos recursos a serem disponibilizados pela aplicação e em seus formatos, ao invés de pensar nas operações. Desde o Rails 1.2, o estilo de desenvolvimento REST para aplicações web é encorajado pelo framework, que possui diversas facilidades para a adoção deste estilo arquitetural. As operações disponíveis para cada um dos recursos são: • GET: retorna uma representação do recurso • POST: criação de um novo recurso • PUT: altera o recurso • DELETE: remove o recurso Os quatro verbos do protocolo HTTP são comumente associados às operações de CRUD em sistemas Restful. Há uma grande discussão dos motivos pelos quais usamos POST para criação (INSERT ) e PUT para alteração (UPDATE). A razão principal é que o protocolo HTTP especifica que a operação PUT deve ser idempotente, já POST não. Idempotência Operações idempotentes são operações que podem ser chamadas uma ou mais vezes, sem dife- renças no resultado final. Idempotência é uma propriedade das operações. A principal forma de suporte no Rails a estes padrões é através de rotas que seguem as convenções da arquitetura REST. Ao mapear um recurso no routes.rb, o Rails cria automaticamente as rotas adequadas no controlador para tratar as operações disponíveis no recurso (GET, POST, PUT e DELETE). Capítulo 9 - Rotas e Rack - REST - resources - Página 122
  • 134. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails # routes.rb resources :restaurantes Ao mapear o recurso :restaurantes, o rails automaticamente cria as seguintes rotas: • GET /restaurantes :controller => ‘restaurantes’, :action => ‘index’ • POST /restaurantes :controller => ‘restaurantes’, :action => ‘create’ • GET /restaurantes/new :controller => ‘restaurantes’, :action => ‘new’ • GET /restaurantes/:id :controller => ‘restaurantes’, :action => ‘show’ • PUT /restaurantes/:id :controller => ‘restaurantes’, :action => ‘update’ • DELETE /restaurantes/:id :controller => ‘restaurantes’, :action => ‘destroy’ • GET /restaurantes/:id/edit :controller => ‘restaurantes’, :action => ‘edit’ Como é possível perceber através das rotas, todo recurso mapeado implica em sete métodos no controlador associado. São as famosas sete actions REST dos controladores rails. Além disso, para cada rota criada, são criados os helpers associados, já que as rotas são na verdade Named Routes. restaurantes_path # => "/restaurantes" new_restaurante_path # => "/restaurantes/new" edit_restaurante_path(3) # => "/restaurantes/3/edit" Rails vem com um generator pronto para a criação de novos recursos. O controlador (com as sete actions), o modelo, a migration, os esqueleto dos testes (unitário, funcional e fixtures) e a rota podem ser automaticamente criados. rails generate resource comentario O gerador de scaffolds do Rails 2.0 em diante, também usa o modelo REST: rails generate scaffold comentario conteudo:text author:string Na geração do scaffold são produzidos os mesmos artefatos de antes, com a adição das views e de um layout padrão. Não deixe de verificar as rotas criadas e seus nomes (Named Routes): Capítulo 9 - Rotas e Rack - REST - resources - Página 123
  • 135. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails rake routes 9.7 - Actions extras em Resources As sete actions disponíveis para cada resource costumam ser suficientes na maioria dos casos. Antes de colocar alguma action extra nos seus resources, exercite a possibilidade de criar um novo resource para tal. Quando necessário, você pode incluir algumas actions extras para os resources: resources :comentarios do member do post :desabilita end # url: /comentarios/:id/desabilita, named_route: desabilita_comentario_path end :member define actions que atuam sobre um recurso específico: /comentarios/1/desabilita. Dentro do bloco member usar dessa forma method :action, onde method pode ser get, post, put, delete ou any. Outro bloco que pode ser usado dentro de um resource é o collection que serve para definir actions extras que atuem sobre o conjunto inteiro de resources. Definirá rotas do tipo /comentarios/action. resources :comentarios do collection do get :feed end # url: /comentarios/feed, named_route: feed_comentarios_path end Para todas as actions extras, são criadas Named Routes adequadas. Use o rake routes como referência para conferir os nomes dados às rotas criadas. 9.8 - Diversas Representações Um controlador pode ter diversos resultados. Em outras palavras, controladores podem responder de diver- sas maneiras, através do método respond_to: class MeuController < ApplicationController def list respond_to do |format| format.html format.js do render :update do |page| page.insert_html :top, ’div3’, "Novo conteudo" end end format.xml end end def O convenção para o nome da view de resultado é sempre: Capítulo 9 - Rotas e Rack - Actions extras em Resources - Página 124
  • 136. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails app/views/:controller/:action.:format.:handler Os handlers disponíveis por padrão no Rails são: erb, builder, rhtml, rxml e rjs. Os formatos instalados por padrão ficam na constante Mime::SET e você pode instalar outros pelo arquivo ‘config/initializers/mime_types.rb’. 9.9 - Para Saber Mais - Nested Resources Quando há relacionamentos entre resources, podemos aninhar a definição das rotas, que o rails cria auto- maticamente as urls adequadas. No nosso exemplo, :restaurante has_many :qualificacoes, portanto: # routes.rb resources :restaurantes do resources :qualificacoes end A rota acima automaticamente cria as rotas para qualificações específicas de um restaurante: • GET /restaurante/:restaurante_id/qualificacoes :controller => ‘qualificacoes’, :action => ‘index’ • GET /restaurante/:restaurante_id/qualificacoes/:id :controller => ‘qualificacoes’, :action => ‘show’ • GET /restaurante/:restaurante_id/qualificacoes/new :controller => ‘qualificacoes’, :action => ‘new’ • ... As sete rotas comuns são criadas para o recurso :qualificacao, mas agora as rotas de :qualificacoes são sempre específicas a um :restaurante (todos os métodos recebem o params[’restaurante_id’]). 9.10 - Rails e o Rack A partir do Rails 3, quando criamos uma nova aplicação, um dos arquivos que ele cria é config.ru na raiz do projeto e, mais que isso, podemos afirmar que toda aplicação Rails 3 é uma applicação rack. Prova disso é que conseguimos iniciar a aplicação através do comando rackup config.ru Capítulo 9 - Rotas e Rack - Para Saber Mais - Nested Resources - Página 125
  • 137. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Outro ponto interessante sobre o rack e o Rails, é que agora é possível mapear uma aplicação rack direta- mente em uma rota de uma aplicação rails. # routes.rb match ’rack’, :to => proc{|env| [200, {"Content-Type" => "text/html"}, ["App Rack numa rota Rails"]]} Capítulo 9 - Rotas e Rack - Rails e o Rack - Página 126
  • 138. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 9.11 - Exercícios - Criando um rota para uma aplicação Rack 1) Vamos fazer uma aplicação rack. a) Abra o arquivo “routes.rb” b) Adicione a seguinte linha: match ’rack’, :to => proc{|env| [200, {"Content-Type" => "text/html"}, ["App Rack numa rota Rails"]]} c) Inicie a aplicação com o comando rails server d) Teste no browser pela url: http://localhost:3000/rack Capítulo 9 - Rotas e Rack - Exercícios - Criando um rota para uma aplicação Rack - Página 127
  • 139. C APÍTULO 10 Completando o Sistema “O êxito parece doce a quem não o alcança” – Dickinson, Emily 10.1 - Um pouco mais sobre o Scaffold Vimos que quando usamos o gerador scaffold o Rails cria os arquivos necessários em todas as cama- das. Controller, Model, Views e até mesmo arquivos de testes e a Migration. Para concluir nossos projeto precisamos criar apenas Controller + Views pois tanto o modelo quanto as migrations já estão prontos. Para isso vamo usar o mesmo gerador scaffold mas vamos passar os parâmetros: --migration=false para ele igno- rar a criação da migration e o parâmetro -s que é a abreviação para --skip que faz com que o rails “pule” os arquivos já existentes. Para concluir os modelos que já começamos vamos executar o gerador da seguinte manera: rails generate scaffold cliente nome:string idade:integer --migration=false -s Outros paramêtros nos geradores Para conhecer todas as opções de parâmetros que um gerador pode receber tente executá-lo pas- sando o parâmetro -h Ex. rails generate scaffold -h 10.2 - Exercícios 1) Vamos gerar os outros controllers e views usando o scaffold: a) Primeiro vamos gerar o scaffold para cliente b) Va ao Terminal c) Execute: rails generate scaffold cliente nome:string idade:integer --migration=false -s 128
  • 140. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails d) Agora vamos gerar para qualificacao. e) Execute: rails generate scaffold qualificacao cliente_id:integer restaurante_id:integer nota:float valor_gasto:float --migration=false -s f) Olhe as views criadas (app/views/clientes e app/views/qualificacoes) Capítulo 10 - Completando o Sistema - Exercícios - Página 129
  • 141. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails g) Olhe as rotas criadas (config/routes.rb) h) Abra os arquivos app/views/clientes/index.html.erb e app/views/restaurantes/index.html.erb e apa- gue as linhas que chamam a action destroy Lembre-se de que não queremos inconsistências na nossa tabela de qualificações i) Reinicie o servidor j) Teste: http://localhost:3000/clientes e http://localhost:3000/qualificacoes Note que precisamos utilizar a opção “--migration=false” no comando scaffold, além de informar manu- almente os atributos utilizados em nossas migrations. Isso foi necessário, pois já tinhamos um migration Capítulo 10 - Completando o Sistema - Exercícios - Página 130
  • 142. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails pronto, e queríamos que o Rails gerasse os formulários das views para nós, e para isso ele precisaria conhecer os atributos que queríamos utilizar. css scaffold O comando scaffold, quando executado, gera um css mais bonito para nossa aplicação. Se quiser utilizá-lo, edite nosso layout (app/views/layouts/application.html.erb) e adicione a seguinte linha logo abaixo da tag <title>: <%= stylesheet_link_tag ‘scaffold’ %> 2) Vamos agora incluir Helpers no nosso Layout, para poder navegar entre Restaurante, Cliente e Qualificação sem precisarmos digitar a url: a) Abra o Helper “applications": “app/helpers/application_helper.rb” b) Digite o seguinte método: def menu_principal menu = %w(cliente qualificacao restaurante) menu_principal = "<ul>" menu.each do |item| menu_principal << "<li>" + link_to(item, :controller => item.pluralize) + "</li>" end menu_principal << "</ul>" raw menu_principal end c) Adicione a chamada ao método <%=menu_principal %> no nosso layout (app/views/layouts/application.html.erb), ficando desse jeito: ... <body> <%= menu_principal %> <p style="color: green"><%= flash[:notice] %></p> <%= yield %> </body> ... Capítulo 10 - Completando o Sistema - Exercícios - Página 131
  • 143. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails d) Teste: http://localhost:3000/restaurantes 10.3 - Selecionando Clientes e Restaurante no form de Qualificações Você já deve ter reparado que nossa view de adição e edição de qualificações está um tanto quanto estranha: precisamos digitar os IDs do cliente e do restaurante manualmente. Para corrigir isso, podemos utilizar o FormHelper select, inserindo o seguinte código nas nossas views de adição e edição de qualificações: <%= select(’qualificacao’, ’cliente_id’, Cliente.order(:nome).collect {|p| [ p.nome, p.id]}) %> em substituição ao: <%= f.text_field :cliente_id %> Mas existe um outro FormHelper mais elegante, que produz o mesmo efeito, o collection_select: <%= collection_select(:qualificacao, :cliente_id, Cliente.order(:nome), :id, :nome, {:prompt => true}) %> Como estamos dentro de um form_for, podemos usar do fato de que o formulário sabe qual o nosso Active- Record, e com isso fazer apenas: <%= f.collection_select(:cliente_id, Cliente.order(:nome), :id, :nome, {:prompt => true}) %> Capítulo 10 - Completando o Sistema - Selecionando Clientes e Restaurante no form de Qualificações - Página 132
  • 144. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 10.4 - Exercícios 1) Vamos utilizar o FormHelper collection_select para exibirmos o nome dos clientes e restaurantes nas nossas views da qualificação: a) Abra o arquivo app/views/qualificacoes/_form.html.erb b) Troque a linha: <%= f.text_field :cliente_id %> por: <%= f.collection_select(:cliente_id, Cliente.order(’nome’), :id, :nome, {:prompt => true}) %> c) Troque a linha: <%= f.text_field :restaurante_id %> por: <%= f.collection_select(:restaurante_id, Restaurante.order(’nome’), :id, :nome, {:prompt => true}) %> d) Teste: http://localhost:3000/qualificacoes 2) Agora vamos exibir o nome dos restaurantes e clientes nas views index e show de qualificações: Capítulo 10 - Completando o Sistema - Exercícios - Página 133
  • 145. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails a) Abra o arquivo app/views/qualificacoes/show.html.erb b) Troque a linha: <%= @qualificacao.cliente_id %> por: <%= @qualificacao.cliente.nome %> c) Troque a linha: <%= @qualificacao.restaurante_id %> por: <%= @qualificacao.restaurante.nome %> d) Abra o arquivo app/views/qualificacoes/index.html.erb Capítulo 10 - Completando o Sistema - Exercícios - Página 134
  • 146. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails e) Troque as linhas: <td><%= qualificacao.cliente_id %></td> <td><%= qualificacao.restaurante_id %></td> por: <td><%= qualificacao.cliente.nome %></td> <td><%= qualificacao.restaurante.nome %></td> f) Teste: http://localhost:3000/qualificacoes 3) Por fim, vamos utilizar o FormHelper hidden_field para permitir a qualificação de um restaurante a partir da view show de um cliente ou de um restaurante. No entanto, ao fazer isso, queremos que não seja necessário a escolha de cliente ou restaurante. Para isso: a) Abra o arquivo app/views/qualificacoes/_form.html.erb b) Troque as linhas <p> <%= f.label :cliente_id %><br /> <%= f.collection_select(:cliente_id, Cliente.order(’nome’), :id, :nome, {:prompt => true}) %> </p> por: <% if @qualificacao.cliente %> Capítulo 10 - Completando o Sistema - Exercícios - Página 135
  • 147. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails <%= f.hidden_field ’cliente_id’ %> <% else %> <p><%= f.label :cliente_id %><br /> <%= f.collection_select(:cliente_id, Cliente.order(’nome’), :id, :nome, {:prompt => true}) %></p> <% end %> c) Troque as linhas <p> <%= f.label :restaurante_id %><br /> <%= f.collection_select(:restaurante_id, Restaurante.order(’nome’), :id, :nome, {:prompt => true}) %> </p> por: <% if @qualificacao.restaurante %> <%= f.hidden_field ’restaurante_id’ %> <% else %> <p><%= f.label :restaurante_id %><br /> <%= f.collection_select(:restaurante_id, Restaurante.order(’nome’), :id, :nome, {:prompt => true}) %></p> <% end %> d) Adicione a seguinte linha na view show do cliente (app/views/clientes/show.html.erb): <%= link_to "Nova qualificação", :controller => "qualificacoes", :action => "new", :cliente => @cliente %> Capítulo 10 - Completando o Sistema - Exercícios - Página 136
  • 148. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails e) Adicione a seguinte linha na view show do restaurante (app/views/restaurantes/show.html.erb): <%= link_to "Qualificar este restaurante", :controller => "qualificacoes", :action => "new", :restaurante => @restaurante %> Capítulo 10 - Completando o Sistema - Exercícios - Página 137
  • 149. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails f) Por fim, precisamos fazer com que o controlador da action new das qualificações receba os parâmetros para preenchimento automático. Abra o controller app/controllers/qualificacoes_controller.rb g) Adicione as seguintes linhas à nossa action new: if params[:cliente] @qualificacao.cliente = Cliente.find(params[:cliente]) end if params[:restaurante] @qualificacao.restaurante = Restaurante.find(params[:restaurante]) end Capítulo 10 - Completando o Sistema - Exercícios - Página 138
  • 150. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails h) Teste: http://localhost:3000/clientes, entre na página Show de um cliente e faça uma nova qualifi- cação. 10.5 - Exercícios Opcionais 1) Crie um método no nosso Application Helper para converter um número para valor monetário: a) Abra o arquivo app/helpers/application_helper.rb b) Adicione o seguinte método: def valor_formatado(number) number_to_currency(number, :unit => "R$", :separator => ",", :delimiter => ".") end Capítulo 10 - Completando o Sistema - Exercícios Opcionais - Página 139
  • 151. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails c) Em app/views/qualificacoes/index.html.erb e app/views/qualificacoes/show.html.erb, troque o se- guinte código: @qualificacao.valor_gasto por: valor_formatado(@qualificacao.valor_gasto) 10.6 - Mais sobre os controllers Podemos notar que nossas actions, por exemplo a index, fica muito parecida com a action index de outros controladores, mudando apenas o nome do modelo em questão. #qualificacoes_controller def index @qualificacoes = Qualificacao.all respond_to do |format| format.html # index.html.erb format.xml { render :xml => @qualificacoes } end end #clientes_controller def index @clientes = Cliente.all respond_to do |format| format.html # index.html.erb format.xml { render :xml => @clientes } end end Normalmente precisamos fazer exatamente a mesma ação para formatos iguais e por isso acabamos repe- tindo o mesmo bloco de respond_to nas actions. Para solucionar esse problema, no rails 3 acrescentaram o método respond_to nos controllers e o método respond_with nas actions. Veja o exemplo: class ClientesController < ApplicationController respond_to :html, :xml # GET /clientes # GET /clientes.xml def index @clientes = Cliente.all respond_with @clientes end # GET /clientes/1 # GET /clientes/1.xml Capítulo 10 - Completando o Sistema - Mais sobre os controllers - Página 140
  • 152. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails def show @cliente = Cliente.find(params[:id]) respond_with @cliente end ... end Dessa forma estamos dizendo para o rails que esse controller irá responder para os formatos html e xml, dentro da action basta eu dizer qual objeto é pra ser usado. No caso da action index, se a requisição pedir o formato html, o rails simplesmente irá enviar a chamada para o arquivo views/clientes/index.html.erb e a variável @clientes estará disponível lá. Se a requisição pedir o formato xml, o rails fará exatamente o mesmo que estava no bloco de respond_to que o scaffold criou, irá renderizar a variável @clientes em xml. O bloco de código acima é equivalente ao gerado pelo scaffold: class ClientesController < ApplicationController # GET /clientes # GET /clientes.xml def index @clientes = Cliente.all respond_to do |format| format.html # index.html.erb format.xml { render :xml => @clientes } end end # GET /clientes/1 # GET /clientes/1.xml def show @cliente = Cliente.find(params[:id]) respond_to do |format| format.html # show.html.erb format.xml { render :xml => @cliente } end end ... end Veja na imagem como ficaria o ClientesController usando essa outra maneira de configurar os controllers. Capítulo 10 - Completando o Sistema - Mais sobre os controllers - Página 141
  • 153. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Capítulo 10 - Completando o Sistema - Mais sobre os controllers - Página 142
  • 154. C APÍTULO 11 Calculations “Ao examinarmos os erros de um homem conhecemos o seu caráter” – Chamfort, Sébastien Roch Nesse capítulo, você aprenderá a utilizar campos para calcular fórmulas como, por exemplo, a média de um campo. 11.1 - Métodos Uma vez que existem os campos valor gasto e nota, seria interessante disponibilizar para os visitantes do site a média de cada um desses campos para determinado restaurante. Em Rails esse recurso é chamado calculations, métodos dos nossos modelos que fazem operações mais comuns com campos numéricos como, por exemplo: • average(column_name, options = {}) - média • maximum(column_name, options = {}) - maior valor • minimum(column_name, options = {}) - menor valor • sum(column_name, options = {}) - soma • count(*args) - número de entradas 11.2 - Média Supondo que o cliente pediu para adicionar a nota média de um restaurante na tela com as informações do mesmo (show). Basta adicionar uma chamada ao método average das qualificações do nosso restaurante: <b>Nota média: </b><%= @restaurante.qualificacoes.average(:nota) %><br/> Podemos mostrar também o número total de qualificações que determinado restaurante possui: <b>Qualificações: </b><%= @restaurante.qualificacoes.count %><br/> E, por último, fica fácil adicionar o valor médio gasto pelos clientes que visitam tal restaurante: <b>Preço médio: </b><%= @restaurante.qualificacoes.average(:valor_gasto) %><br/> 143
  • 155. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 11.3 - Exercícios 1) Altere a view show de restaurante para mostrar sua nota média, quantas qualificações possui e preço médio: a) Insira as seguintes linhas em app/views/restaurantes/show.html.erb: <b>Nota média: </b><%= @restaurante.qualificacoes.average(:nota) %><br/> <b>Qualificações: </b><%= @restaurante.qualificacoes.count %><br/> <b>Preço médio: </b><%= @restaurante.qualificacoes.average(:valor_gasto) %><br/><br/> b) Entre no link http://localhost:3000/restaurantes e escolha um restaurante para ver suas estatísti- cas. Capítulo 11 - Calculations - Exercícios - Página 144
  • 156. C APÍTULO 12 Associações Polimórficas “Os negócios são o dinheiro dos outros” – Alexandre Dumas Nesse capítulo você verá como criar uma relação muitos-para-muitos para mais de um tipo de modelo. 12.1 - Nosso problema O cliente pede para a equipe de desenvolvedores criar uma funcionalidade que permita aos visitantes deixar comentários sobre suas visitas aos restaurantes. Para complicar a vida do programador, o cliente pede para permitir comentários também em qualificações, permitindo aos usuários do site justificar a nota que deram. Esse problema poderia ser resolvido de diversas maneiras sendo que trabalharemos em cima de um modelo para representar um comentário, relacionado com restaurantes e qualificações, aproveitando para mostrar como realizar tal tipo de relacionamento. Seria simples se pudéssemos criar mais uma tabela com o comentário em si e o id da entidade relacionada. O problema surge no momento de diferenciar um comentário sobre qualificação de um sobre restaurante. Para diferenciar os comentários de restaurantes e qualificações, podemos usar um atributo de nome “tipo”. Em Ruby podemos criar apelidos para um ou mais modelos, algo similar a diversas classes implementarem determinada interface (sem métodos) em java. Podemos chamar nossos modelos Restaurante e Qualificacao como comentáveis, por exemplo. Um exemplo dessa estrutura em Java é o caso de Serializable – interface que não obriga a implementação de nenhum método mas serve para marcar classes como serializáveis, sendo que diversas classes da api padrão do Java implementam a primeira. No caso do Ruby, começamos criando um modelo chamado Comentario. 12.2 - Alterando o banco de dados O conteúdo do script de migração criará as colunas “comentário”, “id de quem tem o comentário”, e o “tipo”. Nos campos id e tipo, colocamos o nome da coluna com o apelido seguido de _id e _type, respectiva- mente, notificando o Ruby que ele deve buscar tais dados daquilo que é “comentavel”. Note que no português a palavra “comentavel” soa estranho e parece esquisito trabalhar com ela, mas para seguir o padrão definido no inglês em diversas linguagens, tal apelido indica o que os modelos são capazes de fazer e, no caso, eles são “comentáveis”. 145
  • 157. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails O script deve então criar três colunas, sem nada de novo comparado com o que vimos até agora: rails generate scaffold comentario conteudo:text comentavel_id:integer comentavel_type:string Caso seja necessário, podemos ainda adicionar índices físicos nas colunas do relacionamento, deixando a migration criada como a seguir: class CreateComentarios < ActiveRecord::Migration def self.up create_table :comentarios do |t| t.text :conteudo t.integer :comentavel_id t.string :comentavel_type t.timestamps end add_index :comentarios, :comentavel_type add_index :comentarios, :comentavel_id end def self.down drop_table :comentarios end end Para trabalhar nos modelos, precisamos antes gerar a nova tabela necessária: rake db:migrate O modelo Comentario (app/models/comentario.rb) deve poder ser associado a qualquer objeto do grupo de modelos comentáveis. Qualquer objeto poderá fazer o papel de comentavel, por isso dizemos que a associação é polimórfica: class Comentario < ActiveRecord::Base belongs_to :comentavel, :polymorphic => true end A instrução :polymorphic indica a não existência de um modelo com o nome :comentavel. Falta agora comentar que uma qualificação e um restaurante terão diversos comentários, fazendo o papel de algo comentavel. Para isso usaremos o relacionamento has_many: class Qualificacao < ActiveRecord::Base belongs_to :cliente belongs_to :restaurante has_many :comentarios, :as => :comentavel Capítulo 12 - Associações Polimórficas - Alterando o banco de dados - Página 146
  • 158. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails # ... end E o Restaurante: class Restaurante < ActiveRecord::Base has_many :qualificacoes has_many :comentarios, :as => :comentavel # ... end A tradução do texto pode ser quase literal: o modelo TEM MUITOS comentários COMO comentável. 12.3 - Exercícios 1) Vamos criar o modelo do nosso comentário e fazer a migração para o banco de dados: a) Va ao Terminal b) Digite: rails generate scaffold comentario conteudo:text comentavel_id:integer comenta- vel_type:string c) Vamos inserir alguns índices físicos. Abra o arquivo db/migrate/<timestamp>_create_comentarios.rb d) Insira as seguintes linhas: add_index :comentarios, :comentavel_type add_index :comentarios, :comentavel_id Capítulo 12 - Associações Polimórficas - Exercícios - Página 147
  • 159. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails e) Volte ao Terminal para executar a migration f) Execute: rake db:migrate 2) Vamos modificar nossos modelos: a) Abra o arquivo app/models/comentario.rb b) Adicione a seguinte linha: belongs_to :comentavel, :polymorphic => true c) Abra o arquivo app/models/qualificacao.rb Capítulo 12 - Associações Polimórficas - Exercícios - Página 148
  • 160. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails d) Adicione a seguinte linha: has_many :comentarios, :as => :comentavel e) Abra o arquivo app/models/restaurante.rb f) Adicione a seguinte linha: has_many :comentarios, :as => :comentavel Capítulo 12 - Associações Polimórficas - Exercícios - Página 149
  • 161. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 3) Para o próximo capítulo, iremos precisar que o nosso sistema já inclua alguns comentários. Para criá-los, você pode usar o rails console ou ir em http://localhost:3000/comentarios e adicionar um comentá- rio qualquer para o “Comentavel” 1, por exemplo, e o tipo “Restaurante”. Isso criará um comentário para o restaurante de ID 1. Capítulo 12 - Associações Polimórficas - Exercícios - Página 150
  • 162. C APÍTULO 13 Ajax com Rails “O Cliente tem sempre razão” – Selfridge, H. Nesse capítulo, você verá como trabalhar com AJAX de maneira não obstrusiva no Rails. 13.1 - Adicionando comentários nas views Até agora trabalhamos com arquivos html.erb, que são páginas html com scripts em ruby, mas nada de javascript. Como o Ruby on Rails é um framework voltado para o desenvolvimento web, é natural que a questão do javascript seja levantada. O Rails, antes da versão 3, tentava facilitar o desenvolvimento de código javascript com recursos como o RJS Templates, que produzia código javascript a partir de código Ruby. Contudo, o código gerado era acoplado ao Prototype, o que dificultava o uso de outras bibliotecas poulares como o JQuery. No Rails 3 optou-se por uma nova forma, não obstrutiva, de se trabalhar com javascript, permintindo que os desenvolvedores tenham controle absoluto do código criado, e podendo, inclusive, escolher a biblioteca que será usada (Prototype, JQuery, Moo-tools ou qual quer outra, desde que um driver exista para essa biblioteca). 13.2 - Instalando manualmente o JQuery no projeto Para instalar o JQuery, a única coisa que precisa ser feita é colocar o arquivo do JQuery que você pode baixar direto do site oficial do projeto e o ‘driver’ para o Rails que pode ser baixado em http://github.com/rails/ jquery-ujs. Pegue esses 2 arquivos e coloque no public/javascript/ do seu projeto para que o Rails possa encontrá-los. Outro passo importante é remover os arquivos do Prototype que o Rails insere automaticamente durante a criação dos projetos, para que não ocorram conflitos. 151
  • 163. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Copiados os arquivos, precisamos fazer com que o Rails importe esses arquivos nas nos- sas páginas. A maneira mais fácil de fazer isso é alterar nosso application layout, no arquivo app/views/layout/application.html.erb , para que sejam incluídos todos os arquivos de javascript. Para tanto, basta mudar a linha do javascript_include_tag para :all, como no exemplo abaixo: <%= javascript_include_tag ’jquery’, ’rails’ %> Capítulo 13 - Ajax com Rails - Instalando manualmente o JQuery no projeto - Página 152
  • 164. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 13.3 - Instalando o JQuery no projeto usando a gem jquery-rails Abra o arquivo Gemfile e adicione a seguinte linha: gem ’jquery-rails’, ’>= 0.2.6’ Agora execute no terminal: bundle install rails generate jquery:install 13.4 - Criando as chamadas AJAX Falta ainda escrever a funcionalidade de adicionar comentários aos nossos restaurantes e qualificações. Podemos, aqui, utilizar AJAX para uma experiência mais marcante no uso do site pelos usuários. Nosso primeiro passo será possibilitar a inclusão da lista de comentários nas páginas de qualquer modelo que seja comentável. Para não repetir este código em todas as páginas que aceitem comentários, podemos isolá-lo em um helper: def comentarios(comentavel) comentarios = "<div id=’comentarios’>" comentarios << "<h3>Comentarios</h3>" comentavel.comentarios.each do |comentario| comentarios << render(:partial => "comentarios/comentario", :locals => { :comentario => comentario }) end comentarios << "</div>" raw comentarios end Capítulo 13 - Ajax com Rails - Instalando o JQuery no projeto usando a gem jquery-rails - Página 153
  • 165. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Podemos simplificar o código acima, utilizando a opção :collection. Dessa maneira, o partial é renderizado uma vez para cada elemento que eu tenha no meu array: def comentarios(comentavel) comentarios = "<div id=’comentarios’>" comentarios << "<h3>Comentarios</h3>" comentarios << render(:partial => "comentarios/comentario", :collection => comentavel.comentarios) unless comentavel.comentarios.empty? comentarios << "</div>" raw comentarios end Agora, vamos criar o partial responsável pela renderização de cada um dos comentários. Repare que usamos o método link_to passando o parâmetro :remote => true, que faz uma chamada a uma url utilizando para isso uma requisição assíncrona (AJAX ): <!-- /app/views/comentarios/_comentario.html.erb --> <p id="comentario_<%= comentario.id %>"> <%= comentario.conteudo %> - <%= link_to ’(remover)’, comentario, :method => :delete, :remote => true, :id => "remove_comentario_#{comentario.id}" %> </p> Além disso, precisamos invocar nosso helper em app/views/restaurantes/show.html.erb e app/views/qualificacoes/show.html.erb: <%= comentarios @qualificacao %> Tente clicar no link e verá que nada acontece, porém ao recarregar a página, o comentário foi removido! A ação ComentariosController#destroy está sendo chamada de forma assíncrona (Ajax), porém a página não foi atualizada. Por isso precisamos tratar a responsta do servidor para remover o item da página. Para isso, primeiramente vamos alterar o app/views/layouts/application.html.erb para nos possibilitar escre- vermos javascript no mesmo arquivo que exibe os comentários. <!-- /app/views/layouts/application.html.erb --> <!DOCTYPE html> <html> <head> <title>Restaurante2</title> <%= stylesheet_link_tag :all %> <%= javascript_include_tag :defaults %> <%= csrf_meta_tag %> </head> <body> <%= yield %> <script type="text/javascript"> <%=yield :js%> </script> Capítulo 13 - Ajax com Rails - Criando as chamadas AJAX - Página 154
  • 166. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails </body> </html> Usando o yield Usando o yield passando um símbolo como parâmentro podemos usar o método content_for nas nossas views e fazer um tipo de include inteligente nos nossos arquivos. Agora vamos alterar novamente o arquivo app/views/comentarios/_comentario.html.erb para colocar o ja- vascript que será renderizado no lugar do ‘yield :js’. <p id="comentario_<%= comentario.id %>"> <%= comentario.conteudo()%> <%= link_to ’remover’, comentario, :method => :delete, :remote => true, :id => "remove_comentario_#{comentario.id}"%> </p> <%= content_for :js do%> $(’#remove_comentario_<%=comentario.id%>’).bind( ’ajax:success’, function(xhr, result){ $(’#comentario_<%=comentario.id%>’).remove(); } ); <%end%> Dessa forma, teremos um html gerado parecido com esse: <div id=’comentarios’><h3><Comentarios></h3> <p id="comentario_1"> comentario 1 <a href="/comentarios/1" data-method="delete" data-remote="true" id="remove_comentario_1" rel="nofollow">remover</a> </p> <p id="comentario_2"> Comentario 2 <a href="/comentarios/2" data-method="delete" data-remote="true" id="remove_comentario_2" rel="nofollow">remover</a> </p> <!-- Continuação do HTML --> <script type="text/javascript"> $(’#remove_comentario_1’).bind( ’ajax:success’, function(xhr, result){ $(’#comentario_1’).remove(); } Capítulo 13 - Ajax com Rails - Criando as chamadas AJAX - Página 155
  • 167. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails ); $(’#remove_comentario_2’).bind( ’ajax:success’, function(xhr, result){ $(’#comentario_2’).remove(); } ); </script> </body> Basta fazermos com que nossa action destroy não renderize nada , adicionando mais um formato ao bloco respond_to: def destroy @comentario = Comentario.find(params[:id]) @comentario.destroy respond_to do |format| format.xml { head :ok } format.js { head :ok } end end end 13.5 - Exercícios 1) Vamos instalar o JQuery na nossa aplicação a) Adicione a linha abaixo no arquivo Gemfile gem ’jquery-rails’, ’>= 0.2.6’ b) Execute o gerador do jquery-rails para instalar o jquery no projeto. rails generate jquery:install c) Abra o arquivo app/views/layout/application.html.erb e adicione o yield para javascripts no final do body <script type="text/javascript"> <%=yield :js%> </script> Capítulo 13 - Ajax com Rails - Exercícios - Página 156
  • 168. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 2) Vamos adicionar os comentários nas views. a) Abra o arquivo app/helpers/application_helper.rb b) Insira as seguintes linhas: def comentarios(comentavel) comentarios = "<h3>Comentarios</h3>" comentarios << "<div id=’comentarios’>" if comentavel.comentarios.any? comentarios << render(:partial => "comentarios/comentario", :collection => comentavel.comentarios) end comentarios << "</div>" raw comentarios end Capítulo 13 - Ajax com Rails - Exercícios - Página 157
  • 169. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails c) Crie o arquivo app/views/comentarios/_comentario.html.erb com o seguinte conteúdo: <p id="comentario_<%= comentario.id %>"> <%= comentario.conteudo %> - <%= link_to ’(remover)’, comentario, :method => :delete, :remote => true, :id => "remove_comentario_#{comentario.id}" %> </p> <%=content_for :js do%> $(’#remove_comentario_<%=comentario.id%>’).bind( ’ajax:success’, function(xhr, result){ $(’#comentario_<%=comentario.id%>’).remove(); } ); <%end%> Capítulo 13 - Ajax com Rails - Exercícios - Página 158
  • 170. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails d) Altere as seguintes linhas da action destroy do controller comentarios_controller.rb def destroy @comentario = Comentario.find(params[:id]) @comentario.destroy respond_to do |format| format.xml { head :ok } format.js { head :ok } end end e) Adicione a seguinte linha em app/views/restaurantes/show.html.erb <%= comentarios @restaurante %> Capítulo 13 - Ajax com Rails - Exercícios - Página 159
  • 171. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails f) Adicione a seguinte linha em app/views/qualificacoes/show.html.erb <%= comentarios @qualificacao %> Capítulo 13 - Ajax com Rails - Exercícios - Página 160
  • 172. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails g) Teste em http://localhost:3000/restaurantes, escolhendo um restaurante no qual você já tenha inserido comentários. 13.6 - Adicionando comentários Para possibilitar a adição de comentários podemos adicionar um novo link logo após a lista de comentários, criando um novo helper method no ApplicationController: def novo_comentario(comentavel) comentarios = render(:partial => "comentarios/novo_comentario", :locals => { :comentavel => comentavel }) raw comentarios end É necessário agora criar o novo partial. Lembre que para criar um comentário, é preciso saber o que está sendo comentado (comentável). <!-- /app/views/comentarios/_novo_comentario.html.erb --> <div id=’novo_comentario’> <a href="javascript:$(’#novo_comentario’).children().toggle();">Novo comentario</a> <div id="form_comentario" style="display: none;"> <%= form_for Comentario.new, :remote => true do |f| %> <%= hidden_field :comentario, :comentavel_id, :value => comentavel.id %> <%= hidden_field :comentario, :comentavel_type, :value => comentavel.class %> <div class="field"> <%= f.label ’conteudo’ %><br /> <%= f.text_area ’conteudo’ %> Capítulo 13 - Ajax com Rails - Adicionando comentários - Página 161
  • 173. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails </div> <div class="actions"> <%= f.submit %> <a href="javascript:$(’#novo_comentario’).children().toggle();">Cancelar</a> </div> <% end %> </div> </div> <%content_for :js do%> $(’#form_comentario’).bind(’ajax:complete’, function(xhr, result){ $(’#comentarios’).html(result.responseText); $(’#form_comentario textarea’).val("") $(’#form_comentario’).hide(); $(’#novo_comentario > a’).show(); }); <%end%> 13.7 - Exercícios 1) Vamos permitir a adição de novos comentários: a) Abra o arquivo app/helpers/application_helper.rb b) Vamos criar um novo método nesse Helper. A função desse método será renderizar um partial contendo o link para criação de novos comentários. Para isso, adicione o método novo_comentario na sua classe ApplicationHelper: def novo_comentario(comentavel) raw render(:partial => "comentarios/novo_comentario", :locals => { :comentavel => comentavel }) end Capítulo 13 - Ajax com Rails - Exercícios - Página 162
  • 174. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails c) Crie o novo partial app/views/comentarios/_novo_comentario.html.erb com o seguinte conteúdo: <div id=’novo_comentario’> <a href="#" onclick="$(’#novo_comentario’).children().toggle();">Novo comentario</a> <div id="form_comentario" style="display: none;"> <%= form_for Comentario.new, :remote => true do |f| %> <%= hidden_field :comentario, :comentavel_id, :value => comentavel.id %> <%= hidden_field :comentario, :comentavel_type, :value => comentavel.class %> <div class="field"> <%= f.label ’conteudo’ %><br /> <%= f.text_area ’conteudo’ %> </div> <div class="actions"> <%= f.submit %> <a href="#" onclick="$(’#novo_comentario’).children().toggle();">Cancelar</a> </div> <% end %> </div> </div> <%content_for :js do%> $(’#form_comentario’).bind(’ajax:complete’, function(xhr, result){ $(’#comentarios’).html(result.responseText); $(’#form_comentario textarea’).val("") $(’#form_comentario’).hide(); $(’#novo_comentario > a’).show(); }); <%end%> Capítulo 13 - Ajax com Rails - Exercícios - Página 163
  • 175. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails d) O link deverá ser colocado após a verificação da existência de comentários para mostrar a lista dos comentários, para isso, abra o arquivo app/views/restaurantes/show.html.erb e abaixo do unless que faz a verificação adicione a chamada para o seu novo Helper : <% unless @restaurante.comentarios.empty?%> <%= comentarios @restaurante %> <% end %> <%= novo_comentario(@restaurante) %> e) Faça o mesmo para o arquivo app/views/qualificacoes/show.html.erb. f) Para finalizar o processo temos que alterar o nosso controller para exibir a lista de comentários do nosso comentável. Altere o método create no app/controllers/comentarios_controller.rb if @comentario.save format.xml { render :xml => @comentario, :status => :created, :location => @comentario } format.js {} else g) E agora crie o arquivo views/comentarios/create.js.erb <%= render(:partial => "comentarios/comentario", :collection => @comentario.comentavel.comentarios) %> h) Para que nosso partial exiba corretamente os javascripts precisamos criar um layout para colocar o bloco de yield dos javascripts. i) Crie o arquivo app/views/layouts/application.js.erb com o seguinte conteúdo <%= yield %> <script type="text/javascript"> Capítulo 13 - Ajax com Rails - Exercícios - Página 164
  • 176. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails <%=yield :js%> </script> j) Agora já é possível cadastrar um comentário direto do show dos comentáveis Capítulo 13 - Ajax com Rails - Exercícios - Página 165
  • 177. C APÍTULO 14 Alguns Plugins e Gems Importantes “A minoria pode ter razão, a maioria está sempre errada” – Mikhail Aleksandrovitch Bakunin 14.1 - Paginação O uso do plugin will_paginate sempre foi recomendado ao invés da forma clássica de paginação embutida no Rails 1.2. No Rails 2.0, a paginação foi removida para o plugin classic_pagination e agora você deve escolher qual usar. Hoje o will_paginate é um gem. Para poder usá-lo nas suas aplicações Rails, abra o arquivo Gemfile e adicione a seguinte linha: gem install will_paginate A documentação pode ser encontrada no wiki hospedado no github.com: http://github.com/mislav/will_paginate/wikis Após a instalação do gem, para usá-lo em uma aplicação Rails, basta inserir no final do arquivo Gemfile: gem "will_paginate" Para trazer os dados paginados, basta usar o método paginate, no lugar de find: @restaurantes = Restaurante.all.paginate :page => params[’page’] O método paginate funciona como um finder normal. Suporta todas as opções previamente vistas, como :conditions, :order e :include. O número de items por página é padronizado em 30, mas você pode customizar de duas formas. Através do método per_page nas classes ActiveRecord::Base: class Restaurante < ActiveRecord::Base def self.per_page 10 end # ... end Ou passando como parâmetro ao método paginate: @restaurantes = Restaurante.all.paginate :page => params[’page’], :per_page => 10 166
  • 178. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails O gem fornece ainda um helper para inclusão dos links de paginação em qualquer view: # index.html.erb <% @restaurantes.each do |restaurante| %> <li><%= restaurante.nome %></li> <% end %> <%= will_paginate @restaurantes %> Alguns exemplos de estilos (css) alternativos para a paginação podem ser encontrados em: http://mislav.caboo.se/static/will_paginate/ 14.2 - Exercícios - Título 1) Adicione o will_paginate ao seu projeto, no arquivo Gemfile gem ’will_paginate’ Execute o seguinte comando no terminal para instalar a gem bundle install 2) Abra o arquivo app/controllers/restaurantes_controller.rb. Na action list, troque a linha: @restaurantes = Restaurante.order("nome") por @restaurantes = Restaurante.order("nome").paginate :page=> params[’page’], :per_page=>3 3) Abra o arquivo app/views/restaurantes/index.html.erb. Adicione a linha abaixo após a tabela: <%= will_paginate @restaurantes %> 4) Abra a listagem de restaurantes e verifique a paginação. 14.3 - Hpricot HPricot é uma biblioteca poderosa para manipulação de xhtml. Bastante útil para capturar conteúdo da internet que não tenha sido criado pensando em integração e não oferece formatos mais adequados para serem consumidos por outros sistemas, como json ou xml. gem install hpricot open-uri é uma biblioteca que usaremos para fazer requisições http: doc = Hpricot(open(’http://twitter.com/guilhermecaelum’)) Analisando o html gerado pelo twitter, vemos que as mensagens estão sempre dentro de elementos com a classe "hentry Capítulo 14 - Alguns Plugins e Gems Importantes - Exercícios - Título - Página 167
  • 179. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails . Além disso, dentro de cada hentry, a única parte que nos interessa é o conteúdo dos subitems de classe "entry-content . Podemos procurar estes itens com o Hpricot, usando seletores CSS. Expressões XPath também poderiam ser usadas: doc / ".hentry .entry-content" Para imprimir cada um dos itens de uma maneira mais interessante: items = doc / ".hentry .entry-content" items.each do |item| puts item.inner_text end 14.4 - Exercícios - Testando o Hpricot 1) Vamos fazer um leitor de twitties de um determinado usuário a) Crie um arquivo chamado “twitter_reader.rb” b) Adicione ás seguintes linhas: require ’rubygems’ require ’hpricot’ require ’open-uri’ doc = Hpricot(open(’http://twitter.com/paulo_caelum’)) items = doc / ".hentry .entry-content" items.each do |item| puts item.inner_text end c) Teste usando o comando ruby twitter_reader.rb 14.5 - File Uploads: Paperclip Podemos fazer upload de arquivos sem a necessidade de plugins adicionais, utilizando algo como o código abaixo: File.open("public/"+path, "nome") { |f| f.write(params[:upload][’picture_path’].read) } O código acima recebe o binário do arquivo e faz o upload para a pasta public. Porém, ao fazer um upload seria interessante fazer coisas como redimensionar a imagem, gerar thumbs, associar com models ActiveRe- cord, etc. Um dos primeiros plugins rails voltados para isso foi o attachment_fu. Hoje em dia o plugin mais indicado é o Paperclip. O Paperclip tem como finalidade ser um plugin de fácil uso com o modelos Active Record. As configurações são simples e é possível validar tamanho do arquivo ou tornar sua presença obrigatória. O paperclip tem como pré-requisito o ImageMagick, Capítulo 14 - Alguns Plugins e Gems Importantes - Exercícios - Testando o Hpricot - Página 168
  • 180. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 14.6 - Exercícios 1) Para instalar o paperclip, abra o arquivo Gemfile e adicione a gem: gem ’paperclip’ E no terminal, rode : bundle install 2) Adicione o has_attached_file do paperclip na classe Restaurante. Vamos configurar mais uma opção que daremos o nome de styles. Toda vez que a view chamar a foto do restaurante com essa opção, o Rail buscará pelo thumb. class Restaurante < ActiveRecord::Base has_attached_file :foto, :styles => { :medium => "300x300>", :thumb => "100x100>" } end Economizando espaço em disco É boa prática ao configurar os tamanhos das imagens que armazenaremos, sobrescrever o tama- nho do estilo “original”, dessa maneira evitamos que o Paperclip salve imagens muito maiores do que utilizaremos em nossa aplicação. has_attached_file :foto, :styles => { :medium => "300x300>", :thumb => "100x100>", :original => "800x600>" } No exemplo acima, a imagem “original” será salva com tamanho máximo de 800x600 pixels, isso evita que armazenemos desnecessariamente em nossa aplicação, por exemplo, imagens de 4000x3000 pixels, tamanho resultante de uma foto tirada em uma máquina fotográfica digital de 12MP. 3) Precisamos de uma migration que defina novas colunas para a foto do restaurante na tabela de restaurantes. O paperclip define 4 colunas básicas para nome, conteúdo, tamanho do arquivo e data de update. Crie a migration AddFotoColumnsToRestaurante abaixo na pasta db/migrate: class AddAttachmentFotoToRestaurante < ActiveRecord::Migration def self.up add_column :restaurantes, :foto_file_name, :string add_column :restaurantes, :foto_content_type, :string add_column :restaurantes, :foto_file_size, :integer add_column :restaurantes, :foto_updated_at, :datetime end def self.down remove_column :restaurantes, :foto_file_name remove_column :restaurantes, :foto_content_type remove_column :restaurantes, :foto_file_size remove_column :restaurantes, :foto_updated_at end end Capítulo 14 - Alguns Plugins e Gems Importantes - Exercícios - Página 169
  • 181. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Geradores do Paperclip Você também pode usar o generator do próprio Paperclipe: rails generate paperclip Restaurante foto Rode a migration no terminal com: rake db:migrate 4) Abra a view app/views/restaurantes/new.html.erb e altere o formulário. Seu form deve ficar como o abaixo: <%= form_for :restaurantes, :url => {:action=>’create’}, :html => {:multipart=>true} do |f| %> <!--outros campos--> <%= f.file_field :foto %> <% end %> 5) Abra a view app/views/restaurantes/show.html.erb e adicione: <p> <b>Foto:</b> <%= image_tag @restaurante.foto.url(:thumb) %> </p> Repare que aqui chamamos o thumb, que foi configurado como um dos styles do model. Suba o server e insira um novo restaurante com foto. Capítulo 14 - Alguns Plugins e Gems Importantes - Exercícios - Página 170
  • 182. C APÍTULO 15 Testes “Ninguém testa a profundidade de um rio com os dois pés.” – Provérbio Africano 15.1 - O Porquê dos testes? Testes de Unidade são classes que o programador desenvolve para se certificar que partes do seu sistema estão funcionando corretamente. Eles podem testar validações, processamento, domínios etc, mas lembre-se que um teste unitário deve testar somente um pedaço de código (de onde veio o nome unitário). Criar esse tipo de testes é uma das partes mais importantes do desenvolvimento de uma aplicação pois possibilita a verificação real de todas as partes do programa automaticamente. Extreme Programming (XP) Extreme Programming é um conjunto de práticas de programação que visam a simplicidade, pratici- dade, qualidade e flexibilidade de seu sistema. Os testes de unidade fazem parte dessa metodogia de programação. O Ruby já possui classes que nos auxiliam no desenvolvimento destes testes. 15.2 - Test::Unit Test::Unit é a biblioteca usada para escrever suas classes de teste. Ao escrever testes em Ruby utilizando esse framework, você deve herdar a classe TestCase que provê a funcionalidade necessária para fazer os testes. require ’test/unit’ class PessoaTest < Test::Unit::TestCase # ... end Ao herdar TestUnit TestCase, você ganha alguns métodos que irão auxiliar os seus testes: • assert(boolean, msg=nil) • assert_equal(esperado, atual, msg=nil) • assert_not_equal(esperado, atual, msg=nil) 171
  • 183. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails • assert_in_delta(esperado, atual, delta, msg=nil) • assert_instance_of(classe, objeto, msg=nil) • assert_kind_of(classe, objeto, msg=nil) • assert_match(regex, texto, msg=nil) • assert_no_match(regex, texto, msg=nil) • assert_nil(objeto, msg=nil) • assert_not_nil(objeto, msg=nil) • assert_respond_to(objeto, metodo, msg=nil) • assert_same(esperado, atual, msg=nil) • assert_not_same(esperado, atual, msg=nil) O método assert simples recebe como parâmetro qualquer expressão que devolva um valor booleano e todos os métodos assert recebem opcionalmente como último argumento uma mensagem que será exibida caso a asserção falhe. Mais detalhes e outros métodos assert podem ser encontrados na documentação do módulo TestTestUnit Assertions, na documentação da biblioteca core da linguagem Ruby (http://ruby-doc.org/ core/). Os testes podem ser executados em linha de comando, bastando chamar ruby o_que_eu_quero_testar.rb. O resultado é um “.” para os testes que passarem, “E” para erros em tempo de execução e “F” para testes que falharem. Também é possível executar todos os testes com algumas tasks do rake: rake test # roda todos os testes de unidade, de integração e funcionais rake test:units # roda todos os testes da pasta test/unit rake test:functionals # roda todos os testes da pasta test/functional rake test:integration # roda todos os testes da pasta test/integration rake test:plugins # roda todos os testes de plugins, na pasta vendor/plugins Existem ainda outras tarefas disponíveis para o rake. Sempre podemos consultá-las com rake -T, no dire- tório do projeto. Podemos criar uma classe de teste que só possua um único “assert true”, no diretório test/unit/. class MeuTeste < Test::Unit::TestCase def test_truth assert true end end Ao escrever testes de unidade em projetos Ruby On Rails, ao invés de herdar diretamente de TestUnit TestCase, temos a opção de herdar da classe fornecida pelo ActiveSupport do Rails: Capítulo 15 - Testes - Test::Unit - Página 172
  • 184. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails require ’test_helper’ class RestauranteTest < ActiveSupport::TestCase def test_anything assert true end end Além disso, todos os testes em projetos Rails devem carregar o arquivo test_helper.rb, disponível em qualquer projeto gerado pelo Rails. As coisas comuns a todos os testes, como método utilitários e configurações, ficam neste arquivo. A vantagem de herdar de ActiveSupport::TestCase ao invés da original é que o Rails provê diversas funci- onalidades extras aos testes, como fixtures e métodos assert extras. Alguns dos asserts extras: • assert_difference • assert_no_difference • assert_valid(record) - disponível em testes de unidade • assert_redirected_to(path) - para testes de controladores • assert_template(esperado) - também para controladores • entre outros 15.3 - Exercícios - Teste do modelo 1) Vamos testar nosso modelo restaurante. Para isso precisamos utilizar o banco de dados específico para testes. rake db:create:all rake db:migrate RAILS_ENV=test 2) O Rails já tem suporte inicial para testes automatizados. Nossa aplicação já possui arquivos importantes para nossos testes. Abra o arquivo test/fixtures/restaurantes.yml. Esse arquivo simula os dados de um restaurante. Crie os dois restaurantes abaixo. Importante: Cuidado com a identação! fazano: nome: Fazano endereco: Rua Vergueiro fogo_de_chao: nome: Fogo de Chao endereco: Avenida dos Bandeirantes 3) O arquivo de teste do modelo está em test/unit/restaurante_test.rb. Obs: Verifique se o require na primeira linha está correto. require ’test/test_helper’ Capítulo 15 - Testes - Exercícios - Teste do modelo - Página 173
  • 185. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails class RestauranteTest < ActiveSupport::TestCase fixtures :restaurantes def test_restaurante restaurante_fazano = Restaurante.new :nome => restaurantes(:fazano).nome, :endereco => restaurantes(:fazano).endereco assert restaurante_fazano.save restaurante_fazano_copia = Restaurante.find(restaurante_fazano.id) assert_equal restaurante_fazano.nome, restaurante_fazano_copia.nome restaurante_fazano.nome = "Fazano" assert restaurante_fazano.save assert restaurante_fazano.destroy end end 4) Para rodar o teste, vá na raiz do projeto pelo terminal e digite: ruby test/unit/restaurante_test.rb Verifique se tudo está certo: Loaded suite test/unit/restaurante_test Started . Finished in 0.044991 seconds. 1 tests, 4 assertions, 0 failures, 0 errors 15.4 - Exercícios - Teste do controller 1) Para testar o controller de restaurantes vamos criar uma nova action chamada busca. Essa action direciona para o restaurante buscado caso encontre ou devolve uma mensagem de erro caso contrário. Abra o arquivo app/controllers/restaurantes_controller.rb e adicione a action busca: def busca @restaurante = Restaurante.find_by_nome(params[:nome]) if @restaurante redirect_to :action => ’show’, :id => @restaurante.id else flash[:notice] = ’Restaurante não encontrado.’ redirect_to :action => ’list’ end end 2) Abra o arquivo test/functional/restaurantes_controller_test.rb. Capítulo 15 - Testes - Exercícios - Teste do controller - Página 174
  • 186. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails require ’test/test_helper’ class RestaurantesControllerTest < ActionController::TestCase fixtures :restaurantes def setup @controller = RestaurantesController.new @request = ActionController::TestRequest.new @response = ActionController::TestResponse.new end def test_procura_restaurante get :busca, :nome => ’Fazano’ assert_not_nil assigns(:restaurante) assert_equal restaurantes(:fazano).nome, assigns(:restaurante).nome assert_redirected_to :action => ’show’ end def test_procura_restaurante_nao_encontra get :busca, :nome => ’Botequin’ assert_redirected_to :action => ’list’ assert_equal ’Restaurante não encontrado.’, flash[:notice] end end Verifique se tudo está certo; Loaded suite test/functional/restaurantes_controller_test Started .. Finished in 0.206066 seconds. 2 tests, 4 assertions, 0 failures, 0 errors 3) Rode o teste no terminal com ruby test/functional/restaurantes_controller_test.rb. 15.5 - RSpec Muito mais do que uma nova forma de criar testes de unidade, RSpec fornece uma forma de criar especifi- cações executáveis do seu código. No TDD, descrevemos a funcionalidade esperada para nosso código através de testes de unidade. BDD (Behavior Driven Development) leva isso ao extremo e diz que nossos testes de unidade devem se tornar especificações executáveis do código. Ao escrever as especificações estaremos pensando no comportamento esperado para nosso código. Introdução ao BDD Uma ótima descrição sobre o termo pode ser encontrada no site do seu próprio criador: Dan North. http://dannorth.net/introducing-bdd/ Capítulo 15 - Testes - RSpec - Página 175
  • 187. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails RSpec fornece uma DSL (Domain Specific Language) para criação de especificações executáveis de código. As especificações do RSpec funcionam como exemplos de uso do código, que validam se o código está mesmo fazendo o que deveria e funcionam como documentação. http://rspec.info Para instalar o rspec e usar em qualquer programa Ruby, basta instalar o gem: gem install rspec Para usar em aplicações Rails, precisamos instalar mais um gem que dá suporte ao rspec ao Rails. Além disso, precisamos usar o gerador que vem junto desta gem, para adicionar os arquivos necessários nos projetos que forem usar rspec: cd projeto-rails rails generate rspec:install O último comando também adiciona algumas tasks do rake para executar as specs do projeto, além de criar a estrutura de pastas e adicionar os arquivos necessários. rake spec # executa todas as specs do projeto rake -T spec # para ver as tasks relacionadas ao rspec O rspec-rails também pode ser instalado como plugin, porém hoje é altamente recomendado seu uso como gem. Mais detalhes podem ser encontrados na documentação oficial http://wiki.github.com/rspec/rspec-rails/ RSpec é compatível com testes feitos para rodar com Test::Unit. Desta forma, é possível migrar de forma gradativa. Apesar disso, a sintaxe oferecida pelo RSpec se mostra bem mais interessante, já que segue as idéias do Behavior Driven Development e faz com que os testes se tornem especificações executáveis do código: describe Restaurante, " com nome" do it "should have name" Restaurante.all.should_not be_empty Restaurante.first.should_not be_nil Restaurante.first.name.should == "Fasano" end end A classe de teste vira um Example Group (describe). Cada método de teste vira um Example (it “should ... ). Além disso, os métodos assert tradicionais do Test::Unit viram uma chamada de should. O RSpec adici- ona a todos os objetos os métodos should e should_not, que servem para validarmos alguma condição sobre o estado dos nossos objetos de uma forma mais legível e expressiva que com asserts. Como argumento para o método should, devemos passar uma instância de Matcher que verifica uma con- dição particular. O RSpec é extremamente poderoso, pois nos permite escrever nossos próprios Matchers. Apesar disso, já vem com muitos prontos, que costumam ser mais do que suficientes: Capítulo 15 - Testes - RSpec - Página 176
  • 188. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails • be_<nome> para métodos na forma <nome>?. objeto.should be_empty # testa: objeto.empty? objeto.should_not be_nil # testa: not objeto.nil? objeto.should be_kind_of(Restaurante) # testa: objeto.kind_of(Restaurante) Além de be_<nome>, tambem podemos usar be_a_<nome> ou be_an_<nome>, aumentando a legibili- dade. • be_true, be_false, eql, equal, exist, include: objeto.should be_true objeto.should_not be_false objeto.should eql(outro) # testa: objeto.eql?(outro) objeto.should equal(outro) # testa: objeto.equal?(outro) objeto.should exist # testa: objeto.exist? [4,5,3].should include(3) # testa: [4,5,3].include?(3) • have_<nome> para métodos na forma has_<nome>?. itens = { :um => 1, :dois => ’2’ } itens.should have_key(:dois) # testa: itens.has_key?(:dois) itens.should_not have_value(/3/) # testa: not itens.has_value?(/3/) • be_close, inclui tolerância. conta = 10.0 / 3.0 conta.should be_close(3.3, 0.1) # == 3.3 `.1 • have(num).<colecao>, para testar a quantidade de itens em uma associação. categoria.should have(15).produtos # testa categoria.produtos.size == 15 Um uso especial deste matcher é para objetos que já são coleções. Neste caso, podemos usar o nome que quisermos: array = [1,2,3] array.should have(3).items # testa array.size == 3 array.should have(3).numbers # mesma coisa • have_at_least(num).<colecao>: mesma coisa que o anterior, porém usa >=. • have_at_most(num).<colecao>: mesma coisa que o anterior, porém usa <=. • match, para expressões regulares. texto.should match(/^F/) # verifica se começa com F Este são os principais, mas ainda existem outros. Você pode encontrar a lista de Matchers completa na documentação do módulo Spec::Matchers: Capítulo 15 - Testes - RSpec - Página 177
  • 189. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Exemplos pendentes Um exemplo pode estar vazio. Desta forma, o RSpec o indicará como pendente: describe Restaurante do it "should have endereco" end Isto facilita muito o ciclo do BDD, onde escrevemos o teste primeiro, antes do código de verdade. Podemos ir pensando nas funcionalidades que o sistema deve ter e deixá-las pendentes, antes mesmo de escrever o código. Em outras palavras, começamos especificando o que será escrito. Before e After Podemos definir algum comportamento comum para ser executado antes ou depois de cada um dos exem- plos, como o setup e o teardown do Test::Unit: describe Restaurante do before do @a_ser_testado = Restaurante.new end it "should ..." after do fecha_e_apaga_tudo end end Estes métodos podem ainda receber um argumento dizendo se devem ser executados novamente para cada exemplo (:each) ou uma vez só para o grupo todo (:all): describe Restaurante do before(:all) do @a_ser_testado = Restaurante.new end it "should ..." after(:each) do fecha_e_apaga_tudo end end 15.6 - Cucumber, o novo Story Runner RSpec funciona muito bem para especificações em níveis próximos ao código, como as especificações unitárias. User Stories é uma ferramenta indicada para especificações em níveis mais altos, como funcionalidades de negócio, ou requisitos. Seu uso está sendo bastante difundido pela comunidade Rails. User Stories costumam Capítulo 15 - Testes - Cucumber, o novo Story Runner - Página 178
  • 190. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails ter o seguinte formato: In order to <benefício> As a <interessado> I want to <funcionalidade>. Cucumber é uma excelente biblioteca escrita em Ruby, que serve para tornar especificações como esta, na forma de User Stories, escritas em texto puro, executáveis. Cucumber permite a associação de código Ruby arbitrário, usualmente código de teste com RSpec, a cada um dos passos desta descrição da funcionalidade. Para instalar tudo o que é necessário: gem install cucumber capybara database_cleaner gem ’database_cleaner’ gem ’cucumber-rails’ gem ’cucumber’ gem ’rspec-rails’ gem ’spork’ gem ’launchy’ Para projetos rails, é possível usar o generator fornecido pelo Cucumber para adicionar os arquivos neces- sários ao projeto: cd projetorails rails generate cucumber:install As User Stories são chamadas de Features pelo Cucumber. São arquivos de texto puro com a extensão .feature. Arquivos com definição de features sempre contém uma descrição da funcionalidade (Story) e alguns exemplos (Scenarios), na seguinte estrutura: Feature: <nome da story> In order to <beneficio> As a <interessado> I want to <funcionalidade> Scenario: <nome do exemplo> Given <pré condições> And <mais pré condições> When <ação> And <mais ação> Then <resultado> And <mais resultado> Scenario: <outro exemplo> Given ... When ... Capítulo 15 - Testes - Cucumber, o novo Story Runner - Página 179
  • 191. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Then ... Antigamente, o RSpec incluia sua própria implementação de Story Runner, que hoje está sendo substituída pelo Cucumber. O RSpec Story Runner original utilizava um outro formato para features, mais tradicional, que não dá prioridade ao Return Of Investment. O benefício da funcionalidade fica em segundo plano, no final da descrição: Story: transfer from savings to checking account As a savings account holder I want to transfer money from my savings account to my checking account So that I can get cash easily from an ATM Scenario: ... O importante para o Cucumber são os exemplos (Scenarios) que explicam a funcionalidade. Cada um dos Scenarios contém um conjunto de passos, que podem ser do tipo Given (pré-requisitos), When (ações), ou Then (resultado). A implementação de cada um dos passos (steps) dos scenarios devem ficar dentro do diretório step_definitions/, na mesma pasta onde se encontram os arquivos .feature, texto puro. O nome destes arquivos que contém a definição de cada um dos passos deve terminar com _steps.rb. Cada passo é representado na chamada dos métodos Given, Then ou When, que recebem como argumento uma String ou expressão regular batendo com o que estiver escrito no arquivo de texto puro (.feature). Tipicamente, os projetos contém um diretório features/, com a seguinte estrutura: projeto/ |-- features/ | |-- minha.feature | |-- step_definitions/ | | |-- alguns_steps.rb | | ‘-- outros_steps.rb | ‘-- support/ | ‘-- env.rb O arquivo support/env.rb é especial do Cucumber e sempre é carregado antes da execução dos testes. Geralmente contém a configuração necessária para os testes serem executados e código de suporte aos testes, como preparação do Selenium ou Webrat. Os arquivos com definições dos passos são arquivos Ruby: Given "alguma condicao descrita no arquivo texto puro" do # codigo a ser executado para este passo end Given /e outra condicao com valor: (.*)/ do |valor| # codigo de teste para esse passo end Capítulo 15 - Testes - Cucumber, o novo Story Runner - Página 180
  • 192. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails When /alguma acao/ # ... end Then /verifica resultado/ # ... end O código de teste para cada passo pode ser qualquer código Ruby. É comum o uso do RSpec para verificar condições (métodos should) e Webrat ou Selenium para controlar testes de aceitação. Mais detalhes sobre estes frameworks para testes de aceitação podem ser vistos no capítulo “Outros testes e specs”. Não é necessário haver um arquivo com definição de passos para cada arquivo de feature texto puro. Isto é até considerado má prática por muitos, já que inibe o reuso para definições de steps. Capítulo 15 - Testes - Cucumber, o novo Story Runner - Página 181
  • 193. C APÍTULO 16 Apêndice B - Integrando Java e Ruby “Não há poder. Há um abuso do poder nada mais” – Montherlant, Henri Nesse capítulo você aprenderá a acessar código escrito anteriormente em Java através de scripts escritos em Ruby: o projeto JRuby. 16.1 - O Projeto JRuby (http://www.jruby.org/) é uma implementação de um interpretador Ruby escrito totalmente em java, e mais ainda, com total integração com a Virtual Machine. Além de ser open-source, ele disponibiliza a integração entre as bibliotecas das duas linguagens. Atualmente há algumas limitações como, por exemplo, não é possível herdar de uma classe abstrata. O suporte a Ruby on Rails também não está completo. Os líderes desse projeto open source já trabalharam na Sun, o que permitiu termos uma implementação muito rápida e de boa qualidade. 16.2 - Testando o JRuby Vamos criar um script que imprima um simples “Testando o JRuby” na tela do seu console: print "Testando o JRuby!n" Pode parecer muito simples, mas a grande diferença é que agora quem estará realmente rodando é uma Virtual Machine Java! Não há mais a necessidade de instalar o ruby na máquina, apenas a JVM e algumas bibliotecas do JRuby! Isto pode ajudar muito na adoção da linguagem. Agora se executarmos tanto com os comandos “ruby” ou “jruby” o resultado será o mesmo: 16.3 - Exercícios 1) Crie um arquivo chamado testando.rb que imprime na tela “Testando o JRuby!": a) Edite o arquivo: testando.rb. b) Adicione o seguinte conteúdo: print "Testando o JRuby!n" 182
  • 194. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails c) Rode o arquivo com o JRuby: jruby testando.rb 16.4 - Compilando ruby para .class com Jruby Existe a possibilidade de compilarmos o arquivo .rb para um .class através do JRuby. Para isso devemos utilizar o jrubyc(JRuby Compiler) de modo muito semelhante ao javac: jrubyc <path do arquivo .rb> Vamos criar um arquivo ola_mundo_jruby.rb: # ola_mundo_jruby.rb puts ’Ola Mundo com JRuby!’ Agora vamos compilar esse arquivo: jrubyc ola_mundo_jruby.rb Após isso, o arquivo ola_mundo_jruby.class já foi criado na mesma pasta do arquivo ola_mundo_jruby.rb e nós podemos utiliza-lo apartir de outro arquivo .rb através do require, porém esse .class é diferente do que o javac cria apartir do .java, sendo assim é impossível roda-lo direto na JVM como rodamos outra classe qualquer do java. 16.5 - Rodando o .class do ruby na JVM Como foi dito anteriormente, não é possível executar diretamente na JVM um arquivo compilado pelo jruby, isso acontece pelas características dinâmicas do ruby que tornam necessário a utilização de um jar. Tal jar pode ser baixada no site do Jruby(http://jruby.org/download). Com o .jar em mãos, é fácil executar um bytecode do jruby na JVM, simplesmente devemos utilizar a opção “-jar” da seguinte maneira: java -jar <path do arquivo .jar> <path do arquivo .class> Lembrando que é necessário que a extensão do arquivo(.class) esteja explícita. Vamos copiar o arquivo .jar do jruby para a pasta onde o ola_mundo_jruby.class está e rodar o nosso olá mundo: java -jar jruby.jar ola_mundo_jruby.class Após isso veremos nosso “Ola Mundo com JRuby!”. Capítulo 16 - Apêndice B - Integrando Java e Ruby - Compilando ruby para .class com Jruby - Página 183
  • 195. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 16.6 - Importando um bytecode(.class) criado pelo jruby Para importar um bytecode que foi criado a partir de um arquivo .rb utilizamos o conhecido require. require ’<path do bytecode>’ Obs.: Lembre-se de retirar a extensão do arquivo (.class), o certo seria fazer algo como: require ’app/funcionario’ e não: # desta maneira o arquivo não será encontrado require ’app/funcionario.class’ 16.7 - Importando classes do Java para sua aplicação JRuby Para importar classes Java utilizamos o método java_import, porém devemos ter o cuidado de antes requerer a biblioteca que tem esse método. Vamos criar uma classe Pessoa em Java, e importar ela para dentro do JRuby. Primeiramente criaremos a classe Pessoa no java: // Pessoa.java public class Pessoa { private String nome; public Pessoa(String meuNome) { this.nome = meuNome; } public void setNome(String novoNome) { this.nome = novoNome; } public String getNome(){ return this.nome; } public void seMostra(){ System.out.println(this.getNome()); } } Agora iremos compilar o código fonte com o javac utilizando: javac Pessoa.java Teremos então o arquivo Pessoa.class. Vamos criar um arquivo testando_jruby.rb onde iremos testar essa classe: # testando_jruby.rb require ’java’ # o java_import faz parte desta biblioteca Capítulo 16 - Apêndice B - Integrando Java e Ruby - Importando um bytecode(.class) criado pelo jruby - Página 184
  • 196. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails java_import ’Pessoa’ pessoa = Pessoa.new ’Hugo Roque’ pessoa.se_mostra # Observe que o nome do método no código Java é # seMostra, porém o JRuby faz um alias para # todos os métodos passando-os de Camelcase para # Underscore case. # Obs.: o método seMostra ainda existe. pessoa.nome = ’Nico Steppat’ # Observe que ao criarmos um setter # para o nome(setNome), o JRuby criou # o método nome= automaticamente. # Obs.: Os métodos setNome e set_nome # continuam existindo. puts pessoa.nome # Observe que ao criarmos um getter # para o nome(getNome), o JRuby criou # o método nome automaticamente # Obs.: Os métodos getNome e get_nome # continuam existindo. Ao executarmos o exemplo acima, teremos como saida: Hugo Roque Nico Steppat Lembrando que para executar este exemplo basta utilizar jruby testando_jruby.rb 16.8 - Testando o JRuby com Swing Agora vamos integrar nossso “Testando o JRuby” com um pouco de Java, criando uma janela. Instanciamos um objeto Java em JRuby usando a notação: require ’java’ module Swing include_package ’java.awt’ include_package ’javax.swing’ end module AwtEvent include_package ’java.awt.event’ end # Reparem que não é necessário herdar nem # implementar nada, apenas definir o metodo Capítulo 16 - Apêndice B - Integrando Java e Ruby - Testando o JRuby com Swing - Página 185
  • 197. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails # com o nome que o java exige (duck typing) class ListenerDoBotao def action_performed(evento) Swing::JOptionPane.showMessageDialog(nil, "ActionListener feito em ruby") end end frame = Swing::JFrame.new painel = Swing::JPanel.new frame.add painel label = Swing::JLabel.new label.text = "Testando o JRuby!" # label.setText("Testando o JRuby!") painel.add label botao = Swing::JButton.new ’clique aqui’ botao.add_action_listener ListenerDoBotao.new painel.add botao frame.pack frame.set_size(400, 400) frame.visible = true O include_package é parecido com um import, e depois estamos criando uma instância de JFrame. Dessa mesma maneira você pode acessar qualquer outra classe da biblioteca do Java. Assim você tem toda a expres- sividade e poder do Ruby, somado a quantidade enorme de bibliotecas do Java. Para saber mais: Suporte a closure com JRuby O JRuby permite a passagem de blocos de código como argumento para metodos do java que re- cebem como parâmetro uma interface que define apenas um método, assim como o futuro suporte a closures prometido para o Java 8. No exemplo acima poderíamos ter passado o ActionListener para o botão sem necessidade de escrever uma classe só para isso, e nem mesmo seria preciso instanciar um objeto, fazendo desta forma: botao.add_action_listener do |evento| Swing::JOptionPane.showMessageDialog(nil, "ActionListener em closure") end Capítulo 16 - Apêndice B - Integrando Java e Ruby - Testando o JRuby com Swing - Página 186
  • 198. C APÍTULO 17 Apêndice C - Deployment “Há noites que eu não posso dormir de remorso por tudo o que eu deixei de cometer.” – Mario Quintana Como construir ambientes de produção e deployment para aplicações Rails sempre foram alguns dos maio- res desafios desta plataforma. Existem diversos detalhes a serem considerados e diversas opções disponíveis. 17.1 - Webrick A forma mais simples de executar aplicações rails é usar o servidor que vem embutido em todas estas aplicações: Webrick. É um servidor web muito simples, escrito em Ruby, que pode ser iniciado através do arquivo script/server, dentro do projeto: cd projetorails rails server Por padrão, o Webrick inicia na porta 3000, porém isto pode ser mudado com a opção -p: rails server -p 3002 Por ser muito simples, não é recomendado o uso do webrick em produção. 17.2 - CGI Uma das primeiras alternativas de deployment para aplicações Rails foi o uso de servidores web famo- sos, como o Apache Httpd. Porém, como o httpd só serve conteúdo estático, precisar delegar as requisições dinâmicas para processos Ruby que rodam o Rails, através do protocolo CGI. Durante muito tempo, esta foi inclusive uma das formas mais comuns de servir conteúdo dinâmico na inter- net, com linguagens como Perl, PHP, C, entre outras. O grande problema no uso do CGI, é que o servidor Web inicia um novo processo Ruby a cada requisição que chega. Processos são recursos caros para o sistema operacional e iniciar um novo processo a cada requisição acaba limitando bastante o tempo de resposta das requisições. 187
  • 199. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 17.3 - FCGI - FastCGI Para resolver o principal problema do CGI, surgiu o FastCGI. A grande diferença é que os processos que tratam requisições dinâmicas (workers) são iniciados junto ao processo principal do servidor Web. Desta forma, não é mais necessário iniciar um novo processo a cada requisição, pois já foram iniciados. Os processos ficam disponíveis para todas as requisições, e cada nova requisição que chega usa um dos processos existentes. Pool de processos O conjunto de processos disponíveis para tratar requisições dinâmicas também é popularmente conhecido como pool do processos. A implementação de FCGI para aplicações Rails, com o apache Httpd nunca foi satisfatória. Diversos bugs traziam muita instabilidade para as aplicações que optavam esta alternativa. Infelizmente, FCGI nunca chegou a ser uma opção viável para aplicações Rails. 17.4 - Lighttpd e Litespeed Implementações parecidas com Fast CGI para outros servidores Web pareceram ser a solução para o problema de colocar aplicações Rails em produção. Duas alternativas ficaram famosas. Uma delas é a implementação de Fast CGI e/ou SCGI do servidor web Lighttpd. É um servidor web escrito em C, bastante performático e muito leve. Muitos reportaram problemas de instabilidade ao usar o Lighttpd em aplicações com grandes cargas de requisições. Litespeed é uma outra boa alternativa, usado por aplicações Rails em produção até hoje. Usa o proto- colo proprietário conhecido como LSAPI. Por ser um produto pago, não foi amplamente difundido dentro da comunidade de desenvolvedores Rails. http://www.litespeedtech.com/ruby-lsapi-module.html 17.5 - Mongrel Paralelamente às alternativas que usam FCGI (e variações) através de servidores Web existentes, surgiu uma alternativa feita em Ruby para rodar aplicações Rails. Mongrel é um servidor web escrito por Zed Shaw, em Ruby. É bastante performático e foi feito especifica- mente para servir aplicações Rails. Por esses motivos, ele rapidamente se tornou a principal alternativa para deployment destas aplicações. Hoje suporta outros tipos de aplicações web em Ruby. 17.6 - Proxies Reversos O problema com o Mongrel é que uma instância do Rails não pode servir mais de uma requisição ao mesmo tempo. Em outras palavras, o Rails não é thread-safe. Possui um lock que não permite a execução de seu código apenas por uma thread de cada vez. Por causa disso, para cada requisição simultânea que precisamos tratar, é necessário um novo processo Mongrel. O problema é que cada Mongrel roda em uma porta diferente. Não podemos fazer os usuários terem de se preocupar em qual porta deverá ser feita a requisição. Capítulo 17 - Apêndice C - Deployment - FCGI - FastCGI - Página 188
  • 200. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Por isto, é comum adicionar um balanceador de carga na frente de todos os Mongrels. É o balanceador que recebe as requisições, geralmente na porta 80, e despacha para as instâncias de Mongrel. Como todas as requisições passam pelo balanceador, ele pode manipular o conteúdo delas, por exemplo adicionando informações de cache nos cabeçalhos HTTP. Neste caso, quando faz mais do que apenas distribuir as requisições, o balanceador passa a ser conhecido como Proxy Reverso. Reverso? Proxy é o nó de rede por onde passam todas as conexões que saem. O nome Proxy Reverso vem da idéia de que todas as conexões que entram passam por ele. O principal ponto negativo no uso de vários Mongrels é o processo de deployment. A cada nova versão, precisariamos instalar a aplicação em cada um dos Mongrels e reinicar todos eles. Para facilitar o controle (start, stop, restart) de vários Mongrels simultâneamente, existe o projeto mon- grel_cluster. 17.7 - Phusion Passenger (mod_rails) Ninh Bui, Hongli Lai e Tinco Andringa da empresa Phusion decidiram tentar novamente criar um módulo para rodar aplicações Rails usando o Apache Httpd. Phusion Passenger, também conhecido como mod_rails, é um módulo para o Apache Httpd que adiciona suporte a aplicações Web escritas em Ruby. Uma de suas grandes vantagens é usar o protocolo Rack para enviar as requisições a processos Ruby. Como o Rack foi criado especificamente para projetos Web em Ruby, praticamente todos os frameworks web Ruby suportam este protocolo, incluindo o Ruby on Rails, o Merb e o Sinatra. Só por serem baseados no protocolo Rack, são suportados pelo Passenger. A outra grande vantagem do mod_rails é a facilidade de deployment. Uma vez que o módulo esteja instalado no Apache Httpd, bastam três linhas de configuração no arquivo httpd.conf: <VirtualHost *:80> ServerName www.aplicacao.com.br DocumentRoot /webapps/aplicacoes/projetorails </VirtualHost> A partir daí, fazer deployment da aplicação Rails consiste apenas em copiar o código para a pasta configu- rada no Apache Httpd. O mod_rails detecta que é uma aplicação Rails automaticamente e cuida do resto. A documentação do Passenger é uma ótima referência: http://www.modrails.com/documentation/Users%20guide.html 17.8 - Ruby Enterprise Edition Além do trabalho no mod_rails, os desenvolvedores da Phusion fizeram algumas modificações importantes no interpretador MRI. As mudanças podem trazer redução de até 30% no uso de memória em aplicações Rails. Capítulo 17 - Apêndice C - Deployment - Phusion Passenger (mod_rails) - Página 189
  • 201. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails O patch principalmente visa modificar um pouco o comportamento do Garbage Collector, fazendo com que ele não modifique o espaço de memória que guarda o código do Rails. Desta forma, os sistemas operacionais modernos conseguem usar o mesmo código Rails carregado na memória para todos os processos. Esta técnica é conhecida como Copy on Write; suportada pela maioria dos sistemas operacionais modernos. Outra mudança importante promovida pelos desenvolvedores da Phusion foi o uso de uma nova biblioteca para alocação de memória, tcmalloc, no lugar da original do sistema operacional. Esta biblioteca é uma criação do Google. 17.9 - Exercícios: Deploy com Apache e Passenger 1) Abra o FileBrowser e copie o projeto restaurantes para o Desktop. o projeto está em /rr910/Aptana Studio Workspace/restaurantes 2) Abra o terminal e digite: install-httpd Feche e abra o terminal novamente Esse comando baixa httpd e compila na pasta /home/apache. No nosso caso=> /home/rr910/apache 3) Ainda no terminal entre no diretório do projeto e rode a migration para atualizar o banco em produção: cd Desktop/restaurante rake db:migrate:reset RAILS_ENV=production 4) Abra o arquivo de configuração do Apache: gedit /home/rr910/apache/conf/httpd.conf Altere a linha abaixo: Listen 8080 Adicione a linha a baixo em qualquer lugar do arquivo: Servername http://localhost:8080 5) Suba o Apache, no terminal rode: apachectl start Acesse http://localhost:8080/ no broser e confira se o Apache subiu, deve aparecer a menssagem It works!. Capítulo 17 - Apêndice C - Deployment - Exercícios: Deploy com Apache e Passenger - Página 190
  • 202. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails 6) vamos instalar o Passenger. no terminal rode: gem install passenger passenger-install-apache2-module Quando o instalador surgir no terminal, pressione enter. No fim, copie a instrução semelhante a essa: LoadModule passenger_module /home/rr910/.gem/ruby/1.8/gems/passenger-2.2.5/ext/apache2/ mod_passenger.so PassengerRoot /home/rr910/.gem/ruby/1.8/gems/passenger-2.2.5 PassengerRuby /usr/bin/ruby1.8 7) Abra o arquivo de configuração do Apache: gedit /home/rr910/apache/conf/httpd.conf Adicione essas linhas ao final do arquivo: <VirtualHost *:8080> DocumentRoot /home/rr910/Desktop/restaurante/public </VirtualHost> <Directory /> Options FollowSymLinks AllowOverride None Order allow,deny Allow from all </Directory> 8) No terminal, de o restart no apache: apachectl restart Acesse http://localhost:8080/restaurantes. Nossa aplicação está rodando no Apache com Passenger! Capítulo 17 - Apêndice C - Deployment - Exercícios: Deploy com Apache e Passenger - Página 191
  • 203. C APÍTULO 18 Apêndice D - Instalação “A dúvida é o principio da sabedoria” – Aristóteles 18.1 - Ruby - Ubuntu Para instalar o Rails no Ubuntu deve-se executar os seguintes passos: • Build essencial para instalação de gems com extensão nativa: sudo apt-get install build-essential • Instalar ruby sudo apt-get install ruby1.8 ruby1.8-dev • Precisamos também instalar o rubygems. Existe um pacote deb no apt-get, mas que é melhor não usar pois ele está sempre desatualizado. Então vamos fazer o download e instalação manuais. Faça o download da última versão: http://rubyforge.org/frs/?group_id=126 (1.1.1) Basta descompactar e executar no diretório: sudo ruby setup.rb Depois de instalar, não se esqueça de atualizar o rubygems: sudo gem update --system Feito isso, você já estará com o Ruby e rubygems mais atuais. O Ubuntu cria os executáveis com o sufixo 1.8. Para tudo funcionar como esperado, é necessário ainda criar alguns links: sudo ln -s /usr/bin/gem1.8 /usr/bin/gem sudo ln -s /usr/bin/ruby1.8 /usr/bin/ruby sudo ln -s /usr/bin/rdoc1.8 /usr/bin/rdoc 192
  • 204. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails sudo ln -s /usr/bin/ri1.8 /usr/bin/ri sudo ln -s /usr/bin/irb1.8 /usr/bin/irb 18.2 - Ruby - Windows Para instalar no Windows, basta fazer o download da última versão do ruby em: http://rubyforge.org/frs/?group_id=167. Basta descompactar e dar duplo clique para instalar. Após isso, é necessário atualizar a rubygem. Digite no prompt de comando: gem update --system 18.3 - Rails Para instalar Rails, basta executar o seguinte comando: No Ubuntu: sudo gem install rails No Windows, abra um prompt de comando e digite: gem install rails 18.4 - JDK Para utilização do editor Aptana, é necessária a instalação da JDK. No Ubuntu: sudo apt-get install sun-java6-jdk No Windows: Fazer o download em http://java.sun.com/javase/downloads/index.jsp 18.5 - Aptana O Aptana Studio pode ser adquirido em: http://www.aptana.com/studio/download Após fazer o download do Aptana, basta descompactá-lo e clicar em “Aptana”. Feito isso, é necessário instalar o plugin para manipulação de projetos Rails. Para isso, faça: Capítulo 18 - Apêndice D - Instalação - Ruby - Windows - Página 193
  • 205. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Menu Help -> Software Updates -> Find and Install -> Search for new features to install Selecione Aptana: RadRails Development Environment -> next O Aptana irá fazer download o plugin Rails automáticamente 18.6 - Mongrel Para instalar o mongrel, basta executar o seguinte comando: No Ubuntu: sudo gem install mongrel No Windows, abra um prompt de comando e digite: gem install mongrel 18.7 - MySQL No Ubuntu: sudo apt-get install mysql-server-5.0 No Windows: Basta fazer o download em http://dev.mysql.com/downloads/mysql/5.0.html Após isso, bastá descompactar e dar duplo clique para instalar. 18.8 - SVN No Ubuntu: sudo apt-get install subversion No Windows: Basta fazer o download em: http://subversion.tigris.org/servlets/ProjectDocumentList?folderID=91 Após isso, basta dar duplo clique para instalar. Capítulo 18 - Apêndice D - Instalação - Mongrel - Página 194
  • 206. Índice Remissivo ActiveRecord, 71 mongrelc luster, 189 afterf ilter, 117 MRI, 4 aroundf ilter, 117 MSpec, 6 MVC, 55 BDD, 175 beforef ilter, 117 Observer, 49 Behavior Driven Development, 175 open-uri, 167 Boolean, 12 Operadores Aritméticos, 11 Builder, 116 Operadores Booleanos, 12 OR, 14 Classes abertas, 19 ORM, 71 CoC, 55 comments, 9 Palavras Reservadas, 11 Comparable, 34 Phusion, 7 Copy on Write, 189 Phusion Passenger, 7 puts, 9 DRY, 55 Duck Typing, 45 rack, 119 RadRails, 56 Enumerable, 34 Rake, 72 ERb, 104 Ranges, 11 Regexp, 13 for, 13 respondt o, 124 gems, 5 RSpec, 175 Gemstone, 7 Rubinius, 6 Ruby, 4 HAML, 116 Ruby Enterprise Edition, 7 hpricot, 167 Ruby.NET, 6 RubyGems, 5 I/O, 37 RubySpec, 6 if / elsif / case / when, 12 IronRuby, 6 scaffold, 62 Search Engine Optimization, 121 JRuby, 6 SEO, 121 String, 9 Maglev, 7 Symbol, 11 MetaProgramming, 52 Syntax Sugar, 22 Migrations, 73 modr ails, 7 tcmalloc, 190 195
  • 207. Material do Treinamento Desenvolvimento Ágil para Web 2.0 com Ruby on Rails Template Method, 46 Testes, 171 The Great Ruby Shootout, 7 willp aginate, 166 Índice Remissivo - Índice Remissivo - Página 196