apt-get install libcurl3 libcurl3-gnutls libcurl4-openssl-dev

Isso resolve o problema.

• One to One
• One to Many
• Many to Many

Eu vou demostrar aqui como criar relacionamentos One to One. Para esse exemplo, vamos considerar que um usuário possui um perfil e um perfil só pode pertencer a um usuário.

Para começar, vamos criar nosso usuário.

rails g scaffold user name:string email:string

No nosso caso, não iremos precisar criar controller e views para o perfil. As informações contidas no perfil serão criadas no mesmo form que se cria as informações do usuário. Por isso, criaremos apenas um model para o perfil.

rails g model profile user_id:integer description:text

Neste caso, faremos o relacionamento adicionando o id do usuário na tabela do perfil. Vamos, agora, adicionar as migrações no banco.

rake db:migrate

Podemos começar a adicionar o código para criar nosso relacionamento. A primera coisa a se fazer é alterar os models para que eles saibam com quem estão se relacionando. No model do perfil, vamos dizer que ele pertence ao usuário.

#app/models/profile.rb
class Profile < ActiveRecord::Base
  belongs_to :user
end

O model do usuário vai ficar assim:

#app/models/user.rb
class User < ActiveRecord::Base
  has_one :profile
  accepts_nested_attributes_for :profile
end

Neste caso, precisamos adicionar a linha acceptsnestedattributesfor :profile_. O que ela faz é informar para o model que ele deve aceitar os atributos que são do perfil e salvá-los na tabela correspondente. Nested Attributes permitem que você salve os atributos de um filho através de seu pai. Exatamente o que estamos fazendo neste caso. No form de usuário, adicionaremos os campos do perfil e, no momento que submetermos, o perfil será salvo através do usuário. Ficará mais fácil de entender vendo como montaremos o form do usuário. Vamos a ele então.

#app/views/users/_form.html.erb
<%= form_for(@user) do |f| %>
  ...
    <div class="field">
        <%= f.fields_for :profile do |p| %>
            <%= p.label :description %><br/>
            <%= p.text_area :description %>
        <% end %>
    </div>
  ...
<% end %>

Eu reduzi um pouco o arquivo para ficar mais fácil de visualizar o código que estamos adicionando. O f.fieldsfor :profile_ serve para adicionarmos os campos do perfil dentro do form do usuário. Foi por isso que adicionamos a linha do nestedattributes no model de usuário. Na segunda parte, passamos um bloco onde adicionaremos os campos do perfil que, no nosso caso, é apenas _description.

Precisamos fazer com que a descrição apareça na tela depois de criada. Por isso, a adicionaremos no show do usuário.

#app/views/users/show.html.erb
...
<p>
  <b>Description:</b>
  <%= @user.profile.description %>
</p>

Neste momento, se você iniciar o servidor e for olhar sua view, notará que o campo description ainda não está aparecendo; isto é porque ele ainda não foi “criado”. Então, precisamos fazer essa “criação”. Vamos alterar nosso controller para isso.

#app/controllers/users_controller.rb
def new
  @user = User.new
  @user.build_profile
end

A linha @user.buildprofile_ está dizendo para “construir”(não consigo pensar uma expressão melhor no momento ) um perfil para esse usuário.

Tudo pronto! Agora, quando você for criar um usuário novo, verá o campo description, que salvará as informações no local certo e com o relacionamento certo.

Apenas como informação adicional: remova o arquivo public/index.html e adicione no config/routes.rb a linha

root :to => 'users#index'

Isso é apenas para vocês não precisarem acessar /users todas a vezes que entrarem no sistema.

Você pode baixar o código fonte do exemplo no repositório blog-posts, no Github.

Para esse exemplo, vamos considerar que um álbum possui várias fotos.

Comece adicionando a gem do Paperclip.

#Gemfile
gem 'paperclip'

Rode o bundle install para instalar a gem.

Gem adicionada, vamos criar nosso album.

rails g scaffold album name:string

Agora, vamos fazer um scaffold para as fotos.

