Continuando a série, vou falar de algumas outras novidades do Ruby on Rails 2.0 (ele não para, ele não para!). Mas de início tenho que falar de algo que acabou passando batido na primeira parte…

root

O Rails padronizou agora aquela rota que você acaba sempre (ou quase) incluindo em seus projetos, que mapeia a raiz do aplicativo (ou o home, index…). A forma padronizada agora é essa:

map.root :controller => "pages" # mapeia a action "index" do controller "pages"

ou

map.root :controller => "pages", :action => "show", :id => 10 # mapeia a action "show" do controller "pages" com o parâmetro id=10

Sessões em Cookies

As sessões no Rails 2.0 ficam agora totalmente em client side, ou seja, em cookies. Isso é bom pois dessa forma fica mais rápido e acabam as manutenções no tmp/sessions. Nas palavras do próprio DHH:

Esta configuração funciona bem se você segue as boas práticas e mantém o uso da sessão ao mínimo, como o caso comum de apenas guardar o user_id e o flash. Se, de qualquer forma, você está planejando guardar “códigos de lançamento nuclear” na sessão, guardar sessões no cookie é um mal negócio. Enquanto eles não podem ser forjados (então is_admin = true está ok), seu conteúdo podem ser vistos. Se isto é um problema para sua aplicação, você sempre pode voltar para o modo tradicional de guardar sessões.

Request Profiler

Chegou a salvação para aquela sua action que, como diria Lucas Petes, “chupa cana, assovia e bate palma”. Aquela action que faz um monte de coisas, e leva um bom tempo para executar… Request Profiler.

Com o Request Profiler você pode executar um profilling em um request. É assim:

$ cat login_session.rb
get_with_redirect '/'
say "GET / => #{path}"
post_with_redirect '/sessions', :username => 'john', :password => 'doe'
say "POST /sessions => #{path}"
$ ./script/performance/request -n 10 login_session.rb

Para quem não sabe, com o profiler você é capaz de saber exatamente qual parte do seu código está levando mais tempo para executar, com isso você pode focar suas atenções de forma a conseguir um melhor desempenho.

Mais performance no ActiveRecord

O pacote ActiveRecord ganhou milhares de fixes e várias melhoras. Uma que eu particularmente adorei é a Cached Query, que reconhece SQLs similares e retorna o resultado cacheado, assim:

>> User.find :all, :conditions => {:name => "a"}
>> User.find :all, :conditions => {:name => "a"}
olha o log!
  User Load (0.335079)   SELECT * FROM `users` WHERE (`users`.`name` = 'a')
  User Load (0.000363)   SELECT * FROM `users` WHERE (`users`.`name` = 'a') # viu o tempo?

Fixtures

Direto ao código…

  # groups.yml
  admins:
    name: admins
 
  # users.yml
  carlos:
    username: shopify
    password: secret
    group: admins # veja isso!!

Reparem 2 coisas: Você não precisa preencher os campos que já são de preenchimento automático (id, updated_at…). Você não precisa ficar guardando o ID que você deu para aquela outra fixture que é relacionada a que você está trabalhando agora, apenas o nome é suficiente.

Desserialização XML

Você já serializava um objeto em XML, agora você pode também fazer o caminho inverso:

>> u = User.new(:name => "Carlos")
=> #<user>
>> b = User.new.from_xml(u.to_xml)
=> #<user>
>> b
=> #<user>
</user></user></user>

Serialização JSON

A serialização em JSON mudou, repare:

Rails 1.2.6

>> User.new.to_json
=> "{attributes: {name: null,  updated_at: null, created_at: null}, new_record: true}"

Rails 2.0.1

>> User.new.to_json
=> "{\"name\": null, \"updated_at\": null, \"created_at\": null}"

No primeiro ele não serializa apenas as propriedades do usuário, mas sim o objeto ActiveRecord::Base, já no rails 2.0 ele passa a serializar exatamente igual a serialização XML, inclusive os parâmetros de :include e etc…

Menos gordura

Todos os acts_as_ALGUMACOISA foram movidos para seus próprios plugins, assim ./script/plugin install acts_as_ALUMACOISA deixa tudo normal. Outra coisa que mudou foi a postura com relação a bases de dados comerciais, todos foram movidos para seus gems. O Rails agora só trata com MySQL, SQLite e PostgreSQL. Para os bancos comerciais, gem install activerecord-BANCO-adapter (Ex.: activerecord-oracle-adapter).

