O lançamento do Ruby on Rails 2.3 está muito próximo e eu ainda não comentei sobre algumas novidades por aqui. A idéia desta série não é apenas mostrar as novas funcionalidades, mas explicar e dar exemplos de como elas funcionam na prática, mas alguns dos novos recursos são muito simples e não exigem muitos detalhes. [...]

Outro recurso que também foi muito solicitado e estará disponível com a versão 2.3 do Rails é uma melhoria nas nested transactions (transações aninhadas).
Atualmente no Rails já podemos aninhar transações, ou em um português mais simples podemos colocar uma transação dentro de outra. Veja um exemplo:
User.transaction do
User.create(:username => ‘Kotori’)
User.transaction do
[...]

Durante muito tempo a funcionalidade mais requisitada ao core team do Rails era a simplificação do gerenciamento de múltiplos modelos em apenas um formulário. Eu mesmo cheguei a comentar sobre uma nova opção chamada :accessible que facilitaria atribuições em massa em objetos ActiveRecord (aqui e aqui).
Infelizmente este recurso foi incluído ao Rails cedo demais, já [...]

Finders dinâmicos não são mais novidades no Ruby on Rails há muito tempo, qualquer um que já tenha trabalhado em um simples projeto Rails, já fez algo assim:
User.find_by_first_name_and_age(’Pedro’, 20)
Sabemos que o método acima não existe, mas graças aos finders dinâmicos podemos usá-lo para recuperar todos os usuários que tenham como primeiro nome ‘Pedro’ e 20 [...]

Este novo recurso acrescentado ao Rails dificilmente será usado por nós, mas vale a pela curiosidade. Foi acrescentado ao ActiveRecord um novo parâmetro de configuração para internacionalização que permite definir o separador de palavras em mensagens de erro.
Como?
No inglês e no português não faz o menor sentido, mas pegue o seguinte arquivo de internacionalização criado [...]

Finalmente a série de artigos cobrindo todas as novas funcionalidades do Rails 2.2 terminou, e de agora em diante somente novas adições serão cobertas. Não sabemos ao certo se a próxima versão do Rails será a 2.3 ou 3.0, mas aqui chamaremos apenas de Edge Rails.
Outra novidade neste blog foi a adição do Google Connect. [...]

No Rails 2.2 você poderá definir atributos do ActiveRecord como private. Como estes atributos são criados via metaprogramação, até agora isto era impossível.
Para entender como isto funcionará, vamos tornar o atributo name da classe User privado:
class User < ActiveRecord::Base

private
def name
“I’m private”
end

end
Agora ao tentar recuperar o [...]

Para tornar o ActiveRecord mais consistente foi adicionado o método de instância Model#delete. Ele é similar ao método de classe com o mesmo nome. O método delete, diferente do método destroy, apaga o registro do banco de dados sem disparar callbacks, como o before_destroy e o after_destroy.
Este método também não aplicará nenhuma das regras impostas [...]

Para entender esta alteração, vamos precisar analisar o mesmo código sendo executado em uma versão anterior do Rails e depois no Rails 2.2. Vamos pegar um modelo como exemplo:
class Comment < ActiveRecord::Base
alias_attribute :text, :body
end

Note que estou usando o método alias_attribute para criar um alias para o atributo body com o nome de text. [...]

Não sei dizer se isto é um bug ou não, mas na minha opinião isto representa um problema. Veja o código abaixo, onde tento alterar a conta de um usuário usando sua foreign key em um projeto Rails 2.1 ou anterior:
class User < ActiveRecord::Base
belongs_to :account
end

user = User.first
# => #<User id: 1, login: “admin”, [...]

O método composed_of recebeu duas novas opções: :constructor e :converter.
A opção :constructor pode receber um simbolo com o nome de um método ou um Proc. Por padrão, a classe de composição é criada através do método new, recebendo todos os atributos mapeadas como parâmetros, exatamente na ordem que em foram mapeados. Se por algum motivo [...]

Aumentando o número de finders dinâmicos do ActiveRecord, agora temos o find_last_by. Já tinhamos os famosos find_by e o find_all_by.
Além de simplificar, ficou muito mais elegante recuperar o último comentário feito por um usuário, por exemplo. Veja:
Comment.find_last_by_author(”Carlos Brando”)
Este artigo pertence a série “Edge Rails”. Todos os exemplos dados aqui funcionarão somente no Ruby on Rails [...]

