Home Explore Help
Register Sign In
jamesperet
/
rails-notes
Watch 1
Star 0
Fork 0

Browse Source
initial commit

V 10 years ago
commit
dc635a7619
39 changed files with 2089 additions and 0 deletions
Show Diff Stats
  1. 32 0
      ActiveRecord_ActiveRelation.md
  2. 103 0
      CRUD.md
  3. 88 0
      CarrierWave.md
  4. 34 0
      Criando um banco de dados mySQL.md
  5. 16 0
      Gerando um Controller e um View.md
  6. 33 0
      Instance Variables.md
  7. 9 0
      Links.md
  8. 25 0
      Parametros na URL.md
  9. 43 0
      Render e redirecionamento.md
  10. 88 0
      SimpleForm.md
  11. 26 0
      View Templates.md
  12. 185 0
      associacoes.md
  13. 45 0
      associacoes_polimorficas.md
  14. 75 0
      capybara.md
  15. 8 0
      criando um projeto.md
  16. 42 0
      css_selectors.md
  17. 34 0
      cucumber.md
  18. 126 0
      devise.md
  19. 50 0
      error_pages.md
  20. 19 0
      gerando_modelos.md
  21. 83 0
      git.md
  22. 25 0
      helpers.md
  23. 43 0
      heroku.md
  24. 32 0
      i18n.md
  25. 37 0
      instalacao.md
  26. 48 0
      jQuery_file_upload.md
  27. 18 0
      links_referencias.md
  28. 103 0
      migration.md
  29. 28 0
      nested_model.md
  30. 11 0
      rails_console.md
  31. 15 0
      rake.md
  32. 39 0
      readme.md
  33. 115 0
      records.md
  34. 30 0
      routes.md
  35. 36 0
      scaffolding.md
  36. 33 0
      scopes.md
  37. 49 0
      testes.md
  38. 38 0
      time_ago.md
  39. 225 0
      twitter_bootstrap.md

+ 32 - 0
ActiveRecord_ActiveRelation.md
View File 

@@ -0,0 +1,32 @@
1 
+# ActiveRecord
2 
+
3 
+Baseado no padrão de design *"active record"*, um sistema em rails tem objetos inteligentes, com funções para inserir, atualizar e deletar entradas no banco de dados.
4 
+
5 
+## Exemplo
6 
+	user = User.new
7 
+	user.first_name = 'James'
8 
+	user.save # SQL INSERT
9 
+
10 
+	user.last_name = 'Peret'
11 
+	user.sabe #SQL UPDATE
12 
+
13 
+	user.delete #SQL DELETE
14 
+
15 
+# ActiveRelation
16 
+
17 
+Função introduzida no Rails v3.0, serve para simplificar a procura de querys complexos no banco de dados. Também serve para que o sistema apenas faça a busca no banco de dados no momento certo.
18 
+
19 
+## Exemplo
20 
+	users = User.where(:first_name => "James")
21 
+	users = users.order("last_name ASC").limit(5)
22 
+	users = users. include(:articles_authored)
23 
+
24 
+O Codigo acima utilizando ActiveRelations iria criar um query em SQL parecido com o seguinte:
25 
+
26 
+	SELECT users.*, articles*
27 
+	FROM users
28 
+	LEFT JOIN articles ON (users.id = articles.author_id)
29 
+	WHERE users.first_name = 'James'
30 
+	ORDER BY last_name ASC LIMIT 5
31 
+
32 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 103 - 0
CRUD.md
View File 

@@ -0,0 +1,103 @@
1 
+# CRUD
2 
+
3 
+Acrônimo para **Create**, **Read**, **Update**, **delete**. O CRUD se refere a um conjunto de funções que que manipulam um objeto dentro do sistema. Em um aplicativo Rails, o ideal é que cada **modelo** deve ter um **controlador** com suas funções de **CRUD**.
4 
+
5 
+<br>
6 
+
7 
+<table class="table table-bordered">
8 
+	<thead>
9 
+	  <tr>
10 
+	    <th style="text-align: center" class="span2">CRUD</th>
11 
+	    <th style="text-align: center">Ação</th>
12 
+	    <th style="text-align: center">Descrição</th>
13 
+	  </tr>
14 
+	</thead>
15 
+	<tbody>
16 
+	  <tr>
17 
+	    <td rowspan="2"><br>CREATE</td>
18 
+	    <td style="text-align: center">new</td>
19 
+	    <td style="text-align: left; font-size: 14px;">Formulario para criar nova entrada.</td>
20 
+	  </tr>
21 
+	  <tr>
22 
+	    <td style="text-align: center">create</td>
23 
+	    <td style="text-align: left; font-size: 14px;">Processar a nova entrada.</td>
24 
+	  </tr>
25 
+	  <tr>
26 
+	    <td rowspan="2"><br>READ</td>
27 
+	    <td style="text-align: center">list</td>
28 
+	    <td style="text-align: left; font-size: 14px;">Listar as entradas.</td>
29 
+	  </tr>
30 
+	  <tr>
31 
+	    <td style="text-align: center">show</td>
32 
+	    <td style="text-align: left; font-size: 14px;">Mostrar uma entrada unica.</td>
33 
+	  </tr>
34 
+	  <tr>
35 
+	    <td rowspan="2"><br>UPDATE</td>
36 
+	    <td style="text-align: center">edit</td>
37 
+	    <td style="text-align: left; font-size: 14px;">Formulario para editar uma entrada.</td>
38 
+	  </tr>
39 
+	  <tr>
40 
+	    <td style="text-align: center">update</td>
41 
+	    <td style="text-align: left; font-size: 14px;">Processar a edição de uma entrada.</td>
42 
+	  </tr>
43 
+	  <tr>
44 
+	    <td rowspan="2"><br>DELETE</td>
45 
+	    <td style="text-align: center">delete</td>
46 
+	    <td style="text-align: left; font-size: 14px;">Formulario para deletar uma entrada.</td>
47 
+	  </tr>
48 
+	  <tr>
49 
+	    <td style="text-align: center">destroy</td>
50 
+	    <td style="text-align: left; font-size: 14px;">Processar a ação de deletar uma entrada.</td>
51 
+	  </tr>
52 
+	</tbody>
53 
+</table>
54 
+
55 
+O **CRUD** normalmente vai dentro de um **Controlador** que tem um nome em plural e está linkado a apenas um **modelo**.
56 
+
57 
+Ele também ajuda a criar URLs limpas e simples:
58 
+
59 
+- paginas/nova
60 
+- fotos/deletar
61 
+- usuario/editar
62 
+
63 
+## Read
64 
+
65 
+### List
66 
+
67 
+Para criar uma função basica para listar todos os objetos de um modelo, primeiro precisamos criar um metodo no **controlador**. Atravez das convenções do Rails, o nome desse metodo vai ser igual ao nome do template do **View**. Precisamos carregar também uma **instance variable** no controlador com a lista de objetos. Essa variavel vai estar disponivel no View.
68 
+
69 
+#### Exemplo
70 
+
71 
+1- Levando em consideração que o modelo **Paginas** foi criado e tem o paramentro **titulo**, alem de entradas no banco de dados.
72 
+
73 
+2- Gere um controlador: ```$ rails generate controller paginas```
74 
+
75 
+3- No novo arquivo do controlador ```app/controllers/paginas_controller.rb```:
76 
+
77 
+	class PaginasController < ApplicationController
78 
+		def lista
79 
+			 @paginas = Pagina.order("paginas.titulo ASC")
80 
+		edn
81 
+	end
82 
+
83 
+4- Crie o arquivo ```app/views/paginas/lista.html.erb```
84 
+
85 
+	<h1>Lista de páginas:</h1>
86 
+	<ul>
87 
+		<% @paginas.each do |pagina| %>
88 
+			<li>
89 
+				<%= link_to(pagina.titulo {:action =>'mostrar', :id => pagina.id}, :class => 'link') %>
90 
+			</li>
91 
+		<% end %>
92 
+	</ul>
93 
+
94 
+5- (re-)inicie o servidor com o comando ```$ rails server``` e entre na página ```http://localhost:3000/paginas/lista``` para ver a lista de páginas no sistema.
95 
+
96 
+### Show
97 
+
98 
+Para criar a ação basica de mostrar um objeto, é necessario ter o *id** ou algum outro parametro para achar a entrada que está sendo procurada.
99 
+
100 
+#### Exemplo
101 
+
102 
+
103 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 88 - 0
CarrierWave.md
View File 

@@ -0,0 +1,88 @@
1 
+# Upload de arquivos com o CarrierWave
2 
+
3 
+Adicione no ```Gemfile```:
4 
+
5 
+	gem "carrierwave"
6 
+
7 
+Execute o comando ```$ bundle install``` para instalar o **gem** e depois gere um novo objeto:
8 
+
9 
+```$ rails g uploader image```
10 
+
11 
+Depois crie uma migração para associar as imagens a outra classe:
12 
+
13 
+```$ rails g migration add_image_to_posts image:string```
14 
+
15 
+Execute o  comando ```$ rake db:migrate``` para criar o campo na tabela no banco de dados. Depois entre no arquivo ```models/post.rb``` e adicione o uploder:
16 
+
17 
+	class post < ActiveRecord::Base
18 
+	  attr_accessible :name, :content, :image
19 
+	  mount_uploader :image, ImageUploader
20 
+	end
21 
+
22 
+Depois modifique o formulario que vai conter o campo de upload:
23 
+
24 
+	<%= form_for @post, html => {:multipart => true} do |f| %>
25 
+
26 
+		<%= f.file_field :image %>
27 
+		<%= f.submit %>
28 
+
29 
+	<% end %>
30 
+
31 
+Para utilizar a imagem no **view**:
32 
+
33 
+	<%= image_tag @post.image.to_s %>
34 
+
35 
+#### Modificar a pasta onde os arquivos são salvos
36 
+
37 
+No **uploader** que foi gerado, modifique o arquivo ```app/uploaders/image_uploader.rb``` e defina onde os arquivos vão ser salvos:
38 
+
39 
+	class ImageUploader < CarrierWave::Uploader::Base
40 
+	  storage :file
41 
+
42 
+	  def store_dir
43 
+	    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
44 
+	  end
45 
+
46 
+	end
47 
+
48 
+#### Upload de arquivo via URL
49 
+
50 
+Para carregar um arquivo externo vindo de uma URL, modifique o formulario de upload:
51 
+
52 
+	<%= form_for @painting, :html => {:multipart => true} do |f| %>
53 
+		<%= f.file_field :image %>
54 
+	    <%= f.text_field :remote_image_url %>
55 
+	  	<%= f.submit %>
56 
+	<% end %>
57 
+
58 
+No modelo onde que carrega as imagens ```models/post.rb```, adicione o ```attr_accessible :remote_image_url```. É importante usar essa variavel por que o **CarrierWave** vai automaticamente procurar o arquivo pela URL e fazer o upload e processamento.
59 
+
60 
+#### Processamento de imagens com o rmagik
61 
+
62 
+Para fazer modificações na imagem como criar versões *thumbnail*, é possivel utilizar o **rmagick** junto com o **ImageMagick**.
63 
+
64 
+Primeiro é necessario instalar o **ImageMagick**.
65 
+
66 
+Adicione no ```Gemfile``` o **rmagick** e execute o ```$ bundle install```:
67 
+
68 
+	gem "rmagick"
69 
+
70 
+No arquivo ```app/uploaders/image_uploader.rb```, inclua o ```CarrierWave::RMagik```, defina a pasta onde as imagens serão guardadas e defina o processamento da nova versão da imagem:
71 
+
72 
+	class ImageUploader < CarrierWave::Uploader::Base
73 
+
74 
+	  include CarrierWave::RMagick
75 
+
76 
+	  version :thumb do
77 
+	    process :resize_to_limit => [200, 200]
78 
+	  end
79 
+
80 
+	end
81 
+
82 
+Para fazer o display da imagem **thumb**:
83 
+
84 
+	<%= image_tag @post.image.thumb if painting.image? %>
85 
+
86 
+------
87 
+
88 
+<a href="readme.md" class=""btn btn-mini>voltar</a>