rails g scaffold photo album_id:integer

Para facilitar, iremos apenas adicionar o album_id e, para adicionar os outros campos necessários para o paperclip, vamos usar o gerador que ele disponibiliza.

rails generate paperclip Photo image

Usaremos o rake db:migrate para atualizar o banco:

rake db:migrate

Precisamos, agora, alterar nossos models para criar os relacionamentos e adicionar o helper do paperclip.

#app/models/album.rb
class Album < ActiveRecord::Base
  has_many :photos
end

#app/models/photo.rb
class Photo < ActiveRecord::Base
  belongs_to :album
  has_attached_file :image,
                      :styles => { :medium => "300x300>",
                                   :thumb => "100x100>" }
end

Até aqui, nada diferente do que já estamos acostumados. Agora, vem a parte dos múltiplos uploads. Para começar, adicionaremos o form que irá adicionar as fotos.

#app/views/albums/show.html.erb
<%= form_for(Photo.new(:album_id => @album.id)) do |f| %>
    <%= f.hidden_field :album_id, "value" => @album.id %>
    <p><%= f.file_field :image %></p>
<% end %>

Agora, temos o nosso formulário, mas ele não faz nada por enquanto; ainda não tem nenhum botão para enviar. Para que o Uploadify funcione, precisamos, ainda, adicionar algumas coisas. Primeiro, vamos alterar o application.html.erb.

#app/views/layouts/application.html.erb
<head>
    <%= yield(:head) %>
</head>

Estamos adicionando esse yield(:head) porque só adicionaremos o javascript do uploadify no arquivo que irá utilizá-lo. Vamos a esse arquivo, então. Editaremos, novamente, o show do usuário e adicionaremos o seguinte código no inicio do arquivo.

#app/views/albums/show.html.erb
<% content_for(:head) do %>
    <%= render :partial => "upload" %>
<% end %>

Como vocês podem ver, estamos adicionando um partial upload; ele conterá o código javascript do Uploadify.

#app/views/albums/_upload.html.erb
<script type="text/javascript" charset="utf-8">
<%- session_key = Rails.application.config.session_options[:key] -%>
$(document).ready(function() {
    $('#photo_image').click(function(event){
        event.preventDefault();
    });
    $('#photo_image').uploadify({
        uploader : '/assets/uploadify.swf',
        cancelImg : '/assets/cancel.png',
        multi : true,
        auto : true,
        script : '/photos',
        scriptData : {
            '_http_accept': 'application/javascript',
            'format' : 'json',
            '_method': 'post',
            'album_id' : '<%= @album.id %>',
            '<%= session_key %>' : encodeURIComponent('<%= u cookies[session_key] %>'),
            'authenticity_token': encodeURIComponent('<%= u form_authenticity_token %>')
        },
        onComplete : function(event, queueID, fileObj, response, data) {
            $('.thumbs').fadeOut('slow').load('/albums/<%= @album.id %> .thumbs').fadeIn("slow");
        }
    });
});
</script>

O Uploadify utiliza um arquivo flash para funcionar e, para que sua aplicação funcione direito com isso, precisamos adicionar um token de autenticidade para o flash; são essas 3 linhas:

<%- session_key = Rails.application.config.session_options[:key] -%>
'<%= session_key %>' : encodeURIComponent('<%= u cookies[session_key] %>'),
'authenticity_token': encodeURIComponent('<%= u form_authenticity_token %>')

Vamos, também, adicionar um novo arquivo com o seguinte conteúdo:

#app/middleware/flash_session_cookie_middleware.rb
require 'rack/utils'
class FlashSessionCookieMiddleware
  def initialize(app, session_key = '_session_id')
    @app = app
    @session_key = session_key
  end
  def call(env)
    if env['HTTP_USER_AGENT'] =~ /^(Adobe|Shockwave) Flash/
      req = Rack::Request.new(env)
      env['HTTP_COOKIE'] = [ @session_key,
                             req.params[@session_key] ].join('=').freeze unless req.params[@session_key].nil?
      env['HTTP_ACCEPT'] = "#{req.params['_http_accept']}".freeze unless req.params['_http_accept'].nil?
    end
    @app.call(env)
  end