Bom, acho que é só por hoje… aguardem o próximo artigo da série! See yo!

update: a versão release é 2.0.1, e não 2.0 apenas.

Ufa! Chegou o dia a hora! Acaba de ser anunciado por DHH o release do Rails 2.0… os desenvolvedores Rails mais antenados (e que não gostam de deprecation warnings) não terão grandes problemas na migração, pois desde o último release da 1.x.x já haviam warnings avisando de todos os métodos que estavam obsoletos.

O Rails 2.0 vem para facilitar ainda mais a vida dos desenvolvedores. Idéias novas e antigas, muito mais leve e limpo (sem gordura). Muito que antes estava no core do Rails agora é apenas um plugin, um dos casos mais clássicos é a substituição do ActionWebService pelo ActiveResource (uma opção por padronizar o uso do REST em detrimento ao SOAP).

Vamos ao que há de novo:

Sexy migrations (ou como queira chamar)

As migrations ficam mais fáceis e ágeis com este novo recurso:
Ao invés de:

t.column :first_name, :string
t.column :last_name, :string

Temos:

t.string :first_name, :last_name

namespaces nas rotas

já pensou?

map.namespace(:admin) do |admin|
  admin.resources :users
end

Este pequeno bloco de código mapeia aquele seu controller Admin::UsersController como um recurso, onde você tem admin_user_url, admin_users_url, …

Convenção em controllers que são recursos REST

Agora da para reaproveitar (sem gambiarra) um controller (resource) em vários contextos. Isso se deve a uma convenção de que todo controller que será um resource agora está no plural. Então…

map.resources :users # /users => UsersController#index
map.resources :groups, :has_many => :users # /groups/1/users => UsersController#index

Multiview

Agora a view é associada ao renderizador e ao formato, ou seja, index.rhtml agora é index.html.erb, onde html é o formato e ERB é o renderizador. index.erb (sem o formato) é que tem a mesma template para todos os formatos. index.atom.builder utiliza o Builder, este formato antes seria index.rxml. Desta forma uma view é mapeada diretamente para o formato requerido no Request.

URLs made easy

Se temos um map.resources :users, então link_to(@user.name, @user), mapeia para a URL direta do @user, ou seja, /user/:id. O mesmo para form_for(@user) e redirect_to(@user), e tudo mais que usa a magnífica construção de URL do rails.

Autenticação HTTP

O novo módulo de autenticação HTTP ajuda bastante em vários aspectos. Tanto para eliminar uma tela de login simples, quanto para autenticação quando se está sendo acessado via API RESTful.

def auth
  authenticate_or_request_with_http_basic do |username, password|
    if user = User.auth(username, password)
      set_current_user(user)
      return true
    else
      return false
    end
  end
end

Mais segurança

Rails 2.0 melhora a segurança tendo habilitado como padrão uma proteção contra ataques XSS e CSRF. Rails 2.0 também adiciona o suporte a HTTP-only cookies (que não podem ser acessados via JavaScript), estes serão usados na proteção citada anteriormente nos browsers que já o suportam.

Exceções

Finalmente! Hehehe, esta é boa. Agora você pode tratar exceções em todo controller (independente da action) e em controllers filhos de forma única.

class ApplicationController < ActionController::Base
  rescue_from ActiveRecord::RecordNotFound, :with => :not_found
 
  def not_found
    render :template => "errors/not_found"
  end
end

Este código renderiza uma template única de “not found” para sempre que tentar procurar um registro que não existe, em todos os controllers filhos de ApplicationController.

AtomFeedHelper

Um helper para o Builder para construção de atom em um jeito mais rubista… Veja se não é fácil…

Em um index.atom.builder

  atom_feed do |feed|
    feed.title("Thinking About Something")
    feed.updated((@posts.first.created_at))
 
    for post in @posts
      feed.entry(post) do |entry|
        entry.title(post.title)
        entry.content(post.body, :type => 'html')
 
        entry.author do |author|
          author.name(post.author_name)
        end
      end
    end
  end

Fonte: weblog.rubyonrails.org