+ 34 - 0
Criando um banco de dados mySQL.md
View File 

@@ -0,0 +1,34 @@
1 
+# Criando um banco de dados mySQL
2 
+
3 
+Para criar um banco de dados para o projeto, no terminal digite o seguinte comando:
4 
+
5 
+```$ mysql -u root -p```
6 
+
7 
+O terminal vai pedir a senha do sistema e entrar no banco de dados. A seguir confira se um banco de dados já existe para o projeto *"demo_project"*:
8 
+
9 
+```SHOW DATABASES;```
10 
+
11 
+Para criar o banco de dados:
12 
+
13 
+```CREATE DATABASE demo_project_development;```
14 
+
15 
+Depois é preciso dar acesso para um novo usuario ao banco de dados, para não comprometer a segurança do sistema utilizando a senha **"root"**.
16 
+
17 
+```CREATE USER 'db_user'@'localhost' IDENTIFIED BY 'pass1234'; ```
18 
+
19 
+
20 
+```GRANT ALL PRIVILAGES ON demo_project_development.* TO 'user'@'localhost' IDENTIFIED BY 'password1234';```
21 
+
22 
+Para publicação do site, mude o servidor de **localhost** para o dominio onde o sistema vai funcionar na internet.
23 
+
24 
+Depois sai do bando de dados:
25 
+
26 
+```exit```
27 
+
28 
+Depois disso entre no arquivo ```config/database.yml``` e configure o novo usuário e senha para o banco de dados do sistema.
29 
+
30 
+Para entrar de novo no banco de dados, utilize o comando:
31 
+
32 
+```$ mysql -u user -p demo_project_development```
33 
+
34 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 16 - 0
Gerando um Controller e um View.md
View File 

@@ -0,0 +1,16 @@
1 
+# Gerando um "Controller" e um "View"
2 
+
3 
+Um aplicativo Rails utiliza a arquitetura **MVC** (Model-View-Controller).  O **"controller"** serve para indentificar o que está sendo requisitado, carrega os modelos com informações e disponibiliza tudo isso para o **"view"**.
4 
+
5 
+Para gerar um **"controller"** e um **"View"**, digite o comando no terminal:
6 
+
7 
+```$ rails generate controller demo index```
8 
+
9 
+O rails vai gerar os arquivos e hierarquia de pastas:
10 
+
11 
+- ```app/controllers/demo_controller.rb```
12 
+- ```app/views/demo/index.html.erb```
13 
+
14 
+Alem disso ele vai gerar alguns outros arquivos (testes e helpers) e uma rota no  ```config/routes.rb``` para o novo **"View"** que foi criado: ```get "demo/index"```.
15 
+
16 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 33 - 0
Instance Variables.md
View File 

@@ -0,0 +1,33 @@
1 
+# Instance Variables
2 
+
3 
+De acordo com a arquitetura **MVC**, o **controlador** agrega as informações do **modelo** e repassa para o **View** renderiza-las no browser.
4 
+
5 
+Para isso, o **controlador** declara as **"instance variables"** que são repassadas para o **View**.
6 
+
7 
+### Variaveis em Ruby:
8 
+
9 
+	normal_variable
10 
+	@intance_variable
11 
+
12 
+### Exemplo
13 
+
14 
+No arquivo ```app/controllers/demo_controller.rb```:
15 
+
16 
+	def instance_variable_test
17 
+		@array = [1,2,3,4]
18 
+	end
19 
+
20 
+Depois no arquivo ```app/views/demo/instance_variable_test.html.erb```:
21 
+
22 
+	<% @array.each do |n| %>
23 
+	  <%= n %> <br/>
24 
+	<% end %>
25 
+
26 
+HTML renderizado pelo browser:
27 
+
28 
+	1<br/>
29 
+	2<br/>
30 
+	3<br/>
31 
+	4<br/>
32 
+
33 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 9 - 0
Links.md
View File 

@@ -0,0 +1,9 @@
1 
+# Links
2 
+
3 
+Em um **View**, para criar um **link** utilize a função ```link_to```.
4 
+
5 
+## Exemplo
6 
+
7 
+	<%= link_to("click here", {:action => 'index'}) %>
8 
+
9 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 25 - 0
Parametros na URL.md
View File 

@@ -0,0 +1,25 @@
1 
+# Parametros na URL
2 
+
3 
+Para utilizar os parametros GET e POST que vem em uma URL, utilizamos o **hash** ```params```.
4 
+
5 
+## Exemplos
6 
+
7 
+```/demo/hello/1?page=3&name=james```
8 
+
9 
+Uma URL com estes parametros seria convertida no **hash**:
10 
+
11 
+	{ :action => 'hello', :id => 1, :page => 3, :name => 'james', :controller => 'demo' }
12 
+
13 
+Esses valores podem ser acessados no **controlador**, **modelo** ou no **view** atravez do **hash** ```params``` e do nome da variavel:
14 
+
15 
+	params[:id]
16 
+	params['name']
17 
+	params[:page].to_i
18 
+
19 
+## Detalhes
20 
+
21 
+- Todos os ```params``` são strings.
22 
+- ```params``` são *"HashWithIndifferentAccess"* ou seja ```params[:id]``` é igual a ```params['id]```.
23 
+- ```params.inspect``` mostra um array com todos os paramentros.
24 
+
25 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 43 - 0
Render e redirecionamento.md
View File 