end

Agora, faremos com que o rails adicione isso na nossa sessão. Adicione o código abaixo no arquivo session_store.rb

#config/initializers/session_store.rb
...
Rails.application.config.middleware.insert_before(
  ActionDispatch::Session::CookieStore,
  FlashSessionCookieMiddleware,
  Rails.application.config.session_options[:key]
)

A parte do Uploadify nas views está pronta. O próximo passo é adicionar as imagens na tela. Para isso, editaremos o arquivo show, novamente.

#app/views/albums/show.html.erb
<div class="thumbs">
    <% @album.photos.each do |photo| %>
        <p><%= image_tag photo.image.url(:medium) %></p>
    <% end %>
</div>

Com os Models e views prontos, precisamos adicionar códigos no controller, também, e alterar o método create para receber os novos parâmetros enviados pelo form do Uploadify.

Primeiro, criaremos um método privado com o seguinte código:

#app/controllers/photos_controller.rb
private
def coerce(params)
  if params[:photo].nil?
    h = Hash.new
    h[:photo] = Hash.new
    h[:photo][:album_id] = params[:album_id]
    h[:photo][:image] = params[:Filedata]
    h[:photo][:image].content_type = MIME::Types.type_for(h[:photo][:image].original_filename).to_s
    h
  else
    params
  end
end

Ele vai tratar os parâmetos enviados e fazer com que fiquem em um formato que podemos usar para salvar nosso objeto. Também precisamos alterar o método create dessa forma:

#app/controllers/photos_controller.rb
def create 
  @album = Album.find(params[:album_id])
  newparams = coerce(params)
  @photo = Photo.new(newparams[:photo])
 
  respond_to do |format|
    if @photo.save
      format.html { redirect_to album_path(@album) }
      format.json { render :json => { :result => ‘success’, :upload => photo_path(@photo) } }
    else
      format.html { render :action => “new” }
    end
  end
end

Para finalizar, adicionaremos os arquivos do Uploadify na nossa aplicação. Ficará da seguinte forma:

#app/assets/javascripts
jquery.uploadify.v2.1.4.min.js
swfobject.js

#app/assets/stylesheets
uploadify.css

#app/assets/swf
uploadify.swf

Todos esses arquivos do Uploadify você encontra no zip, disponibilizado no site do plugin. Para baixar direto, clique aqui.

Acesse http://localhost:3000/albums e crie um álbum e, depois disso, teste o upload das fotos.

Você pode baixar o código fonte do exemplo no repositório blog-posts, no Github.

Estou preparando um post sobre upload de fotos com Paperclip e Uploadify. Estou organizando para que fique bem explicado. Como é um post maior, não quero que fique confuso.

Aplicações no Github

A partir do próximo post, todos os tutoriais serão disponibilizados com uma aplicação no Github. Acho que dessa forma fica legal para quem quiser baixar o código e estudar melhor. Por enquanto, ainda são aplicações pequenas. Mas pretendo, com o tempo, passar a criar aplicações mais complexas; acho que disponibilizando o código, ajuda bastante para quem está aprendendo.

Para instalar o Pow, basta ir no Terminal.app e rodar o comando:

curl get.pow.cx | sh

Com isso, você faz a instalação e já pode começar a usar. Para fazer o “deploy”, basta criar um link simbólico dentro da pasta ~/.pow.

cd ~/.pow
ln -s /path/to/myapp

Esse link simbólico é a unica coisa necessária para ativar o server. Agora acesse http://myapp.dev e sua aplicação estará rodando normalmente.

Se você quiser tornar o processo ainda mais fácil, basta utilizar a gem powder.

gem install powder

Agora, no terminal entre na pasta da sua aplicação e faça:

cd /myapp
powder link

Para saber mais sobre o Pow acesse o site: http://pow.cx/.

