rails app_teste

Com isso iremos gerar toda a estrutura da aplicação. Agora vamos configurar as gems utilizadas, em ‘config/enviroment.rb’, adicionaremos dentro do bloco ‘Rails::Initializer.run’ a gem do mongoid:

Rails::Initializer.run do |config|
  config.gem 'mongoid'
  config.time_zone = 'UTC'
end

Com a gem do Mongoid, não precisaremos mais do ActiveRecord, para remover de sua aplicação basta adicionar dentro do mesmo bloco que você configurou o a gem, a seguinte linha ‘config.frameworks -= [:active_record]‘. Deixando meu enviroment.rb assim:

Rails::Initializer.run do |config|
  config.frameworks -= [:active_record]
  config.gem 'mongoid'
  config.time_zone = 'UTC'
end

Quando utilizavamos o ActiveRecord, por padrão ele procurava um arquivo YAML chamado database.yml no qual continha as informações sobre o meu banco. No caso do mongoid, podemos continuar com esse mesmo arquivo, ou criar outro (no meu caso eu prefiro criar um chamado mongoid.yml).
Abaixo segue o meu arquivo yml:

base: &base
  adapter: mongodb
  # em tempo de execucao vamos adicionar o "-#{Rails.env}" ao nomo do banco
  database: "feedse"
# Se estiver rodando o mongodb em outro host,
#vc deveria autenticar-se
  #host: host.mongodb.com
  #username: your-username
  #password: your-password

# use as proximas linhas para colocar algo especifico a cada ambiente
development:
  <<: *base

test:
  <<: *base

production:
  <<: *base

Feito isso, agora precisamos que nossa aplicação leia esse arquivo e configure nossa conexão com o banco. Para isso, criaremos um arquivo chamado ‘mongo.rb’ (ou qualquer outro nome que você queira) dentro do diretório config/initializers.
mongo.rb

require 'yaml'

mongo_config = YAML::load(File.read(File.join(Rails.root, 'config/mongoid.yml')))[Rails.env]

Mongoid.configure do |config|
  config.from_hash(mongo_config)
end

Com isso, já temos tudo pronto em relação ao nosso banco.

Criaremos então, um model chamado ‘Content’. Lembrando que como não utilizamos mais o ActiveRecord, nossa classe não deverá herdar ActiveRecord::Base.

Abaixo segue a implementação da nossa classe:

class Content
  include Mongoid::Document
  field :title, :type => String

  validates_presence_of :title
  validates_uniqueness_of :title
end

Para que nossa classe seja persistida em nossa banco, precisamos incluir o include Mongoid::Document. Precisamos também definir os campos que ele vai ter, no nosso caso somente o campo ‘title’. A definição básica dos campos segue a seguinte estrutura ‘field , :type => ‘. Para mais informações consulte a documentação do mongoid.

Utilizando o RSpec

Vamos gerar a estrutura do rspec, como faríamos em qualquer outro projeto Rails.

script/generate rspec

Logo após gerar a estrutura, abra o arquivo spec_helper.rb dentro do diretório spec recém gerado, e dentro do bloco Spec::Runner.configure comente as seguinte linhas:

  config.use_transactional_fixtures = true
  config.use_instantiated_fixtures  = false
  config.fixture_path = RAILS_ROOT + '/spec/fixtures/'

Um dos problemas que enfrentei logo quando comecei a mexer com Rspec junto com MongoDb, foi que o rpspec não limpa o banco de testes após executar os mesmos. Logo isso deverá ser feito na mão, para isso adicionaremos dentro do bloco Spec::Runner.configure em o seguinte código:

  config.after(:each) do
    Mongoid.database.collections.each do |collection|
      unless collection.name =~ /^system\./
        collection.remove
      end
    end
  end

Deixando o nosso spec_helper.rb assim:

ENV["RAILS_ENV"] ||= 'test'
require File.expand_path(File.join(File.dirname(__FILE__),'..','config','environment'))
require 'spec/autorun'
require 'spec/rails'

# in ./support/ and its subdirectories.
Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}