@@ -0,0 +1,43 @@
1 
+# Render e redirecionamento
2 
+O **Controlador** tem o papel de definir qual ação vai ser tomada e no final ele deve renderizar um **"View"** ou redirecionar para uma **URL** ou outro **controlador**.
3 
+
4 
+### Exemplo
5 
+
6 
+	Class DemoController < ApplicationController
7 
+
8 
+		def index
9 
+			render('hello')
10 
+		end
11 
+
12 
+		def hello
13 
+			render(:text => 'Hello World!')
14 
+		end
15 
+
16 
+		def other_hello
17 
+			redirect_to(:action => 'hello')`
18 
+		end
19 
+
20 
+		def my_url
21 
+			redirect_to("http://jamesperet.com")
22 
+		end
23 
+
24 
+	end
25 
+
26 
+Neste exemplo, ao entrar na página ```demo/index```, o browser irá carregar a página ```demo/hello```, mas a URL no browser continua sendo a do "index".
27 
+
28 
+Ao entrar na página ```demo/hello``` diretamente, o rails retorna apenas o texto "Hello World".
29 
+
30 
+Ao entrar na página ```demo/other_hello``` o browser é redirecionado para o controllador "hello", que vai apenas renderizar texto e a URL no browser será a da página "hello".
31 
+
32 
+### Sintaxe das funções para render e redirecionamento
33 
+
34 
+* Default: a página de template (view) tem o mesmo nome que a ação que está sendo chamada.
35 
+* ```render (:action => 'hello')``` - função depreciada.
36 
+* ```render (:template => 'demo/hello')```  - função depreciada.
37 
+* ```render ('demo/hello')```  - Só é necessario especificar o controlador se ele for diferente do atual.
38 
+* ```render ('hello')``` - Metodo correto para renderizar o template de um View.
39 
+* ```render (:text => 'Hello World')``` - renderiza apenas texto.
40 
+* ```redirect_to(:action => 'other_hello')``` - redireciona o browser para outro controlador.
41 
+* ```redirect_to("http://jamesperet.com")``` - Redireciona o browser para uma URL externa.
42 
+
43 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 88 - 0
SimpleForm.md
View File 

@@ -0,0 +1,88 @@
1 
+# SimpleForm
2 
+
3 
+O **SimpleForm** é um **gem** que simplifica drasticamente a criação de formularios.
4 
+
5 
+Para utiliza-lo, adicione no o SimpleForm no ```Gemfile```
6 
+
7 
+<pre class="prettyprint languague-ruby">
8 
+gem 'simple_form'
9 
+</pre>
10 
+
11 
+Depois execute o comando para instalar o **gem**:
12 
+
13 
+```$ bundle install```
14 
+
15 
+Para iniciar o SimpleForm no projeto, execute o comando:
16 
+
17 
+```$ rails g simple_form:install```
18 
+
19 
+Esse comando ira criar alguns arquivos no projeto e instalar o SimpleForm. Também é possivel passar a variavel ```--bootstrap``` para inicializar o SimpleForm preparado para o Twitter Bootstrap.
20 
+
21 
+Para utilizar o Simple Form, em vez de usar a função ```form_for```, vamos usar a função ```simple_form_for```.
22 
+
23 
+#### Exemplo de formulário com o SimpleForm
24 
+<pre class="prettyprint languague-erb">
25 
+<%= simple_form_for(@product) do |f| %>
26 
+  <%= f.error_notification %>
27 
+  <%= f.input :name %>
28 
+  <%= f.input :price, hint: "price should be in USD" %>
29 
+  <%= f.input :released_on, label: "Release Date" %>
30 
+  <%= f.input :discontinued %>
31 
+  <%= f.input :rating, collection: 1..5, as: :radio_buttons %>
32 
+  <%= f.association :publisher %>
33 
+  <%= f.association :categories, as: :check_boxes %>
34 
+  <%= f.error :base %>
35 
+  <%= f.button :submit %>
36 
+<% end %>
37 
+</pre>
38 
+#### Funções
39 
+
40 
+- **input**<br>
41 
+Input padrão que vai ser definido pelo tipo de variavel definida no modelo.
42 
+<br>Exemplo:```f.input :name```
43 
+
44 
+- **association**<br>
45 
+Utilizado para associações. Automaticamente coloca as associações possiveis na lista do formulario.
46 
+Exemplo: ```f.association :categories```
47 
+
48 
+- **button**<br>
49 
+Utilizado para enviar o formulario.
50 
+<br>Exemplo: ```f.button :submit```
51 
+
52 
+- **error_notification**<br>
53 
+Retorna as *mensagens flash* de erro e sucesso.
54 
+<br>Exemplo: ```f.error_notification```
55 
+
56 
+- **error**<br>
57 
+Retorna o erro de validação de um campo especifico.
58 
+<br>Exemplo: ```f.error :username, :id => 'user_name_error'```
59 
+
60 
+#### Variaveis
61 
+
62 
+- ```:hint => 'preço em reais'```
63 
+- ```:label => 'Nome completo'```
64 
+- ```:placeholder => 'exemple@email.com'```
65 
+- ```:collection => 1..5```
66 
+- ```:as => radio_buttons```
67 
+
68 
+#### Custom Wrappers
69 
+
70 
+O **simple_form** envolve os campos do formulario em *divs*. Para criar seus proprios *wrappers*, adicione a seguinte função no arquivo ```config/initializers/simple_form.rb```:
71 
+
72 
+	config.wrappers :basic, :tag => :span do |b|
73 
+	    b.use :placeholder
74 
+	    b.use :label_input
75 
+	    #component.use :hint,  :wrap_with => { :tag => :span, :class => :hint }
76 
+	    #component.use :error, :wrap_with => { :tag => :span, :class => :error }
77 
+	  end
78 
+
79 
+Depois para utilizar esse *wrapper*:
80 
+
81 
+	f.input :email, wrapper: "basic", label: false
82 
+
83 
+#### Links
84 
+
85 
+- [SimpleForm (GitHub)](https://github.com/plataformatec/simple_form)
86 
+- [RailsCasts - SimpleForm Revised](http://railscasts.com/episodes/234-simple-form-revised)
87 
+
88 
+<hr><a class="btn btn-mini" href="readme.md">voltar</a>

+ 26 - 0
View Templates.md
View File 

@@ -0,0 +1,26 @@
1 
+# ERB View Templates
2 
+
3 
+Páginas de template para mostrar conteúdo. Elas utilizam o **ERB** ou *"Embed Ruby Code"* para processar conteudo dinâmico escrito em **Ruby** para **HTML**.
4 
+
5 
+### Exemplo de nome de arquivo
6 
+
7 
+```views/demo/index.html.erb```
8 
+
9 
+### Codigo de embed
10 
+
11 
+	<% code %>
12 
+	<%= code %>
13 
+
14 
+A primeira versão apenas processa o codigo ruby dentro dos tags. A segunda versão com o sinal de igual processa e retorna o **"output"** do codigo em Ruby.
15 
+
16 
+### Exemplo de arquivo ERB
17 
+
18 
+	<h1>Demo#hello</h1>
19 
+	<p>Hello World</p>
20 
+
21 
+	<%= 1 + 1 %>
22 
+
23 
+	<% target = "world" %>
24 
+	<%= "Hello #{target}" %>
25 
+
26 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 185 - 0
associacoes.md
View File 

@@ -0,0 +1,185 @@
1 
+# Associações
2 
+Para interligar tabelas atravez dos **"forein_keys"**, criamos associações enre os modelos.
3 
+
4 
+Existem 3 tipos de associações: 1 para 1, 1 para varios e varios para varios.
5 
+
6 
+## 1 para 1
7 
+
8 
+Tipo de associação de um objeto para outro. Util para quebrar uma tabela grande em varias partes. Sempre defina os dois lados da associação!
9 
+
10 
+#### Exemplo
11 
+
12 
+- subject-page
13 
+	- Page has_one :subject
14 
+	- Subject has_one :page
15 
+
16 
+No modelo **Subject**:
17 
+
18 
+	class Subject < ActiveRecord::Base
19 
+		has_one :page
20 
+	end
21 
+
22 
+
23 
+No modelo **Page**:
24 
+
25 
+	class Page < ActiveRecord::Base
26 
+		has_one :subject, {:foreign_key => "subject_id"}
27 
+	end
28 
+
29 
+Para utilizar as associações, carregue um objeto e chame o metodo associado para ter o objeto retornado:
30 
+
31 
+```subject.page``` ou ```page.subject```
32 
+
33 
+## 1 para varios
34 
+
35 
+As associações de um objeto para varios são muito usadas dentro dos aplicativos em rails. Elas utilizm o termo no plural e retornam um array de objetos.
36 
+
37 
+A classe com o ```belongs_to``` que deve ter o **foreign key**
38 
+
39 
+#### Exemplo
40 
+
41 
+- user-photos
42 
+	- User has_many :photos
43 
+	- Photo belongs_to :user
44 
+
45 
+No modelo **User**:
46 
+
47 
+	class User < ActiveRecord::Base
48 
+		has_many :photos
49 
+	end
50 
+
51 
+No modelo **Photo**:
52 
+
53 
+	class Photo < ActiveRecord::Base
54 
+		belongs_to :user
55 
+	end
56 
+
57 
+#### Metodos
58 
+
59 
+- ```user.photos```
60 
+- ```user.photos << photo```
61 
+- ```user.photos = [photo, photo, photo]```
62 
+- ```user.photos.delete(photo)```
63 
+- ```user.photos.clear```
64 
+- ```user.photos.empty?```
65 
+- ```user.photos.size```
66 
+- ```user.photos[1]```
67 
+
68 
+## varios para varios
69 
+
70 
+Este tipo de associação é utilizada quando um objeto está associado a varios outros objetos, mas não exclusivamente.
71 
+
72 
+Para este tipo de associação, primeiro é necessario criar uma **join table**, ou seja, uma tabela simples que não tem um **primary key** e tem apenas duas colunas com os **ids** dos dois objetos das duas tableas sendo relacionados.
73 
+
74 
+#### Join Table
75 
+
76 
+A nova tabela que vai guardar as inforamções da associação tem algumas regras de nomeação especificas:
77 
+
78 
+- Primeira_tabela + _ + segunda_tabela
79 
+- Os dois nomes são no plural
80 
+- Os nomes entram em ordem alfabetica
81 
+- Nome *default* que pode ser configurado
82 
+
83 
+#### Exemplo
84 
+
85 
+- posts-tags
86 
+	- Post has_and_belongs_to_many :tags
87 
+	- Tags has_and_belongs_to_many :posts
88 
+
89 
+O nome da tabela vai ser: "posts_tags".
90 
+
91 
+1 - Criar o arquivo de migração:
92 
+
93 
+```rails generate migration CreatePostsTagsJoin```
94 
+
95 
+2 - Editar o arquivo de migração:
96 
+
97 
+	class CreatePostsTagsJoin < ActiveRecord::Migration
98 
+		def self.up
99 
+		  create_table :posts_tags, :id => false do |t|
100 
+			t.integer "post_id"
101 
+			t.integer "tag_id"
102 
+		  end
103 
+		  add_index :posts_tags, ["post_id", "tag_id"]
104 
+		end
105 
+		def self.down
106 
+		  drop_table :posts_tags
107 
+		end
108 
+	end
109 
+
110 
+3 - Rodar a migração:
111 
+
112 
+```rake:db:migrate```
113 
+
114 
+4 - No arquivo do modelo Post:
115 
+
116 
+	class Post < ActiveRecord::Base
117 
+		has_and_belongs_to_many :tags
118 
+	end
119 
+
120 
+5 - No arquivo do modelo Tag:
121 
+
122 
+	class Tag < ActiveRecord::Base
123 
+		has_and_belongs_to_many :blog_posts, :class_name => "Post"
124 
+	end
125 
+
126 
+## Associações Avançadas
127 
+
128 
+Outra maneira de fazer associações de varios objeos para varios outros é criando um modelo proprio para administrar essas associaçãos e outras informações.
129 
+
130 
+A diferença é que a tabela precisa de um **primary key** e não precisa seguir nenhuma conveção para o nome.
131 
+
132 
+#### Exemplo
133 
+
134 
+Neste exemplo vamos criar um log de edição das páginas do sistema.
135 
+
136 
+- User has_many :page_edits
137 
+- PageEdit belongs_to :user
138 
+- Page has_many :page_edits
139 
+- PageEdit belongs_to :page
140 
+
141 
+1 - Criar um modelo:
142 
+
143 
+```rails generate model PageEdit```
144 
+
145 
+2 - Editar o arquivo de migração:
146 
+
147 
+	class CreatePageEdits < ActiveRecord::Migration
148 
+		def self.up
149 
+		  create_table :posts_tags do |t|
150 
+			t.references :page
151 
+			t.references :user
152 
+			t.string "new_content"
153 
+			t.timestamps
154 
+		  end
155 
+		  add_index :page_edits, ["page_id", "user_id"]
156 
+		end
157 
+		def self.down
158 
+		  drop_table :posts_tags
159 
+		end
160 
+	end
161 
+
162 
+3 - Rodar a migração:
163 
+
164 
+```rake:db:migrate```
165 
+
166 
+4 - No arquivo do modelo Page:
167 
+
168 
+	class Page < ActiveRecord::Base
169 
+		has_many :page_edits
170 
+	end
171 
+
172 
+5 - No arquivo do modelo User:
173 
+
174 
+	class User < ActiveRecord::Base
175 
+		has_many :page_edits
176 
+	end
177 
+
178 
+6 - No arquivo do modelo PageEdit:
179 
+
180 
+	class User < ActiveRecord::Base
181 
+		belongs_to :page
182 
+		belongs_to :editor, :class_name => "User", :foreign_key => "user_id"
183 
+	end
184 
+
185 
+#### Traversing

+ 45 - 0
associacoes_polimorficas.md
View File 

@@ -0,0 +1,45 @@
1 
+# Associações Polimorficas
2 
+
3 
+Associações polimorficas servem para criar um modelo que pertence a varios outros modelos. Por exemplo, uma classe de comentarios que está associada a varios modelos como posts, fotos e eventos.
4 
+
5 
+```$ rails g model comment content:text commentable_id:integer commentable_type```
6 
+
7 
+Esse primeiro comando gera o modelo para os comentarios. As ultimas duas variaveis servem para guardar o id e o tipo de objeto que o comentario pertence.
8 
+
9 
+Para melhorar a performance do sistema de comentarios, adicione o ```commentable_id``` e o ```commentable_type``` no index da tabela no arquivo de migração ```db/migrations/xxxxxxxxxxxxxx_create_comments.rb```:
10 
+
11 
+	classCreateComments < ActiveRecord::Migration
12 
+	  defchange
13 
+	    create_table :commentsdo |t|
14 
+	      t.text :content
15 
+	      t.belongs_to :commentable, polymorphic: true
16 
+
17 
+	      t.timestamps
18 
+	    end
19 
+	    add_index :comments, [:commentable_id, :commentable_type]
20 
+	  end
21 
+	end
22 
+
23 
+No exemplo acima, as duas variaveis ```commentable_id``` e o ```commentable_type``` foram substituidas por ```t.belongs_to :commentable, polymorphic: true```. Esse é outro metodo de declarar as associações polimorficas.
24 
+
25 
+Rode o comando ```$ rake db:migrate``` para criar a nova tabela no banco de dados.
26 
+
27 
+Entre no modelo dos comentarios ```app/models/comment.rb``` e adicione a associação e retire os atributos que não são necessarios:
28 
+
29 
+	classComment < ActiveRecord::Base
30 
+	  attr_accessible :content
31 
+	  belongs_to :commentable, polymorphic:true
32 
+	end
33 
+
34 
+Depois, adicione o outro lado da associação para cada modelo que vai ter comentarios:
35 
+
36 
+	classPost < ActiveRecord::Base
37 
+	  attr_accessible :title, :content
38 
+	  has_many :comments, as: :commentable
39 
+	end
40 
+
41 
+Com isso agora é possivel criar e acessar comentarios igual a qualquer outra associação.
42 
+
43 
+Para criar o CRUD do sistema de comentarios, primeiro crie um controlador:
44 
+```$ rails g controller comments index new```
45 
+

+ 75 - 0
capybara.md
View File 

@@ -0,0 +1,75 @@
1 
+# Capybara
2 
+
3 
+#### Navegação
4 
+
5 
+* ```visisit(path)``` - Navega até o *path* utilizando o **GET**.
6 
+
7 
+#### Links e botões
8 
+
9 
+* ```click_link(locator)``` - Acha um link por *ID* ou texto e clica nele. Isso faz com que o **Capybara** carregue uma nova página.
10 
+* ```click_button(locator)``` - Acha um botão com *ID*, texto ou *value* e clica-lo. Isso causa o **Capybara** a enviar o formulário.
11 
+* ```click_on(locator)``` - Acha um botão ou link por *ID*, texto ou *value* e clica nele.
12 
+
13 
+#### Interagindo com formulários
14 
+
15 
+* ```fill_in(locator, {:with => text})``` - Localiza um campo ou area de texto e insere o texto dado. O campo pode ser localizado pelo seu nome, ID ou label.
16 
+* ```choose(locator)``` - Localiza um botão radial e marca. O botão radial pode ser localizado pelo seu nome, ID ou label.
17 
+* ```check(locator)``` - Localiza um check box e o marca. O check box pode ser localizado pelo seu nome, ID ou label.
18 
+* ```uncheck(locator)``` - Localiza e desmarca um check box. O check box pode ser localizado pelo seu nome, ID ou label.
19 
+* ```attach_file(locator, path)``` - Encontra um campo para atachar arquivos  e adiciona um arquivo baseado em seu *path*. O campo pode ser localizado pelo seu nome, ID ou label.
20 
+* ```select(value, {:from => locator})``` - Encontra um select box e seleciona uma de suas opções. Se o select box suportar seleçnoes multiplas, esta função pode ser chamada multiplas vezes. O select box pode ser encontrado pelo seu nome, ID, ou label.
21 
+
22 
+#### Querying
23 
+
24 
+* ```page.has_css?(css_selector)``` - Checa se um elemento identificado por uma tag CSS esta na página ou dentro de um elemento.
25 
+* ```page.has_xpath?(xpath_expression)``` - Checa se um elemento identificado por um XPath esta na página ou dentro de um elemento.
26 
+* ```page.has_button?(locator)``` - Encontra o elemento indentificado pelo localizador na página ou dentro do elemento atual.
27 
+* ```page.has_checked_field?(locator)``` - Encontra o elemento indentificado pelo localizador na página ou dentro do elemento atual.
28 
+* ```page.has_unchecked_field?(locator)``` - Encontra o elemento indentificado pelo localizador na página ou dentro do elemento atual.
29 
+* ```page.has_field?(locator, options = {})``` - Encontra o elemento indentificado pelo localizador na página ou dentro do elemento atual.
30 
+* ```page.has_link?(locator, options = {})``` - Encontra o elemento indentificado pelo localizador na página ou dentro do elemento atual.
31 
+* ```page.has_select?(locator, options = {})``` - Encontra o elemento indentificado pelo localizador na página ou dentro do elemento atual.
32 
+* ```page.has_table?(locator, options = {})``` - Encontra o elemento indentificado pelo localizador na página ou dentro do elemento atual.
33 
+* ```page.has_content?(text)``` - Checa se uma pagina ou o node atual contem o texto dado, ignorando HTML tags e normalizando o espaço em branco.
34 
+
35 
+Todas os metodos *has_xxx?* retornam *verdadeiro* ou *falso* e também possuem um metodo contrario *has_no_xxx?* para checar a o contrario.
36 
+
37 
+Esses metodos devem ser usados junto com assertações do *Test::Unit* ou do *RSpec*.
38 
+
39 
+Exemplo *Test::Unit*
40 
+```assert(page.has_content?("orange juice"))```
41 
+
42 
+Exemplo *RSpec*
43 
+```page.should have_content("orange juice")```
44 
+
45 
+#### find
46 
+
47 
+* ```find_field(locator)``` - Encontra um campo em um formulario na página.
48 
+* ```find_link(locator)``` - Encontra um link na página.
49 
+* ```find(selector)``` - Encontra o primeiro elemento na página utilizando um seletor CSS ou cria um erro.
50 
+* ```find(:xpath, selector)``` - Utiliza o XPath para achar o primeiro elemento na página. O Capybara pode utilizar o XPath como *default* com ```Capybara.default_selector = xpath```.
51 
+* ```all(selector)``` - Retorna todos os elementos em uma array que sejam iguais ao seletor da busca.
52 
+
53 
+Uma referencia completa de funções de busca pode ser encontrada [aqui](http://rubydoc.info/github/jnicklas/capy-bara/master/Capybara/Node/Finders).
54 
+
55 
+Os metodos *find* parecem com os *has_xx?*, mas a diferença é que eles retornam um *Capybara::Element* em vez de verdadeiro ou falso. É possivel invocar outros metodos em um elemento encontrado, como por exemplo:
56 
+
57 
+```page.find('#main-nav').click_link('Login')```
58 
+
59 
+#### Scoping
60 
+
61 
+* ```within(locator, &block)```
62 
+* ```within_fieldset(locator, &block)```
63 
+* ```within_frame(frame_id, &block)```
64 
+* ```within_table(locator, &block)```
65 
+* ```within_window(handle, &block)```
66 
+
67 
+Esses metodos limitam os outros metodos a um scope especifico da página. Exemplo:
68 
+
69 
+	within('#search') do
70 
+		click_button('Search')
	end
71 
+
72 
+---
73 
+
74 
+<a class="btn btn-mini" href="readme.md">voltar</a>
75 
+

+ 8 - 0
criando um projeto.md
View File 

@@ -0,0 +1,8 @@
1 
+# Criando um projeto
2 
+Para criar um aplicativo em rails, digite o seguinte comando no terminal:
3 
+
4 
+```$ rails new demo_project -d mysql```
5 
+
6 
+O parametro *demo_project* indica o nome do projeto que está sendo criado. O parametro *-d mysql* serve para que o rails já configure o projeto utilizando um banco de dados mySQL.
7 
+
8 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 42 - 0
css_selectors.md
View File 

@@ -0,0 +1,42 @@
1 
+# CSS3 Attribute Selectors (CSS selector)
2 
+
3 
+Syntax
4 
+[attribute { ^= | $= | *= } attribute value] {
5 
+declaration block
6 
+}
7 
+
8 
+### Description
9 
+
10 
+CSS3 defines three more attribute selector variations. These new selectors give us the ability to make partial matches to attribute values—we can match strings at the start, end, or anywhere within an attribute value.
11 
+
12 
+We can use the ^= operator to cause an attribute selector to match elements that have an attribute containing a value that starts with the specified value:
13 
+
14 
+	a[href^="http:"] {
15 
+	  ⋮ declarations
16 
+	}
17 
+
18 
+This example matches a elements that have an href attribute value which starts with the characters "http:".
19 
+
20 
+Using the $= operator, an attribute selector can match elements that have an attribute which contains a value ending with the specified value:
21 
+
22 
+	img[src$=".png"] {
23 
+	  ⋮ declarations
24 
+	}
25 
+
26 
+This example matches img elements with a src attribute value that ends with the characters ".png".
27 
+
28 
+Finally, we can use the *= operator to make an attribute selector match elements that have an attribute which contains the specified value:
29 
+
30 
+	div[id*="foo"] {
31 
+	  ⋮ declarations
32 
+	}
33 
+
34 
+This example matches div elements whose id attribute value contains the characters "foo".
35 
+
36 
+### Example
37 
+
38 
+This example will match a elements with an href attribute that contains the string "example.com":
39 
+
40 
+	a[href*="example.com"] {
41 
+	  ⋮ declarations
42 
+	}

+ 34 - 0
cucumber.md
View File 

@@ -0,0 +1,34 @@
1 
+# Cucumber
2 
+
3 
+Behavior driven development
4 
+
5 
+### Instalação
6 
+
7 
+1- no arquivo ```Gemfile```:
8 
+
9 
+	group :test do
10 
+	  gem "rspec"
11 
+	  gem "rspec-rails"
12 
+	  gem "webrat"
13 
+	  gem 'cucumber-rails'
14 
+	  gem 'database_cleaner'
15 
+	end
16 
+
17 
+2- execute o comando ```$ bundle install```.
18 
+
19 
+3- Execute o gerador para iniciar o cucumber em um projeto rails:
20 
+
21 
+```$ rails generate cucumber:install```
22 
+
23 
+Uma pasta chamada ```app/features``` foi criada.
24 
+
25 
+4- Para rodar o cucumber, utilize o comando rake: ```$ rake cucumber```
26 
+
27 
+cucumber features -n
28 
+
29 
+### Features
30 
+
31 
+1. Cenario
32 
+2. Feature
33 
+3. Steps
34 
+4. Paths

+ 126 - 0
devise.md
View File 

@@ -0,0 +1,126 @@
1 
+# Devise
2 
+
3 
+O **devise** é um plugin que adiciona a funcionalidade de login para um projeto. Ele resolve todos os aspectos de **autenticação de usuários**, como login, logout, cadastro de novos usuários e recuperação de senhas.
4 
+
5 
+#### Instalação
6 
+
7 
+Primeiro adicione a linha no ```Gemfile```:
8 
+
9 
+	gem 'devise'
10 
+
11 
+Depois rode o comando ```$ bundle install``` para instalar o **gem**.
12 
+
13 
+Inicie o devise no projeto:
14 
+
15 
+```$ rails g devise:install```
16 
+
17 
+Esse comando instala o **devise** no projeto e mostra algumas instruções para faze-lo funcionar.
18 
+
19 
+Adicione a seguinte linha no arquivo ```config/environments/development.rb``` para configurar o sistema de email:
20 
+
21 
+	# and don't forget the other environments
22 
+	config.action_mailer.default_url_options = { :host => 'localhost:3000' }
23 
+
24 
+
25 
+Depois é necessario criar um modelo para os usuários:
26 
+
27 
+```$ rails generate devise user```
28 
+
29 
+Note que se já existe um modelo ```user```, o devise vai apenas adicionar a funcionalidade ao modelo existente.
30 
+
31 
+Execute depois o comando ```$ rake db:migrate``` para executar a migração.
32 
+
33 
+Agora é necessario adicionar no **View** links para poder fazer o login e o logout. Adicione o seguinte codigo no arquivo ```layouts/application.html.erb```.
34 
+
35 
+	<% if user_signed_in? %>
36 
+	  Logged in as <strong><%= current_user.email %></strong>.
37 
+	  <%= link_to 'Edit profile', edit_user_registration_path %> |
38 
+	  <%= link_to "Logout", destroy_user_session_path, method: :delete %>
39 
+	<% else %>
40 
+	  <%= link_to "Sign up", new_user_registration_path %> |
41 
+	  <%= link_to "Login", new_user_session_path %>
42 
+	<% end %>
43 
+
44 
+Com isso é possivel ter um sistema de autenticação de usuarios basico, funcional em apenas alguns passos simples.
45 
+
46 
+#### Rotas
47 
+
48 
+Para mudar as rotas das páginas de sign_in e sign_out, crie uma rota no arquivo ```config/routes.rb```.
49 
+
50 
+	devise_for :users, path_names: {sign_in: "login", sign_out: "logout"}
51 
+
52 
+É necessario ter uma rota **root** para que o devise funcione direito.
53 
+
54 
+	root :to => "home#index"
55 
+
56 
+#### Mudando o layout do devise
57 
+
58 
+Por *default*, o devise esconde os arquivos do **view**. Rode o comando para gera-los no projeto:
59 
+
60 
+```$ rails g devise:views```
61 
+
62 
+Esse comando irá gerar os varios arquivos que compõe o **view** na pasta ```app/views/devise/```.
63 
+
64 
+#### Mudando os parametros de login
65 
+
66 
+Para utilizar outros paramentros como por exemplo usar o **username** em vez do **email**, é necessario criar uma variavel no banco de dados e alterar algumas variavéis de configuração.
67 
+
68 
+Primeiro rode o comando:
69 
+
70 
+```$ rails g migration add_username_to_users username```
71 
+
72 
+Depois no arquivo ```config/initializers/devise.rb``` modifique as variaveis:
73 
+
74 
+	config.authentication_keys = [ :username ]
75 
+	config.case_insensitive_keys = [ :username ]
76 
+	config.strip_whitespace_keys = [ :username ]
77 
+
78 
+No arquivo do modelo ```app/models/user.rb```, adicione o ```attr_accessible :username``` e valide as presença dos dados por que o **devise** não valida atributos customizados: ```validates_presence_of :attribute, :on => :create, :message => "can't be blank"```
79 
+
80 
+Além disso vai ser necessario mudar os parametros utilizados no **View**.
81 
+
82 
+#### Restringindo acesso
83 
+
84 
+Para limitar o acesso a certas páginas a apenas usuários loggados, adicione a seguinte linha no controlador que controla as páginas desejadas (ex: ```app/controllers/posts_controller.rb```).
85 
+
86 
+	before_filter :authenticate_user!, except: [:index, :show]
87 
+
88 
+#### Helpers
89 
+
90 
+Verificar se o usuário está logado:
91 
+
92 
+	user_signed_in?
93 
+
94 
+Objeto com o atual usuário logado:
95 
+
96 
+	current_user
97 
+
98 
+#### Custom Layouts
99 
+
100 
+Para definir um layout diferente do que o padrão para a classe do **devise**, modifique o arquivo ```app/controllers/appication_controller.rb``` adicionando uma função para determinar o layout a ser usado:
101 
+
102 
+	class ApplicationController < ActionController::Base
103 
+	  layout :layout_by_resource
104 
+
105 
+	  protected
106 
+
107 
+	  def layout_by_resource
108 
+	    if devise_controller?
109 
+	      "layout_name_for_devise"
110 
+	    else
111 
+	      "application"
112 
+	    end
113 
+	  end
114 
+	end
115 
+
116 
+#### Links
117 
+
118 
+- [Devise (GitHub)](https://github.com/plataformatec/devise/)
119 
+- [RailsCats - Devise(revised)](https://github.com/plataformatec/devise/)
120 
+
121 
+---
122 
+
123 
+<a class="btn btn-mini" href="readme.md">voltar</a>
124 
+
125 
+
126 
+

+ 50 - 0
error_pages.md
View File 

@@ -0,0 +1,50 @@
1 
+# Páginas de Erro 404 e 500
2 
+
3 
+Para criar paginas de erro 404 e 500 vamos primeiro adicionar o codigo no ```app/controllers/application_controller.rb```:
4 
+
5 
+	class ApplicationController < ActionController::Base
6 
+	  # ...
7 
+
8 
+	  unless Rails.application.config.consider_all_requests_local
9 
+	    rescue_from Exception, with: lambda { |exception| render_error 500, exception }
10 
+	    rescue_from ActionController::RoutingError, ActionController::UnknownController, ::AbstractController::ActionNotFound, ActiveRecord::RecordNotFound, with: lambda { |exception| render_error 404, exception }
11 
+	  end
12 
+
13 
+	  private
14 
+	  def render_error(status, exception)
15 
+	    respond_to do |format|
16 
+	      format.html { render template: "errors/error_#{status}", layout: 'layouts/application', status: status }
17 
+	      format.all { render nothing: true, status: status }
18 
+	    end
19 
+	  end
20 
+
21 
+	  # ...
22 
+	end
23 
+
24 
+Depois é necessario criar um controlador para mostrar essas páginas. Crie o controlador  ```app/controllers/errors_controller.rb```:
25 
+
26 
+	class ErrorsController < ApplicationController
27 
+	  def error_404
28 
+	    @not_found_path = params[:not_found]
29 
+	  end
30 
+
31 
+	  def error_500
32 
+	  end
33 
+	end
34 
+
35 
+Criei os templates para as duas páginas de erro em ```app/views/errors/```.
36 
+
37 
+Por ultimo, adicione no fim do arquivo ```config/routes.rb``` uma rota para o erro 404:
38 
+
39 
+	unless Rails.application.config.consider_all_requests_local
40 
+	    match '*not_found', to: 'errors#error_404'
41 
+	end
42 
+
43 
+Essas págians de erro vão apenas ser mostradas no ambiente de produção. Para testar no ambiente de desenvolvimento, retire o seguinte codigo do ```application_controller.rb``` e do ```config/routes.rb```:
44 
+
45 
+	Rails.application.config.consider_all_requests_local
46 
+
47 
+### Link
48 
+* [Rambling Labs - Rails 3.1 - Adding custom 404 and 500 error pages](http://ramblinglabs.com/blog/2012/01/rails-3-1-adding-custom-404-and-500-error-pages)
49 
+
50 
+---

+ 19 - 0
gerando_modelos.md
View File 

@@ -0,0 +1,19 @@
1 
+# Gerando Modelos
2 
+
3 
+O seguinte comando gera um novo modelo em um aplicativo Rails. O nome tem que ser escrito em **"CamelCase"** e tem que ser uma termo no **singular**.
4 
+
5 
+```$ rails generate model Page```
6 
+
7 
+Arquivos gerados:
8 
+
9 
+- ```db/migrate/201200101000000_create_pages.rb``` - Arquivo inicial de migração
10 
+- ```app/models/page.rb``` - Classe **Page** que herda funções da classe **ActiveRecord::Base**
11 
+
12 
+## Exemplo de modelo
13 
+
14 
+	class User < ActiveRecord::Base
15 
+		# Para utilizar uma tabela que não seja a default "pages"
16 
+		# set_table_name("weird_page")
17 
+	end
18 
+
19 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 83 - 0
git.md
View File 

@@ -0,0 +1,83 @@
1 
+# Git
2 
+
3 
+### Iniciando um projeto
4 
+
5 
+Para inicicar um projeto com o Git via terminal:
6 
+
7 
+1. Entre no diretorio do projeto
8 
+2. ```$ git init```
9 
+3. ```$ git add REAdME.md```
10 
+4. ```$ echo "Hello Git World"```
11 
+5. ```$ git commit -m 'Initial upload'```
12 
+
13 
+### Commit
14 
+
15 
+Para ver as alterações feitas em um projeto:
16 
+
17 
+```git status```
18 
+
19 
+Depois adicione os arquivos que vão ser colocados dentro do commit com o comando:
20 
+
21 
+```git add .```
22 
+
23 
+Por ultimo faça o commit:
24 
+
25 
+```git commit -m "Meu primeiro commit no git"```
26 
+
27 
+### Retirando arquivos que estão em "Staging"
28 
+
29 
+```git reset FILE```
30 
+
31 
+Esse comando ira retirar um arquivo especifico da area de *staging* antes do commit.
32 
+
33 
+### Modificar o ultimo commit
34 
+
35 
+```git commit --amend```
36 
+
37 
+### Remover um arquivo que já está no repositorio
38 
+
39 
+```git rm file.txt```
40 
+
41 
+Para apenas ignorar o arquivo e suas modificações não entrem no "Staging Index", crie uma regra no arquivo ```.gitignore``` e utilize o comando:
42 
+
43 
+```git rm --cached file.txt```
44 
+
45 
+### Criar um branch
46 
+
47 
+```$ git checkout iss53```
48 
+
49 
+Faça algum commit nesse branch e depois volte para o master:
50 
+
51 
+```$ git checkout master```
52 
+
53 
+Para juntar os dois branchs utilize o comando:
54 
+
55 
+```$ git merge iss53```
56 
+
57 
+
58 
+### Remotes
59 
+
60 
+Um ```remote``` é um servidor que vai guardar outra copia do codigo. Pode ser um servidor como o GitHub para guardar e compartilhar o codigo ou pode ser um servidor de produção como o Heroku que vai rodar o codigo do aplicativo.
61 
+
62 
+Para criar um remote:
63 
+
64 
+```git remote add origin https://github.com/username/Hello-World.git```
65 
+
66 
+e para enviar codigo para ele:
67 
+
68 
+```git push origin master```
69 
+
70 
+Para deletar um remote:
71 
+
72 
+```git remote rm origin```
73 
+
74 
+e para listar os remotes
75 
+
76 
+```git remote```
77 
+
78 
+### Links
79 
+
80 
+- [12 curated git tips and workflow](http://durdn.com/blog/2012/12/05/git-12-curated-git-tips-and-workflows/)
81 
+- [Git Branching - Basic Branching and Merging](http://git-scm.com/book/en/Git-Branching-Basic-Branching-and-Merging)
82 
+
83 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 25 - 0
helpers.md
View File 

@@ -0,0 +1,25 @@
1 
+# Helpers
2 
+
3 
+## Text
4 
+
5 
+## Stylesheet
6 
+
7 
+O Rails guarda os arquivos de css na pasta: ```/public/stylesheets``` e os arquivos por *default* precisam ter a extensão **".css"**.
8 
+
9 
+Os stylesheets devem ser definidos no ```<head>``` do arquivo de template.
10 
+
11 
+Normalmente uma declaração de stylesheet em **HTML** seria a seguinte:
12 
+
13 
+	<lin href="stylesheets/styles.css" rel="stylesheet" type="text/css" media="all" />
14 
+
15 
+É possivel usar um **helper** do rails para simplificar o processo:
16 
+
17 
+	<%= stylesheet_link_tag('public', :media => 'all') %>
18 
+
19 
+Esse **helper** do rails cria o mesmo codigo **HTML** que foi mostrado anteriormente.
20 
+
21 
+É possivel carregar mais de um estilo por vez, separados por virgulas.
22 
+
23 
+Os tipos de media que podem ser utilizados são: **all**, **screen**, **print**, **mobile** e **tablet**.
24 
+
25 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 43 - 0
heroku.md
View File 

@@ -0,0 +1,43 @@
1 
+# Heroku Server
2 
+
3 
+### Configurando o Heroku Toolbelt e chaves SSH
4 
+
5 
+Primeiro faça o download do Heroku toolbelt e instale no computador. Depois rode o seguinte comandos para logar no heroku:
6 
+
7 
+	heroku login
8 
+
9 
+Apos fazer o login, se ocorrer algum problema de autenticação, é por que as chaves SSH não estão criadas ou atualizadas. Para cria-las, entre na pasta e execute os comandos:
10 
+
11 
+	cd ~/.ssh)
12 
+	ssh-keygen -t rsa -f id_rsa
13 
+	heroku keys:add "id_rsa.pub"
14 
+
15 
+### Configuração do aplicativo
16 
+
17 
+Coloque o seguinte codigo no arquivo ```config/application.rb```:
18 
+
19 
+	config.assets.initialize_on_precompile = false
20 
+
21 
+Depois modifique o arquivo ```config/enviorments/production.rb```:
22 
+
23 
+	  config.assets.compile = true
24 
+
25 
+### Criando um applicativo no servidor do Heroku
26 
+
27 
+	$ heroku apps:create example
28 
+	Creating example... done, stack is cedar
29 
+	http://example.herokuapp.com/ | git@heroku.com:example.git
30 
+
31 
+### Mudando o remote de um projeto git
32 
+
33 
+	git remote rm heroku
34 
+	git remote add heroku git@heroku.com:yourappname.git
35 
+
36 
+### Populate the database
37 
+
38 
+	heroku db:push
39 
+
40 
+Or just use the ```db/seeds.db``` file.
41 
+
42 
+
43 
+

+ 32 - 0
i18n.md
View File 

@@ -0,0 +1,32 @@
1 
+# Internacionalização com i18n
2 
+
3 
+O plugin i18n serve para criar administrar varias linguas em um sistema. Para começar, adicione o gem ao ```Gemfile```
4 
+
5 
+	gem 'i18n'
6 
+
7 
+Exemplo estatico:
8 
+
9 
+	<h1>Oranges<h1>
10 
+
11 
+Exemplo com o i18n:
12 
+
13 
+	<h1><%= t ".title" %></h1>
14 
+
15 
+No arquivo de tradução ```en.yml```
16 
+
17 
+	en:
18 
+	  item:
19 
+	    index:
20 
+	      title: "Titulo do produto"
21 
+
22 
+Para mudar a lingua no sistema, modifique o arquivo ```/app/controllers/application_controller.rb```:
23 
+
24 
+	classApplicationController < ActionController::Base
25 
+	  protect_from_forgery
26 
+	  before_filter :set_locale
27 
+	  private
28 
+	  def
29 
+		set_localeI18n.locale = "pt-BR"
30 
+	  end
31 
+	end
32 
+

+ 37 - 0
instalacao.md
View File 

@@ -0,0 +1,37 @@
1 
+# Instalação
2 
+
3 
+1. Cheque para ver se o Ruby já está instalado na sua maquina:
4 
+
5 
+	```$ Ruby -v```
6 
+2. Cheque a versão do Ruy Gems e faça o update:
7 
+
8 
+	```$ gem -v```
9 
+
10 
+	```$ gem update```
11 
+
12 
+	```$ sudo gem install mysql2```
13 
+
14 
+3. Instale o rails:
15 
+
16 
+	```$ gem list```
17 
+	```$ sudo gem install rails```
18 
+
19 
+4. Instale e inicie o banco de dados mySQL:
20 
+
21 
+	```$ ruby -e "$(curl -fsskl raw.github.com/mxcl/homebrew/go)"```
22 
+
23 
+	```$ brew install mysql```
24 
+
25 
+	```$ mysql_install_db --verbose --user='user' --basedir="$(brew --prefix mysql)" --datadir=/usr/local/var/mysql --tmldir=/tmp```
26 
+
27 
+	```$ mysql.server start```
28 
+
29 
+5. Para mudar a senha do banco de dados:
30 
+
31 
+	```$ mysql```
32 
+
33 
+	```SET PASSWORD for root@localhost=PASSWORD('1234');```
34 
+
35 
+	```exit```
36 
+
37 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 48 - 0
jQuery_file_upload.md
View File 

@@ -0,0 +1,48 @@
1 
+# jQuery File Upload
2 
+
3 
+Para transformar um esquema de upload normal para AJAX usando jQuery, para upload de multiplos arquivos por vez, primeiro crie o formulario e a classe do [CarrierWave](CarrierWave.md). Depois modifique o formulario:
4 
+
5 
+	<%= form_for Painting.new do |f| %>
6 
+	  <%= f.label :image, "Upload image:" %>
7 
+	  <%= f.file_field :image, multiple: true, name: "painting[image]" %>
8 
+	<% end %>
9 
+
10 
+Depois adicione o **gem** no ```Gemfile```:
11 
+
12 
+	group :assets do
13 
+	  gem 'jquery-fileupload-rails'
14 
+	end
15 
+
16 
+Depois no arquivo *javascript* ```app/assets/javascripts/application.js```, adicione a linha depois do jQuery:
17 
+
18 
+	//= require jquery-fileupload/basic
19 
+
20 
+No arquivo *javascript* do **modelo**, exemplo ```app/assets/javascripts/painting.js.coffe```
21 
+
22 
+	jQuery ->
23 
+		$('#new_image').fileupload()
24 
+			dataType "script"
25 
+
26 
+No controlador ```app/controllers/paintings_controller.rb```, modifique a ação **create** para devolver um arquivo javascript.
27 
+
28 
+	def create
29 
+	  @painting = Painting.create(params[:painting])
30 
+	end
31 
+
32 
+Agora crie o arquivo ```app/views/paintings/create.js.erb```.
33 
+
34 
+	<% if @painting.new_record? %>
35 
+	  alert("Failed to upload painting: <%= j @painting.errors.full_messages.join(', ').html_safe %>");
36 
+	<% else %>
37 
+	  $("#paintings").append("<%= j render(@painting) %>");
38 
+	<% end %>
39 
+
40 
+No modelo dos **paintibgs** ```app/models/painting.rb```
41 
+
42 
+	before_create :default_name
43 
+
44 
+	def default_name
45 
+	  self.name ||= File.basename(image.filename, '.*').titleize if image
46 
+	end
47 
+
48 
+Isso ira criar um nome *default* para os *paintings* criados.

+ 18 - 0
links_referencias.md
View File 

@@ -0,0 +1,18 @@
1 
+# Links de Referencias
2 
+
3 
+- [Rails Guide](http://guides.rubyonrails.org/index.html)
4 
+
5 
+
6 
+## Free Rails Cast
7 
+
8 
+- [FriendlyId](http://railscasts.com/episodes/314-pretty-urls-with-friendlyid?autoplay=true)
9 
+- [Oh My ZSH](http://railscasts.com/episodes/308-oh-my-zsh)
10 
+- [Spree eCommerce](http://railscasts.com/episodes/298-getting-started-with-spree)
11 
+- [Markdown with RedCarpet](http://railscasts.com/episodes/272-markdown-with-redcarpet)
12 
+- [Authentication from scratch](http://railscasts.com/episodes/250-authentication-from-scratch)
13 
+
14 
+## Plugins
15 
+
16 
+- [Joosy](http://joosy.ws/)
17 
+
18 
+<a href="readme.md" class="btn btn-mini">voltar</a>

+ 103 - 0
migration.md
View File 

@@ -0,0 +1,103 @@
1 
+# Migration
2 
+
3 
+Uma **migração** é um conjunto de instrução para o **banco de dados**, escrito em Ruby. Elas servem para *"migrar"* o banco de dados de um estado para outro.
4 
+
5 
+As intruções vão para **cima** e para **baixo** ou seja, é possivel ir para frente um estado e depois se necessario, voltar para o estado anterior.
6 
+
7 
+Ao fazer migrações, uma copia do atual esquema do banco de dados é guardado no arquivo ```app/db/schema.rb```
8 
+
9 
+## Metodo 1
10 
+
11 
+```$ rails generate migration initial_infos```
12 
+
13 
+O comando ira gerar um arquivo na pasta ```app/db/migrate```.
14 
+
15 
+## Metodo 2
16 
+
17 
+```$ rails generate model User```
18 
+
19 
+O comando ira gerar um arquivo chamado "create_users" na pasta ```app/db/migrate```.
20 
+
21 
+## Criando migrações especificas
22 
+
23 
+Se você está criando uma migração para outros propositos (como por exemplo adicionando um campo a uma tabela já existente), é possivel usar o seguinte gerador:
24 
+
25 
+```$ rails generate migration AddPartNumberToProducts part_number:string```
26 
+
27 
+Para esse comando funcionar é preciso usar o formato ```AddXXXToYYY``` ou ```RemoveXXXFromYYY``` junto com uma lista dos nomes das colunas e seus formatos.
28 
+
29 
+## Tipos de colunas
30 
+
31 
+- binary
32 
+- boolean
33 
+- date
34 
+- datetime
35 
+- decimal
36 
+- float
37 
+- integer
38 
+- string
39 
+- text
40 
+- time
41 
+- foreign key (ex: ```references :user```)
42 
+
43 
+## Opções de coluna
44 
+- :limit => size
45 
+- :default => value
46 
+- :null => true/false
47 
+- :precision => number
48 
+- :scale => numver
49 
+
50 
+
51 
+## Exemplo de arquivo de migração
52 
+
53 
+	class CreateUsers < ActiveRecord::Migration
54 
+		def self.up
55 
+		  create_table :users do |t|
56 
+			t.string "first_name", :limit => 25
57 
+			t.string "last_name", :limit => 50
58 
+			t.string "email", :default => "", :null => false
59 
+			t.string "password", :limit => 40
60 
+			t.timestamps
61 
+		  end
62 
+		end
63 
+
64 
+	  def self.down
65 
+		drop_table :users
66 
+	  end
67 
+	end
68 
+
69 
+## Executando as migrações
70 
+
71 
+```$ rake db:migrate```
72 
+
73 
+Ao executar o comando, o rails vai rodar todas as migrações que ainda não foram executadas.
74 
+
75 
+É possivel escolher em qual **"Enviorment"** a migração vai rodar adicionando a variavel ```RAILS_ENV=``` e adicionar o nome do ambiente (production, development, testing). O *default* é sempre o **development**.
76 
+
77 
+## Reverter migrações
78 
+
79 
+```$ rake db:migrate VERSION=0```
80 
+
81 
+Esse comando vai reverter as migrações para a primeira versão, apagando a tabela no banco de dados.
82 
+
83 
+Também é possivel reverter para uma versão intermediaria utilizando o número no começo do nome do arquivo da migração.
84 
+
85 
+## Metodos de migração de tabelas
86 
+
87 
+- ```create_table(table, options) do |t|```
88 
+- ```drop_table(table)```
89 
+- ```rename_table(table, new_name)```
90 
+- ```add_column(table, column, type, options)```
91 
+- ```remove_column(table, column)```
92 
+- ```rename_column(table, column, new_name)```
93 
+- ```change_column(table, column, type, options)```
94 
+- ```add_index(table, column, options)```
95 
+- ```remove_index(table,column)```
96 
+- ```execute("any SQL string")```
97 
+
98 
+#### Links
99 
+
100 
+- [Rails Guides - Migrations](http://guides.rubyonrails.org/migrations.html)
101 
+
102 
+
103 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 28 - 0
nested_model.md
View File 

@@ -0,0 +1,28 @@
1 
+# Nested Model
2 
+
3 
+Rails **gem** para simplificar o manuseio de varios modelos associados em um único formulario. Ele faz isso de um jeito discreto utilizando *jQuery*.
4 
+
5 
+#### Instalação
6 
+
7 
+Adicione o **gem** no ```gemfile``` e rode o comando ```$ bundle install```:
8 
+
9 
+	gem "nested_form"
10 
+
11 
+Adicione o **gem** ao *Asset Pipeline* no arquivo ```application.js```:
12 
+
13 
+	//= require jquery_nested_form
14 
+
15 
+Se você não está utilizando o *Asset Pipeline*, rode o seguinte comando para instalar o **nested_form**:
16 
+
17 
+```$ rails g nested_form:install```
18 
+
19 
+Inclua o *JavaScript* gerado no layout:
20 
+
21 
+	<%= javascript_include_tag :defaults, "nested_form" %>
22 
+
23 
+#### Utilização
24 
+
25 
+#### Links
26 
+
27 
+- [nested_form (GitHub)](https://github.com/ryanb/nested_form)
28 
+- [Dynamic Nested Forms in Rails 3 (madebydna blog)](http://blog.madebydna.com/all/code/2010/10/07/dynamic-nested-froms-with-the-nested-form-gem.html)

+ 11 - 0
rails_console.md
View File 

@@ -0,0 +1,11 @@
1 
+# Rails Console
2 
+
3 
+Para entrar no **Rails Console**, primeiro entre no terminal entre na pasta **root** do projeto. Depois digite o comando:
4 
+
5 
+```$ rails console```
6 
+
7 
+Com esse comando o rails vai iniciar o console para o **Enviorment** de desenvolvimento. Para carregar o console em outro enviorment:
8 
+
9 
+```$ rails console production```
10 
+
11 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 15 - 0
rake.md
View File 

@@ -0,0 +1,15 @@
1 
+# Rake
2 
+
3 
+Ruby helper command.
4 
+
5 
+```$ rake -T``` - Mostra uma lista com todos os comandos **rake** instalados.
6 
+
7 
+```$ rake -D db:migrate``` - Mostra uma descrição da tarefa
8 
+
9 
+O arquivo ```rakefile``` configura as **tarefas** do rake. É possivel escrever as proprias tarefas e coloca-las na pasta ```app/lib/tasks/```.
10 
+
11 
+## Exemplo
12 
+
13 
+```$ rake db:schema:dump RAILS_ENV=production``` - Exemplo de comando utilizando uma variavel do **rails**.
14 
+
15 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 39 - 0
readme.md
View File 

@@ -0,0 +1,39 @@
1 
+# Curso de Ruby on Rails
2 
+por James Peret
3 
+
4 
+Anota&ccedil;&otilde;es dos estudos de Ruby on Rails de James Peret, baseado no curso da *Lynda.com* e no livro *"Agile Development with Ruby on Rails"* da editora *"Pragmatic Programmer"*.
5 
+
6 
+## Index
7 
+1. [Instalação](instalacao.md)
8 
+2. [Criando um projeto](criando%20um%20projeto.md)
9 
+3. [Criando um banco de dados mySQL](Criando%20um%20banco%20de%20dados%20mySQL.md)
10 
+4. [Gerando um "Controller" e um "View"](Gerando%20um%20Controller%20e%20um%20View.md)
11 
+5. [Routes](routes.md)
12 
+6. [Render e redirecionamento](Render%20e%20Redirecionamento.md)
13 
+7. [ERB View Templates](View%20Templates.md)
14 
+8. [Instance Variables](Instance%20Variables.md)
15 
+9. [Links](Links.md)
16 
+10. [Parametros na URL](Parametros%20na%20URL.md) (GET e POST)
17 
+11. [Rake](rake.md)
18 
+12. [Migrations](migration.md)
19 
+13. [ActiveRecord e ActiveRelations](ActiveRecord_ActiveRelation.md)
20 
+14. [Gerando modelos](gerando_modelos.md)
21 
+15. [Rails Console](rails_console.md)
22 
+16. [Records](records.md)
23 
+17. [Scopes](scopes.md)
24 
+18. [Associações](associacoes.md)
25 
+19. [CRUD](CRUD.md)
26 
+20. [Scaffolding](scaffolding.md)
27 
+21. [Helpers](helpers.md)
28 
+22. [SimpleForm](SimpleForm.md)
29 
+23. [Nested Model Forms](nested_model.md)
30 
+24. [Autenticação de usuários com o Devise](devise.md)
31 
+25. [Upload de arquivos com o CarrierWave](CarrierWave.md)
32 
+26. [jQuery File Upload](jQuery_file_upload.md)
33 
+27. [Testes](testes.md)
34 
+28. [Twitter Bootstrap](twitter_bootstrap.md)
35 
+29. [Cucumber](cucumber.md)
36 
+30. [Controle de versão com Git](git.md)
37 
+31. [Funções de tempo](time_ago.md)
38 
+
39 
+*[Links de referencia](links_referencias.md)*

+ 115 - 0
records.md
View File 

@@ -0,0 +1,115 @@
1 
+# Records
2 
+Cada entrada de um objeto salvo no banco de dados é um **record**. É possivel criar records nos **controladores**, **modelos** ou atravez do [Rails Console](rails_console.md).
3 
+
4 
+## Criar
5 
+Para criar um novo objeto baseado em um modelo:
6 
+
7 
+```user = User.new```
8 
+
9 
+O objeto é criado, mas ele ainda não foi salvo no banco de dados. Para ver o estado do objeto:
10 
+
11 
+```user.new_record?``` - Retorna **true** se o objeto ainda não foi salvo.
12 
+
13 
+Para modificar parametros de um objeto:
14 
+
15 
+```user.first_name = "James"```
16 
+
17 
+Depois para salvar o objeto:
18 
+
19 
+```user.save```
20 
+
21 
+Também é possivel criar um objeto, configurar seus parametros e salva-lo em um unico comando:
22 
+
23 
+```user = User.new(:first_name => "James", :last_name => "Peret")```
24 
+
25 
+## Modificar
26 
+
27 
+Para achar uma entrada de um objeto atravez de seu **ID**:
28 
+
29 
+```user = User.find(1)```
30 
+
31 
+Depois um metodo para modificar parametros de um objeto em um unico comando:
32 
+
33 
+```user.update_attributes(:first_name => "Gabriel")```
34 
+
35 
+## Deletar
36 
+
37 
+Para deletar um objeto no banco de dados, primeiro ache o objeto e depois execute o comando:
38 
+
39 
+```user.destroy```
40 
+
41 
+Esse comando apenas remove o objeto do banco de dados, mas ele continua carregado na memoria.
42 
+
43 
+```user.frozen?``` - Retorna true se o objeto foi apagado do banco de dados.
44 
+
45 
+## Busca Simples
46 
+
47 
+- Busca por ID primario, retorna o objeto ou um **erro**:
48 
+
49 
+	```Page.find(2)```
50 
+
51 
+- Busca dinamica, retorna o objeto ou **NIL**:
52 
+
53 
+	```Page.find_by_id(2)```
54 
+
55 
+	```Page.find_by_title("About Us")```
56 
+
57 
+- Achar todos os objetos:
58 
+
59 
+	```Page.all```
60 
+
61 
+- Achar o primeiro ou ultimo objetos no banco de dados:
62 
+
63 
+	```Page.first```
64 
+
65 
+	```Page.last```
66 
+
67 
+## Busca com ActiveRelation
68 
+
69 
+Buscas utilizando ActiveRelation são apenas executadas quando necessario, diferente das buscas simples onde são executadas imediatamente. Outro detalhe é que as buscas com ActiveRelation normalmente retornam um array.
70 
+
71 
+Essas buscas utilizam o metodo ```where(condition)```, por exemplo:
72 
+
73 
+```Page.where(:author => "James Peret")```
74 
+
75 
+Essa busca retorna um Active Relation object, que pode ser linkado a outras buscas e consições:
76 
+
77 
+```Page.where(:author => "James Peret").order("id ASC")```
78 
+
79 
+O objeto com a busca é da classe ```ActiveRecord::Relation```, para ver isso:
80 
+
81 
+```page_query.class```
82 
+
83 
+Para ver a busca que vai ser gerada em SQL:
84 
+
85 
+```page_query.to_sql```
86 
+
87 
+Para iniciar uma busca com todos os objetos:
88 
+
89 
+```pages = Page.scoped```
90 
+
91 
+#### Tipos de expressões de condições
92 
+
93 
+- **String**: metodo mais simples para passar condições para uma busca. Porem cuidado com SQL Injection!
94 
+
95 
+	```author = 'James Peret' AND status='published'```
96 
+
97 
+- **Array**: utilizado para previnir SQL Injection.
98 
+
99 
+	```["author = ? AND status = published", "James Peret"]```
100 
+
101 
+- **Hash**: seguro de SQL Injection, mas limitado (não pode usar LIKE e outras expressões).
102 
+
103 
+	```{:author => "James Peret", :status => "published"}```
104 
+
105 
+#### order, limit, offset
106 
+
107 
+- order(sql_fragment)
108 
+	- formato: ```table_name.column_name``` + ```ASC``` ou ```DESC```
109 
+	- É possivel combinar mais de uma ordem, separadas por virgula.
110 
+- limit(integer)
111 
+- offset(integer)
112 
+
113 
+Exemplo: ```Page.order("id ASC").limit(10).offset(30)```
114 
+
115 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 30 - 0
routes.md
View File 

@@ -0,0 +1,30 @@
1 
+# Routes
2 
+
3 
+Configurações do applicativo Rails onde são definidos os roteamentos de páginas.
4 
+
5 
+```app -> config -> routes.rb```
6 
+
7 
+### Tipos de rotas
8 
+
9 
+#### Simple route
10 
+Roteamento simples de páginas unicas.
11 
+
12 
+```get "demo/index"``` = ```match "demo/index", :to => "demo#index"```
13 
+
14 
+#### Default route
15 
+Roteamento automatico de páginas baseado em varios parametros.
16 
+
17 
+```match ':controller(/:action(/:id(.:format)))'```
18 
+
19 
+#### Root route
20 
+Rota para o index do sistema.
21 
+
22 
+```root :to => "demo#index"```
23 
+
24 
+### Detalhes
25 
+
26 
+- Sempre reiniciar o servidor depois de mudar configurações de roteamento.
27 
+- O sistema vai escolher a primeira rota compativel com a página requisitada que for achado no arquivo de rotas.
28 
+- Escrever a rota para o index no começo do arquivo.
29 
+
30 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 36 - 0
scaffolding.md
View File 

@@ -0,0 +1,36 @@
1 
+# Scaffolding
2 
+
3 
+É possivel usar o comando **scaffold** para gerar de uma vez todos os componentes do **CRUD**:
4 
+
5 
+```$ rails generate scaffold post title:string body:text```
6 
+
7 
+Esse comando cria o model, o controller (com as actions: index, show, new, create, edit, update e destroy) e as views para as actions criadas.
8 
+
9 
+O comando gerou altomaticamente uma **migração** com um nome parecido com ```db/migrate/20120803224002_create_posts.rb```.
10 
+
11 
+	class CreatePosts < ActiveRecord::Migration
12 
+	  def change
13 
+	    create_table :posts do |t|
14 
+	      t.string :title
15 
+	      t.text :body
16 
+
17 
+	      t.timestamps
18 
+	    end
19 
+	  end
20 
+	end
21 
+
22 
+Note que essa **migração** é um pouco diferente das padrões.
23 
+
24 
+Depois é necessario rodar as migrações com o comando:
25 
+
26 
+```$ rake db:migrate```
27 
+
28 
+Inicie o servidor com o comando ```$ rails server``` e entre na URL com o browser: [http://localhost:3000/posts](http://localhost:3000/posts).
29 
+
30 
+<img src="imgs/exemplo_scaffolding.jpg" class="img-polaroid">
31 
+
32 
+Acima, uma página de listagem de posts criada pelo comando scaffold.
33 
+
34 
+*Referencia: [Blog do Dmitry Nix - Scaffold Exemplo e a Estrutura no Rails](http://blog.dmitrynix.com/scaffold-exemplo-e-a-estrutura-no-rails/)*
35 
+
36 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 33 - 0
scopes.md
View File 

@@ -0,0 +1,33 @@
1 
+# Scopes
2 
+
3 
+É possivel definir **ActiveRelation** querys dentro de um modelo. Isso é util para salvar buscas que são muito utilizadas. Também é possivel passar parametros para um **scope**.
4 
+
5 
+## Exemplo Simples
6 
+
7 
+Primeiro declare o **scope**:
8 
+
9 
+	Class Page < ActiveRecord::Base
10 
+
11 
+		scope :pub, where(:status => "published")
12 
+
13 
+	end
14 
+
15 
+ Depois para acessa-lo:
16 
+
17 
+```pages = Page.pub```
18 
+
19 
+## Exemplo com parametros
20 
+
21 
+Para utilizar parametros em um scope, utilizamos um operador chamado **lambda**:
22 
+
23 
+	Class Page < ActiveRecord::Base
24 
+
25 
+		scope :search, lambda{ |query| where([title LIKE ?", "%#{query}&"])}
26 
+
27 
+	end
28 
+
29 
+Depois para utilizar o scope com o parametro:
30 
+
31 
+```pages = Page.search("Contact")```
32 
+
33 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 49 - 0
testes.md
View File 

@@ -0,0 +1,49 @@
1 
+# Testes
2 
+
3 
+Em vez de ficar manualmente *debbugando* a cada modificação que for feita no aplicativo, o ideial é escrever **testes** que façam esse trabalho altomaticamente e mais rapido.
4 
+
5 
+Exitem varios tipos de testes:
6 
+
7 
+<table class="table table-bordered ">
8 
+	<tbody>
9 
+	  <tr>
10 
+	    <td style="width: 30%; padding-top: 8px; text-align: left; padding-left: 5px;">Unit Testing</td>
11 
+	    <td style="width: 50%;">Models</td>
12 
+	  </tr>
13 
+	  <tr>
14 
+	    <td style="width: 50%; padding-top: 8px; text-align: left; padding-left: 5px;">Functional Testing</td>
15 
+	    <td style="width: 50%;">Controllers/Views, requests</td>
16 
+	  </tr>
17 
+	  <tr>
18 
+	    <td style="width: 50%; padding-top: 8px; text-align: left; padding-left: 5px;">Integration Testing</td>
19 
+	    <td style="width: 50%;">User stories, sequences of requests</td>
20 
+	  </tr>
21 
+	  <tr>
22 
+	    <td style="width: 50%; padding-top: 8px; text-align: left; padding-left: 5px;">Performance Testing</td>
23 
+	    <td style="width: 50%;">How fast are requests handled</td>
24 
+	  </tr>
25 
+	  <tr>
26 
+	    <td style="width: 50%; padding-top: 8px; text-align: left; padding-left: 5px;">Load Testing</td>
27 
+	    <td style="width: 50%;">How many requests ca ben handled</td>
28 
+	  </tr>
29 
+	  <tr>
30 
+	    <td style="width: 50%; padding-top: 8px; text-align: left; padding-left: 5px;">Security Testing</td>
31 
+	    <td style="width: 50%;">Security vulnerabilities</td>
32 
+	  </tr>
33 
+	</tbody>
34 
+</table>
35 
+
36 
+### Frameworks e ferramentas para testes
37 
+
38 
+- Test::Unit (Incluso no Ruby e o Rails utiliza como default)
39 
+- Rspec
40 
+- Selenium
41 
+- Watir
42 
+- [Cucumber](cucumber.md)
43 
+- Webrat
44 
+- Mocha
45 
+- Shoulda
46 
+- Rcov
47 
+- Autotest
48 
+
49 
+<hr><a class="btn btn-mini" href="readme.md">voltar</a>

+ 38 - 0
time_ago.md
View File 

@@ -0,0 +1,38 @@
1 
+# Funções de tempo
2 
+
3 
+Formatação da função de tempo:
4 
+
5 
+	  %a - The abbreviated weekday name (``Sun'')
6 
+	  %A - The  full  weekday  name (``Sunday'')
7 
+	  %b - The abbreviated month name (``Jan'')
8 
+	  %B - The  full  month  name (``January'')
9 
+	  %c - The preferred local date and time representation
10 
+	  %d - Day of the month (01..31)
11 
+	  %H - Hour of the day, 24-hour clock (00..23)
12 
+	  %I - Hour of the day, 12-hour clock (01..12)
13 
+	  %j - Day of the year (001..366)
14 
+	  %m - Month of the year (01..12)
15 
+	  %M - Minute of the hour (00..59)
16 
+	  %p - Meridian indicator (``AM''  or  ``PM'')
17 
+	  %S - Second of the minute (00..60)
18 
+	  %U - Week  number  of the current year,
19 
+	          starting with the first Sunday as the first
20 
+	          day of the first week (00..53)
21 
+	  %W - Week  number  of the current year,
22 
+	          starting with the first Monday as the first
23 
+	          day of the first week (00..53)
24 
+	  %w - Day of the week (Sunday is 0, 0..6)
25 
+	  %x - Preferred representation for the date alone, no time
26 
+	  %X - Preferred representation for the time alone, no date
27 
+	  %y - Year without a century (00..99)
28 
+	  %Y - Year with century
29 
+	  %Z - Time zone name
30 
+	  %% - Literal ``%'' character
31 
+
32 
+	   t = Time.now
33 
+	   t.strftime("Printed on %m/%d/%Y")   #=> "Printed on 04/09/2003"
34 
+	   t.strftime("at %I:%M%p")            #=> "at 08:56AM"
35 
+
36 
+---
37 
+
38 
+<a class="btn btn-mini" href="readme.md">voltar</a>

+ 225 - 0
twitter_bootstrap.md
View File 

@@ -0,0 +1,225 @@
1 
+# Twitter Bootstrap
2 
+
3 
+O gem **twitter-bootstrap-rails** serve para simplificar o processo de utilizar o [Twitter Bootstrap Framework](http://twitter.github.com/bootstrap/) com o Rails.
4 
+
5 
+Por *default* o Rails utiliza o **SASS** como **pre-processador** de CSS. O Twitter Bootstrap utiliza o **Less** como pré-processador.
6 
+
7 
+O gem **twitter-bootstrap-rails** instala o pré-processador de Less no rails alem de disponibilizar varios comandos para gerar layouts rapidamente.
8 
+
9 
+Para começar, modifique o arquivo ```Gemfile```:
10 
+<pre class="prettyprint languague-ruby">
11 
+group :assets do
12 
+	gem "therubyracer"
13 
+	gem "less-rails" #Sprockets (what Rails 3.1 uses for its asset pipeline) supports LESS
14 
+	gem 'twitter-bootstrap-rails'
15 
+end
16 
+</pre>
17 
+
18 
+O **gem** do **twitter-bootstrap** é usado apenas como um asset, por causa do **Less** que vai compilar o **.css**, e não é necessario no enviorment de produção.
19 
+
20 
+Execute o comando a seguir para instalar o gem do twitter-bootstrap-rails e alguns outros gems como o Less.
21 
+
22 
+```$ bundle install```
23 
+
24 
+Em seguida instale o twitter-bootstrap-rails gem:
25 
+
26 
+```$ rails g bootstrap:install```
27 
+
28 
+Esse comando vai instalar o bootstrap, que vai criar os arquivos de css na pasta de layouts.
29 
+
30 
+Com tudo instalado, é possivel utilizar o comando a seguir para criar layouts rapidamente:
31 
+
32 
+```$ rails g bootstrap:layout application fixed```
33 
+
34 
+Esse comando gera um arquivo de layout com todas as configurações do twitter-bootstrap. É possivel criar um layout **fixed** ou **fluid**.
35 
+
36 
+Também é possivel usar o comando de **scaffold** para gerar o CRUD de um modelo e depois rodar um comando para estiliza-lo com o twitter-bootstrap. Primeiro gere o **scafold**:
37 
+
38 
+```$ rails g scaffold product name price:decimal --skip-stylesheets```
39 
+
40 
+Depois faça a migração:
41 
+
42 
+```$ rake db:migrate```
43 
+
44 
+Em seguida re-crie o layout com o coamndo:
45 
+
46 
+```$ rails g bootstrap:themed products -f```
47 
+
48 
+Para esse comando funcionar é preciso especificar o nome do modelo gerado pelo **scaffold**, neste caso "products" e é preciso passar a opção **-f** para sobre-escrever os arquivos de layout gerados anteriormente.
49 
+
50 
+#### body padding-top
51 
+
52 
+Outro detalhe para resolver depois, caso necessario, é colocar o um **padding** no body para criar um espaço no layout entre a navbar e o conteudo. O gem do twitter-bootstrap-rails cria um arquivo para modificar o css padrão: ```app/assets/stylesheets/bootstrap_and_override.css.less```
53 
+
54 
+<pre class="prettyprint languague-less">
55 
+@import "twitter/bootstrap/bootstrap";
56 
+
57 
+body { padding-top: 60px; }
58 
+
59 
+@import "twitter/bootstrap/responsive";
60 
+</pre>
61 
+
62 
+#### Flash Messages
63 
+
64 
+Para criar mensagens de sucesso e erro ao editar os formularios, utilize este codigo no View desejado ou no ```layouts/application.html.erb```
65 
+
66 
+	<% flash.each do |name, msg| %>
67 
+	  <div class="alert alert-<%= name == :notice ? "success" : "error" %>">
68 
+	    <a class="close" data-dismiss="alert">×</a>
69 
+	    <%= msg %>
70 
+	  </div>
71 
+	<% end %>
72 
+
73 
+Esse codigo vai loopar entre as **flash messages** e escreve-las de acordo com as classes do twitter bootstrap.
74 
+
75 
+#### Validação com SimpleForm
76 
+
77 
+Primeiro crie a validação no **modelo**:
78 
+
79 
+<pre class="prettyprint languague-ruby">
80 
+class Product < ActiveRecord::Base
81 
+	validates_presence_of :name, :price
82 
+end
83 
+</pre>
84 
+
85 
+Adicione o SimpleForm no ```Gemfile```:
86 
+
87 
+<pre class="prettyprint languague-ruby">
88 
+gem 'simple_form'
89 
+</pre>
90 
+
91 
+Depois execute o comando para instalar o SimpleForm no projeto:
92 
+
93 
+```$ rails g simple_form:install --bootstrap```
94 
+
95 
+Agora mude o codigo do formulario no arquivo ```_form.html.erb```:
96 
+
97 
+	<%= simple_form_for @product, :html => { :class => 'form-horizontal' } do |f| %>
98 
+	  <fieldset>
99 
+	    <legend><%= controller.action_name.capitalize %> Product</legend>
100 
+
101 
+	    <%= f.input :name %>
102 
+	    <%= f.input :price %>
103 
+
104 
+	    <div class="form-actions">
105 
+	      <%= f.submit nil, :class => 'btn btn-primary' %>
106 
+	      <%= link_to 'Cancel', products_path, :class => 'btn' %>
107 
+	    </div>
108 
+	  </fieldset>
109 
+	<% end %>
110 
+
111 
+#### Customizando a importação de arquivos
112 
+
113 
+Escolha exatamente quais compontentes do Twitter Bootstrap vão ser incluidos no sistema da seguinte forma:
114 
+
115 
+Para mudar o CSS, retire as seguintes linhas no arquivo ```app/assets/stylesheets/bootstrap_and_override.css.less```
116 
+
117 
+<pre class="prettyprint languague-less">
118 
+@import "twitter/bootstrap/bootstrap";
119 
+@import "twitter/bootstrap/responsive";
120 
+</pre>
121 
+
122 
+E substitua com todos os parametros do bootstrap:
123 
+
124 
+<pre class="prettyprint languague-less">
125 
+// CSS Reset
126 
+@import "reset.less";
127 
+
128 
+// Core variables and mixins
129 
+@import "variables.less"; // Modify this for custom colors, font-sizes, etc
130 
+@import "mixins.less";
131 
+
132 
+// Grid system and page structure
133 
+@import "scaffolding.less";
134 
+@import "grid.less";
135 
+@import "layouts.less";
136 
+
137 
+// Base CSS
138 
+@import "type.less";
139 
+@import "code.less";
140 
+@import "forms.less";
141 
+@import "tables.less";
142 
+
143 
+// Components: common
144 
+@import "sprites.less";
145 
+@import "dropdowns.less";
146 
+@import "wells.less";
147 
+@import "component-animations.less";
148 
+@import "close.less";
149 
+
150 
+// Components: Buttons & Alerts
151 
+@import "buttons.less";
152 
+@import "button-groups.less";
153 
+@import "alerts.less"; // Note: alerts share common CSS with buttons and thus have styles in buttons.less
154 
+
155 
+// Components: Nav
156 
+@import "navs.less";
157 
+@import "navbar.less";
158 
+@import "breadcrumbs.less";
159 
+@import "pagination.less";
160 
+@import "pager.less";
161 
+
162 
+// Components: Popovers
163 
+@import "modals.less";
164 
+@import "tooltip.less";
165 
+@import "popovers.less";
166 
+
167 
+// Components: Misc
168 
+@import "thumbnails.less";
169 
+@import "labels.less";
170 
+@import "progress-bars.less";
171 
+@import "accordion.less";
172 
+@import "carousel.less";
173 
+@import "hero-unit.less";
174 
+
175 
+// Utility classes
176 
+@import "utilities.less"; // Has to be last to override when necessary
177 
+
178 
+body { padding-top: 60px; }
179 
+
180 
+@import "twitter/bootstrap/responsive";
181 
+
182 
+// Set the correct sprite paths
183 
+@iconSpritePath: asset-path('twitter/bootstrap/glyphicons-halflings.png');
184 
+@iconWhiteSpritePath: asset-path('twitter/bootstrap/glyphicons-halflings-white.png');
185 
+
186 
+@navbarBackground: #555;
187 
+@navbarBackgroundHighlight: #888;
188 
+@navbarText: #eee;
189 
+@navbarLinkColor: #eee;
190 
+
191 
+.navbar .brand {
192 
+  color: #FAFFB8;
193 
+}
194 
+</pre>
195 
+
196 
+Para modificar os arquivos javascript, modifique o arquivo ```app/assets/javascripts/application.js``` para incluir os scripts desejados:
197 
+
198 
+<pre class="prettyprint languague-javascript">
199 
+//= require twitter/bootstrap/bootstrap-transition
200 
+//= require twitter/bootstrap/bootstrap-alert
201 
+//= require twitter/bootstrap/bootstrap-modal
202 
+//= require twitter/bootstrap/bootstrap-dropdown
203 
+//= require twitter/bootstrap/bootstrap-scrollspy
204 
+//= require twitter/bootstrap/bootstrap-tab
205 
+//= require twitter/bootstrap/bootstrap-tooltip
206 
+//= require twitter/bootstrap/bootstrap-popover
207 
+//= require twitter/bootstrap/bootstrap-button
208 
+//= require twitter/bootstrap/bootstrap-collapse
209 
+//= require twitter/bootstrap/bootstrap-carousel
210 
+//= require twitter/bootstrap/bootstrap-typeahead
211 
+</pre>
212 
+
213 
+#### Links
214 
+
215 
+- [Twitter Bootstrap Framework](http://twitter.github.com/bootstrap/)
216 
+- [twitter-bootstrap-rails no GitHub](https://github.com/seyhunak/twitter-bootstrap-rails)
217 
+- [SimpleForm 2.0 + Bootstrap](http://blog.plataformatec.com.br/2012/02/simpleform-2-0-bootstrap-for-you-with-love/)
218 
+- [variables.less](https://github.com/twitter/bootstrap/blob/master/less/variables.less)
219 
+- [RailsCasts - Twitter bootstrap basic](http://railscasts.com/episodes/328-twitter-bootstrap-basics)
220 
+- [RailsCasts - More on Twitter Bootstrap (pro)](http://railscasts.com/episodes/329-more-on-twitter-bootstrap)
221 
+
222 
+---
223 
+
224 
+<a class="btn btn-mini" href="readme.md">voltar</a>
225 
+