Uma das coisas que eu achei legal, é que agora sempre que quero mostrar alguma aplicação para alguém basta acessar a url sem precisar ir no terminal rodar o server manualmente

Para começar a usar a gem, você precisa ter instalado o ImageMagick. Utilizando o Homebrew, a instalação é bem simples:

brew install imagemagick

Agora vamos configurar a gem no nosso sistema. Adicione  no seu Gemfile o código:

#Gemfile
gem "paperclip"

Rode o bundle install para instalar a gem.
Nesse caso, iremos adicionar um avatar a um model user já existente. Vamos usar um gerador que o Paperclip disponibiliza.

rails generate paperclip User avatar

Ele irá gerar a seguinte migração:

#db/migrate/20111013174306_add_attachment_avatar_to_user.rb
class AddAttachmentAvatarToUser < ActiveRecord::Migration
  def self.up
    add_column :users, :avatar_file_name, :string
    add_column :users, :avatar_content_type, :string
    add_column :users, :avatar_file_size, :integer
    add_column :users, :avatar_updated_at, :datetime
  end
 
  def self.down
    remove_column :users, :avatar_file_name
    remove_column :users, :avatar_content_type
    remove_column :users, :avatar_file_size
    remove_column :users, :avatar_updated_at
  end
end

Rode o rake db:migrate para atualizar o banco e vamos prepara agora nosso model. No model User vamos adicionar os comandos necessários para fazer o upload.

#app/models/user.rb
has_attached_file :avatar,
                    :styles => { :medium => "300x300>",
                                 :thumb => "100x100>" }

E agora no seu _form.html.erb do usuário, vamos adicionar o campo para selecionar o arquivo.

#app/views/users/_form.html.erb
<%= form_for(@user) do |f| %>
  #o resto do seu código
  <%= f.file_field :avatar %>
  #o resto do seu código
<% end %>

No Rails 3.1 você não precisa mais adicionar o :html => { :multipart => true } ao seu form, mas caso esteja usando uma versão menor, seu form deverá ficar assim:

<% form_for :user, :html => { :multipart => true } do |form| %>

O resto permanece o mesmo. Para vermos o resultado, no show vamos adicionar o seguinte código:

<%= image_tag @user.avatar.url %>
<%= image_tag @user.avatar.url(:medium) %>
<%= image_tag @user.avatar.url(:thumb) %>

Agora, você tem um upload de fotos funcionando na sua aplicação. Em um outro post irei mostrar como fazer upload de múltiplas fotos usando o Uploadify, que é um plugin para Jquery muito legal.

Criador do iPod, iTunes, iPhone, iPad e Mac, foi com certeza uma das pessoas mais inovadoras que o mundo já conheceu. Torço para que todo seu legado continue a crescer da mesma forma que cresceu enquanto ele estava a frente da Apple.

Esse é o vídeo de uma famoso discurso na Universidade de Stanford. Vale a pena conferir e aprender um pouco com ele.

“Stay Hungry Stay Foolish”

Antes de conhecer essa gem, eu colocava o código abaixo no development.rb para fazer o envio usando minha conta do gmail.

 require 'tlsmail' #key but not always described
  Net::SMTP.enable_tls(OpenSSL::SSL::VERIFY_NONE)
 
  ActionMailer::Base.delivery_method = :smtp
  ActionMailer::Base.perform_deliveries = true
  ActionMailer::Base.raise_delivery_errors = true
 
  ActionMailer::Base.smtp_settings = {
    :enable_starttls_auto => true,  #this is the important shit!
    :address        => 'smtp.gmail.com',
    :port           => 587,
    :domain         => 'ustraview.com',
    :authentication => :plain,
    :user_name      => 'email',
    :password       => 'password'
  }

Então, sempre que uma email era enviado, eu precisava ir na minha caixa de entrada para ver o email enviado.

Agora, com essa gem, ficou tudo muito mais fácil. Primeiro instale a gem

gem "letter_opener", :group => :development

e no development.rb, simplesmente adicione:

config.action_mailer.delivery_method = :letter_opener

No momento em que um email é enviado, a gem intercepta esse envio, salva o email em /tmp/letter_opener e abre no browser uma tela nesse estilo:

Tudo muito simples.

A primeira coisa a se fazer antes de iniciar é instalar o xCode. Basta baixar na Mac App Store.

Uma ferramenta muito interessante para facilitar a instalação de sistemas no Mac OS é o Homebrew. Para instalar certos programas com ele, basta usar o comando brew install e o nome do programa. Ex: brew install wget.

Instalando o Homebrew

Essa parte não está ligada diretamente ao ambiente Rails. Mas como irei usá-lo para instalar o git, vou mostrar como instalá-lo também.

/usr/bin/ruby -e "$(curl -fsSL https://raw.github.com/gist/323731)"
brew update

Instalando o git

Para mim, bastou rodar o comando brew update, que ele já instalou o git. Caso não tenha instalado para você, instale com o comando:

brew install git

O homebrew irá baixar e compilar os arquivos necessários para instalar o git.

Instalando RVM

O RVM é um gerenciador de versões do ruby. Com ele, você pode, ao mesmo tempo, instalar o Ruby 1.8.7 e o Ruby 1.9.2, inclusive paths diferentes. Por exemplo: Ruby 1.8.7-p180 e Ruby 1.9.2-p290. Isso é muito útil para caso você tenha projetos em diferentes versões do Ruby.

bash < <(curl -s https://rvm.beginrescueend.com/install/rvm)

Leia as instruções exibidas no console; você precisará adicionar uma linha no seu .bash_profile.

Instalando o Ruby 1.9.2-p290

Para instalar versões do Ruby, é só usar o comando rvm install e dizer qual Ruby você deseja instalar.

rvm install 1.9.2-p290

O comando rvm list mostra todas as versões que você possui e, caso queria mudar de versão, basta usar rvm use 1.9.2-p290.

Vamos aproveitar para setar o Ruby que instalamos como default.

rvm use 1.9.2-p290 --default

Assim, mesmo instalando outras versões, essa acima sempre será a default.

Instalando Rails 3.1

Eu já estou usando o Rails 3.1 nos projetos que estou trabalhando. Mas caso você não esteja, basta instalar a versão que você desejar, com ou sem rvm, funciona do mesmo modo.

gem install rails

Agora, o básico para se programar em Rails está instalado. Vamos criar uma aplicação simples para testar.

rails new first_app
cd first_app
rails s

Acesse http://localhost:3000 para ver o server rodando.

Em alguns casos, como seu projeto ser open source e estar no github, não é interessante comitar seu arquivo de configuração do banco, afinal de contas lá está a senha do banco de produção. O ideal é no servidor manter uma cópia do banco de produção, para sempre que fizer o deploy atualizar o database.yml.

Então vamos fazer isso, primeiro adicione o arquivo config/database.yml no seu .gitignore:

No servidor, na posta do projeto existe uma diretório *shared* nele ficam os arquivos que serão compartilhados entre as versões do seu código. Crie, nele, um diretório config:

mkdir -p shared/config

E crie um arquivo database.yml com a configuração do seu banco. Algo assim:

production: encoding: utf8 
reconnect: true pool: 10
wait_timeout: 10 username:
user password: password
host: 127.0.0.1
database: database
adapter: mysql

No seu arquivo config/deploy.rb vamos colocar o código responsável por adicionar o arquivo do banco a versão atual do projeto:

after 'deploy:update_code', 'deploy:symlink_db'
namespace :deploy do
  desc "Symlinks the database.yml" 
  task :symlink_db, :roles => :app do
    run "ln -nfs #{deploy_to}/shared/config/database.yml 
            #{release_path}/config/database.yml"
  end
end

Com isso, sempre que você fizer o *cap deploy* ele irá criar um link simbólico do arquivo database.yml do diretório shared apontando para o config/ do seu projeto.

Dessa forma você não precisa se preocupar com as configurações do seu banco.