Spec::Runner.configure do |config|

  #config.use_transactional_fixtures = true
  #config.use_instantiated_fixtures  = false
  #config.fixture_path = RAILS_ROOT + '/spec/fixtures/'
  #clean database mongodb after tests
  config.after(:each) do
    Mongoid.database.collections.each do |collection|
      unless collection.name =~ /^system\./
        collection.remove
      end
    end
  end

end

Nesse caso o Rspec irá limpar o banco depois de cada teste ‘each’, mas você pode efetuar a limpeza somente depois de todos os testes terem rodado, nesse caso ao invés de ‘:each’ como parâmetro, utilizaremos ‘:suite’, e caso você queira executar alguma coisa antes dos testes, utilize o ‘config.before’, que funciona exatamente da mesma maneira do ‘config.after’, com a diferença de ser executado antes(before) dos testes.

Obs: Se você está utilizando também o cucumber e está com problemas em relação a limpeza do banco após os testes, a solução é simples.
Crie o arquivo ‘clean_mongo.rb’ (ou qualquer outro nome) dentro de features/support e adicione nele o código abaixo:

After do |scenario|
  Mongoid.database.collections.each do |collection|
    unless collection.name =~ /^system\./
      collection.remove
    end
  end
end

E com isso temos nossos testes funcionando com o mongodb.

Como no post anterior, eu tenho o model “Person”:

class Person
  include MongoMapper::Document
  key :name, String
  key :middle_initial, String
end

E eu preciso encontrar todos os registros (no caso do Mongodb, documentos) que contenham o nome “Silva” em ‘name’, podendo ter vários Silva’s, como: “João da Silva”, “Maria Silva” e etc…

A solução, mais uma vez, é simples:

Person.all("$where" => "function() { return this.name.match(/"Silva"/i)"})

class Person
  include Mongoid::Document
  field :name
  field :middle_initial
end

E eu preciso encontrar todos os registros (no caso do Mongodb, documentos) que contenham o nome “Silva” em ‘name’, podendo ter vários Silva’s, como: “João da Silva”, “Maria Silva” e etc…

A solução é simples:

Person.find(:all, :conditions => {:name => Regexp.new("Silva")}).entries

Então será retornado um array contendo todos os documentos com o termo “Silva” no nome.

require 'Qt4'

app = Qt::Application.new(ARGV)

hello = Qt::PushButton.new('Hello World!')
hello.resize(100, 30)
hello.show()

app.exec()

gem install is_paranoid

Para que funcione em sua aplicação Rails, adicione no enviroment.rb , dentro do bloco de inicialização:

config.gem "is_paranoid"

Deixando mais ou menos assim:

Rails::Initializer.run do |config|
  # ...
  config.gem "is_paranoid"
end

Agora, nos models que vão utilizar dos recursos do is_paranoid, adicione logo após a declaração da classe ‘is_paranoid’

Exemplo:

class Student < ActiveRecord::Base
  is_paranoid
end

E para finalizar, crie uma migrate que adicione na tabela que vai utilizar o is_paranoid, o campo ‘deleted_at’, do tipo ‘timestamp’.

Exemplo:

class AddIsparanoidInStudent < ActiveRecord::Migration
  def self.up
    add_column :students, :deleted_at, :timestamp
  end

  def self.down
    remove_column :students, :deleted_at
  end
end

Pronto! Se quiser saber mais sobre o is_paranoid, consulte a documentação oficial no site do projeto.

Primeiro iremos gerar uma migration que adiciona na tabela o usuário a coluna ‘reset_password_code’.

script/generate migration reset_password_code

Agora editarei a migration gerada, deixando da seguinte forma:

class ResetPasswordCode < ActiveRecord::Migration
  def self.up
    add_column :users, :reset_password_code, :string
  end

  def self.down
    remove_column :users, :reset_password_code
  end
end

em seguida, ‘rake db:migration’ e estaremos pronto para começar!

Na classe UsersController irei criar um método protected que irá gerar um código para ser enviado ao usuário.

protected
  def random_code( len = 40 )
    chars = (("a".."z").to_a + ("1".."9").to_a )- %w(i o 0 1 l 0)
    newpass = Array.new(len, '').collect{chars[rand(chars.size)]}.join
  end