Todas as mensagens de log que continham uma indicação do tempo que determinado processo levou para ser executado, foram alteradas para exibir o tempo em milisegundos.
Por exemplo, a mensagem:
Completed in 0.10000 (4 reqs/sec) | Rendering: 0.04000 (40%) | DB: 0.00400 (4%) | 200 OK [http://example.com]
Agora será exibida da seguinte forma:
Completed in 100ms (View: 40, DB: [...]

Se você tiver dois modelos: Post e Comment. Onde Post tem muitos (has_many) comentários. Se você executar:
Post.first.comment_ids
O Rails usará a seguinte query para recuperar os ids:
SELECT * FROM `comments` WHERE (`comments`.post_id = 1)
Mas neste caso, não precisamos dos objetos inteiros. A seguinte query seria mais do que suficiente para o funcionamento deste método, além de [...]

Existe um bug no método count do ActiveRecord quando usamos uma associação has_many em conjunto com a opção :limit ou ffset. Vejamos um exemplo:
class Post < ActiveRecord::Base
has_many :comments, :limit=> 2
end

No código acima quando tentarmos recuperar os comentários de um post, apenas 2 comentários devem ser retornados.
post.comments.length # => 2

# Veja o [...]

Digamos que temos a seguinte associação has_many :through:
class Author < ActiveRecord::Base
has_many :authorships
has_many :books, :through => :authorships
end

Ao procurar por um livro você pode incluir a autoria em sua busca:
author.books.find(:all, :include => :authorships,
:conditions => ["authorships.primary [...]

Os métodos dinâmicos de pesquisa do ActiveRecord receberam uma versão destrutiva, que dispara um erro do tipo RecordNotFound caso nenhum registro seja encontrado, ao invés de apenas retornar nil como acontece com a versão original.
Para usar esta versão destrutiva, basta adicionar o sinal de exclamação no final do método. Veja um exemplo:
Topic.find_by_title!(”The First Topic!”)
# => [...]

Lembra-se destes dois artigos?

Edge Rails: Usando a opção :accessible para fazer atribuições em massa no ActiveRecord
Edge Rails: Fazendo uso da opção accessible em formulários

Pois bem, esqueça. Esta funcionalidade foi removida do Rails, pois não estava totalmente completa e não daria tempo de terminar tudo até o lançamento do Rails 2.2.
Provavelmente ela deve voltar no futuro, [...]

Quando uma migration está em execução e um erro ocorre, tudo que já foi executado será aplicado ao banco de dados, mas tudo que estiver após o erro, não será aplicado. Além disso a migration será marcada como concluída. Isto pode dar uma certa dor de cabeça para corrigir.
Mas, se o banco de dados que [...]

Quando você executa o método find_all em um named_scope o método não está sendo direcionado para o proxy_found conforme o esperado. Isto faz com que um erro NoMethodError seja retornado.
Topic.base.find_all(&:approved)
# => NoMethodError: undefined method `find_all’ for #<Class:0×19a0fb4>

Este problema pode ser contornado usando o método to_a:
Topic.base.to_a.find_all(&:approved)
# => [#<Reply:0x179e720>#<Topic:0x179e388>#<Reply:0x179e20c>]

Após o lançamento do Rails 2.2 não teremos mais [...]

Algo que muita gente reclama sobre o Rails é que ele é lento. Sabemos que isto não é totalmente verdade, mas também sabemos que muita coisa pode ser feita para melhorar a performance dele.
Uma destas coisas acabou de se feita. Foi incluído ao Rails um Pool de Conexões com o banco de dados.
Toda vez que [...]

Imagine que ao rodar uma série de migrations um determinado modelo seja renomeado. Agora imagine que antes disto acontecer uma outra migration faça referencia a este modelo. Isto causará um erro feio e parará a execução de suas migrations.
Para evitar este tipo de problema foi criado uma nova classe chamada MigrationProxy que armazena o nome, [...]

Alguns de vocês já devem conhecer o método assert_queries que ajuda a validar nos testes a quantidade de queries executadas. Por exemplo:
assert_queries(Firm.partial_updates? ? 0 : 1) { firm.save! }
No teste acima estou afirmando que se houver partial_updates uma query deve ser executada no banco de dados, caso contrário nenhuma deve ser executada.
Agora ganhamos mais um [...]

Uma nova opção foi acrescentado ao método has_many: a opção :primary_key.
Fazendo uso desta opção podemos definir qual método do modelo associado retornará a chave primária que será usada na associação. Obviamente o método padrão é o id.
Veja um exemplo de uso:
has_many :clients_using_primary_key, :class_name => ‘Client’,
:primary_key => ‘name’, :foreign_key => ‘firm_name’
Atualização
4 de agosto de [...]

Todos os métodos de associações do ActiveRecord (belongs_to, has_one, has_many e has_and_belongs_to_many) receberam um nova opção que permite a atribuição de valores para suas associações usando hashes aninhados.
Vamos pegar como exemplo um modelo chamado Post:
class Post < ActiveRecord::Base
belongs_to :author, :accessible => true
has_many :comments, :accessible => true
end

Note que logo após associar este [...]