Agora criarei o método que chamará a view com o campo para o usuário colocar seu email:

  def change_reset_password
  end

Agora criarei a view que receberá o endereço de email do usuário e chamará o método “reset_password” passando o email:

<p>
    <%= form_tag (:controller => 'users', :action => 'reset_password' ) %>

    <p>
        <%= label_tag 'Email' %>
        <br/>
        <%= text_field_tag (:email) %>
    </p>
    <p>
        <%= submit_tag 'Enviar' %>
    </p>
    <%= flash[:alert] %>
</p>

Já método reset_password, irá receber o email, procurar o usuário com esse email, gerar o código de reset password, e chamar o UserMailer para enviar o email com o código.

  def reset_password
    user = User.find_by_email(params[:email])
    unless user.nil?
      user.reset_password_code = random_code
      if user.save!
        UserMailer.deliver_new_password(user)
        flash[:done] = "Verifique seu email para trocar a senha"
        redirect_to ('/')
      else
        flash[:error] = "Erro ao efetuar trocar de senha"
        render :action => 'change_reset_password'
      end
    else
      flash[:error]  = "Email Inválido"
      render :action => 'change_reset_password'
    end
  end

Vejam que estou chamando “UserMailer.deliver_new_password(user)” e passando o usuário como parâmetro. Na classe ‘UserMailer’ devo criar o método ‘new_password’ que será usado para enviar o email.
Meu método new_password deverá ficar assim:

  def new_password(user)
    setup_email(user)
    @subject    += 'Mudança de senha'
    @body[:url]  = "#{$SERVER_CONTENT_BASE}/password/#{user.reset_password_code}"
  end

Agora criarei a view para esse email, dentro de ‘app/views/user_mailer’ com o nome de ‘new_password.html.erb’

Olá <%=h @user.login %> alguém solicitou a troca de senha para essa conta.
Se deseja realmente trocar sua senha, clique no link abaixo:
<%=h @url %>

Agora de volta ao UsersController, criarei o método que recebe o reset_code e se ele estiver correto será jogado em um campo hidden na view de troca de senha.

  def code_password_reset
    user = User.find_by_reset_password_code(params[:reset_code])
    if user.nil?
      flash[:error]  = "Código inválido"
      redirect_to ('/')
    else
      @reset_code = params[:reset_code]
      render :action => "new_password"
    end
  end

Criarei a view de troca de senha, chamada ‘new_password’

<p>
    <%= form_tag (:controller => 'users', :action => 'reset_password_update', :method => 'put' ) %>
    <p>
        <%= label_tag 'Nova Senha' %>
        <br/>
        <%= password_field_tag (:password) %>
    </p>
    <p>
        <%= label_tag 'Confirmação' %>
        <br/>
        <%= password_field_tag (:password_confirmation) %>
    </p>
    <%= hidden_field_tag(:reset_code, @reset_code) %>
    <p>
        <%= submit_tag 'Enviar' %>
    </p>
	<%= flash[:alert]%>
</p>

E agora o método que de fato executa a troca de senha:

  def reset_password_update
    @user = User.find_by_reset_password_code(params[:reset_code]) unless params[:reset_code].blank?
    if ((params[:password] == params[:password_confirmation]) && !params[:password_confirmation].blank?)
       @user.password_confirmation = params[:password_confirmation]
       @user.password = params[:password]
       @user.reset_password_code = nil
      if @user.save!
        flash[:done] = "Senha atualizada com sucesso!"
        redirect_to ("/")
      else
        flash[:alert] = "Falha ao atualizar senha."
        render :action => 'new_password'
      end
    else
      flash[:alert] = "Senhas diferentes!"
      render :action => 'new_password'
   end
  end

Para finalizar iremos configurar as rotas;

  map.resources :users, :collection => { :change_reset_password => :get,
                                         :new_password => :get, :reset_password_update => :post,
                                         :code_password_reset => :get, :reset_password => :get}
  map.connect 'password/:reset_code', :controller => 'users', :action => 'code_password_reset'

E assim chegamos ao fim desse tutorial.

http://blog.wolfman.com/articles/2007/7/6/rspec-testing-views-for-escaped-html
http://www.elevatedrails.com/articles/2007/09/10/testing-controllers-with-rspec/
http://simplesideias.com.br/usando-o-rspec-para-testar-sua-aplicacao-rails-modelos/
http://simplesideias.com.br/7-coisas-que-voce-precisa-conhecer-no-rspec/
http://blog.davidchelimsky.net/2007/05/14/an-introduction-to-rspec-part-i/

gem install will_paginate

Com o plugin instalado, podemos começar a configura-lo na aplicação. Para isso abra o arquivo environment.rb dentro do diretório config e adicione no final do arquivo a seguinte linha:

require "will_paginate"

Com isso, sua aplicação só irá subir se o plugin will_paginate estiver presente.
Já no controlador devo usar o método paginate para efetuar a busca pelos registros no banco. No meu caso, tenho uma entidade chamada ‘noticia’ e no método ‘index’ do seu controlador, pelo padrão o rails faz uma busca por todos os registros no banco.

  def index
    @noticias = Noticia.all

    respond_to do |format|
      format.html # index.html.erb
      format.xml  { render : xml => @noticias }
    end

E no caso eu irei deixa-lo assim:

  def index
    @noticias = Noticia.paginate :page => params[:page], : order => 'created_at DESC', :per_page => 10

    respond_to do |format|
      format.html # index.html.erb
      format.xml  { render : xml => @noticias }
    end
  end

Onde o “:order =>” irá definir a ordem de exibição dos registros.
E o “:per_page =>” a quantidade de registros por página.

E pra terminar, abra a view e adicione logo abaixo do término da tabela:

<%= will_paginate @noticias %>

Insert Zend Framework
Enviando e-mails com SMTP autenticado e corpo HTML através do Zend_Mail

Teremos um backing bean chamado ClasseBean que conterá uma objeto do tipo classe.

public class ClasseBean {

    private Classe classe;
    private ClasseDao classeDao;
    private List<SelectItem> listaItem;
    private int professorSelecionado;

public ClasseBean() {
        classe = new Classe();
        classeDao = new ClasseDao();
        listaItem = getLista();
    }

 public List<SelectItem> getLista() {
        ArrayList<SelectItem> lista = new ArrayList<SelectItem>();
	ProfessorDao professorDao = new ProfessorDao();
        List<Professor> resultado = (List<Professor>) professorDao.listAll();

        for (Professor teste : resultado) {
            SelectItem item = new SelectItem(teste.getId(), teste.getNome());
            lista.add(item);
        }
        return lista;
    }

 public String salvar() {

	 ProfessorDao professorDao = new ProfessorDao();
         professor = professorDao.procurar(professorSelecionado);
         this.classe.setProfessor(professor);
         classeDao.salvar(classe);

        classe = new Classe();
        return "listarClasses";
    }

	//métodos getters e setters omitidos

}

No exemplos não irei me apegar a camada de persistência, devendo essa ter sido criada previamente pelo programador e conter os métodos de busca pelo ID e buscar todos os registros.

Iremos começar pelo método getLista(), nesse método é criado uma lista de SelectItem que será usada como exibição, os objetos SelectItem recebem como parametro no construtor dois atributos, o primeiro é a chave do selectItem (que será igual ao id do professor) e o valor de exibição (que no nosso caso será o nome do professor).

Já o método salvar() utilizar o ProfessorDao para efetuar uma busca através do atributo professorSelecionado (o valor desse atributo será igual a chave do item escolhido no SelectOneMenu, que no nosso caso será o id do professor. Lembra-se do: “SelectItem item = new SelectItem(teste.getId(), teste.getNome());” ) após isso o atributo professor do objeto Classe é setado e o o objeto é persistido.

Agora iremos para a criação da página jsf:

<h:selectOneMenu value="#{classeBean.professorSelecionado}">
classeBean.listaItem}">
                            <f:selectItems value="#{classeBean.listaItem}"/>
</h:selectOneMenu>

O atributo value do SelectOneMenu recebe como parametro o atributo que receberá o valor da chave do atributo selecionado da lista.
E utilizamos o selectItems para informar em qual atributo está a lista de SelectItem’s a ser exibida.