Alex Florentino

Archive for the ‘Ruby’ Category

Participei do meu primeiro evento Ruby On Rails, conforme minhas expectativas o evento foi bom, valeu apena o dinheiro e o tempo investido.

O Evento foi o Ruby e Rails no mundo Real 2009 confesso que o termo “mundo real” ficou mais no nome do que nas palestras.

1. Criando um Instant Messenger usando Rails

Palestra foi razoavel, falou sobre Jabber e XMPP de forma bem rapido afinal não da para apresentar um tema deste em 1 hora.

2. Ruby, Rails e empreendedorismo

Essa palestra sobre empreendedorismo ficou muito solta no evento, mais gostei, na verdade sempre gosto deste tema.

3. Ruby Desktop

Eu particularmente não gostei deste assunto, Ruby para Desktop ? é bom ter uma idéia sim, mas se vc realmente precisa desenvolver para desktop(windows) é melhor usar Delphi(.Net), ou java!

4. Outsorcing, ou como trabalhar para empresas gringas

Na minha opinião a melhor apresentação, salvou o evento e deu mais sentido no termo “Mundo Real” no nome do evento.

5. GlassFish on Rails: Escalabilidade e Confiabilidade

Palestra muito rapida, sobre um tema pesado! mais foi uma palestra e pesquisando na web você descobre que rodar sua aplicação no JRails + Glassfish pode ser uma boa saida.

6. Só os imaturos não testam

Uma das melhores palestras, Com bastante exemplos de utilização de testes e sobre a evolução dos desenvolvedores.

7. O que é e como funciona o RubyLearning

Uma palestra informativa sobre o projeto e como funciona, gostei!

8. Ruby, muito mais do que reflexivo!

Apresentada pelo Fabio Kung, realmente muito boa apresentação! Ele mostrou tecnicas para manipulação da linguagem usando ParseTree, ele deu exemplo de como usar essa ferramenta gerar métricas de qualidade do seu código.

Em resumo foi um bom evento, e compensou o investimento(R$50)
os organizadores estão de parabéns.

Todo programador  já deve ter escrito varios e varios sistemas onde exista a necessidade de proteger algumas paginas, qual é a solução mais comum ? escrever mais uma vez código para login de usuario, acabando por duplicar código entre projetos.

Outro efeito ruim disso é que acaba duplicando informações de acesso de usuarios, exemplo cada sistema tem sua própria base de dados de usuario, para resolver(ou tentar) este problema foi criado OpenID.

O funcionamento do OpenID, em linhas gerais, é o seguinte: usuario é dono de uma url digamos http://ualex.myopenid.com e  este usuario deseja logar no meu sistema que suporta autenticação por OpenID, ele simplesmente digita sua url na tela de login do meu sistema e logo depois é direcionado para um OpenID provider, neste caso myopenid.com, no site do OpenID provider o usuario digita sua  senha e comprova que é dono da URL, logo após isso ele é redirecionado para minha aplicação e continua navegando normalmente.

Parece complicado não é ?  OpenID tem uma especificação bem clara e existe varios frameworks em varias liguagens para tratar o processo de autenticação, existe até frameworks para criar seu próprio OpenID Provider, este útil para centralizar autenticação de usuarios de aplicações web dentro de uma empresa.

Neste tutorial irei aproveitar aplicação construida no post sobre restful authentication para implementar autenticação por OpenID, vamos la.

1. Instalar a biblioteca openid-ruby

gem install ruby-openid

2. Instalar o plugin open_id_authentication

git clone git://github.com/rails/open_id_authentication.git vendor/plugins/open_id_authentication

3. Criar as migrations do open_id_authentication

rake open_id_authentication:db:create

4. Criar uma migration para alterar nossa tabela users

ruby script\generate migration add_identity_url_for_users

Nossa nova migration irá conter :

class AddIdentityUrlForUsers < ActiveRecord::Migration
def self.up
add_column :users, :identity_url, :string
end

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

5. Alterar nosso controller Session para permitir autenticação por OpenID ou por password

Com certeza essa é umas das partes mais “complicadas” do processo, você irá precisar fazer as seguintes alterações no seu controller session(criado pelo restful_authentication).

def create
if using_open_id?
open_id_authentication()
else
password_authentication()
end
end

def open_id_authentication
authenticate_with_open_id do |result, identity_url|
if result.successful?
if @current_user = User.find_by_identity_url(identity_url)
success_login()
else
failed_login "Sorry, no user by that identity URL exists (#{identity_url})"
end
else
failed_login result.message
end
end
end

def success_login
session[:user_id] = @current_user.id
redirect_to(root_url)
flash[:notice] = "Sucesso"
end

def  failed_login(message)
flash[:notice] = message
redirect_to(new_session_url)

end

def password_authentication
logout_keeping_session!
user = User.authenticate(params[:login], params[:password])
if user
# Protects against session fixation attacks, causes request forgery
# protection if user resubmits an earlier form using back
# button. Uncomment if you understand the tradeoffs.
# reset_session
self.current_user = user
new_cookie_flag = (params[:remember_me] == "1")
handle_remember_cookie! new_cookie_flag
redirect_back_or_default('/')
flash[:notice] = "Logged in successfully"
else
note_failed_signin
@login       = params[:login]
@remember_me = params[:remember_me]
render :action => 'new'
end
end

altere seu arquivo conforme o código acima.

6. Adicionando a opção OpenID na tela de login

vamos adicionar em nossa tela de login um field para usuario entrar com sua url, e caso esta url estiver presente autenticar por OpenID.

//arquivo: sessions/new.html.erb
<p><%= label_tag "OpenID URL" %>
<p><%= text_field_tag 'openid_identifier' %></p>

7. Alterar nossa view para permitir o cadastro de nossa url de autenticação

adicione o novo field identity_url para quando o usuario estiver no processo de signup, ele possa entrar com a OpenID url.

//arquivo: users/new.html.erb

<p><%= label_tag 'Identity url' %><br/>
<%= f.text_field :identity_url %></p>

8. Corrigindo um  detalhe para torna nosso site mais seguro

//arquivo models/user.rb

attr_accessible :login, :email, :name, :password, :password_confirmation, :identity_url

note foi adicionado o :identity_url no final da listagem.

9. Finalizando

Pronto, se você chegou até aqui é hora de testar, para criar um OpenID(free) acesse o http://www.myopenid.com e faça o seu cadastro, uma dica é utilize o rails 2.2 e tentei inicialmente o rails 2.1.1 mais existe uma incompatibilidade entre os frameworks nessa versão.

1. Criando novo projeto de exemplo

 rails -d mysql todo

2. gerando um scaffold simples, com o propósito demonstrar como funciona restful authentication

 ruby script\generate scaffold todo descricao:text prazo:date feito:boolean

vamos criar também nosso banco de dados para isso não se esqueça de configurar seu arquivo config\database.yml (development)

 rake db:create

e executa nossa migration para ele criar a tabela todos:

 rake db:migrate

agora é um bom momento para você startar sua aplicação e fazer alguns testes:

 ruby script/server

3. Baixando restful authentication

no diretorio raíz do seu do seu projeto

 git clone git://github.com/technoweenie/restful-authentication.git vendor/plugins/restful_authentication

para rodar esse comando você irá precisar instalar um cliente git

4. Rodar um generate que irá criar uma estrutura de autenticação em nosso projeto

 ruby script\generate authenticated user sessions

Este generate irá criar o user model para você que nada mais é que sua tabela de usuarios
e também irá criar o controlador sessions, que será usado para login e logout.

novamente precisamos executar uma migration para atualizar nosso banco de dados

 rake db:migrate

e precisamos incluir o modulo AuthenticatedSystem em nosso application controler (app\controllers\application.rb) para que a nossa infra-estrutura de autenticação fique disponivel para nossa aplicação.

 include AuthenticatedSystem

5. vamos alterar  no nosso controller todo para pedir autenticação,
para isso basta adicionar a linha:

 before_filter :login_required , :except => [:index]

lembre se para cadastrar um novo usuario http://localhost:3000/signup

Pronto esta feito! implementamos nosso sistema de autenticação.

Como desenvolvedor sempre surge a tarefa do deployment, ou seja, colocar o seu trabalho para rodar, no mundo web existe várias formas de fazer isso,  exemplo se o site for em PHP, é comum a utilização de FTP, SFTP e RSYNC.  Por outro lado se for java(JSP e Servlet) essa pode não ser uma medida eficiente já que normalmente envolve parar e iniciar o tomcat.

Mas independente da tecnologia,  essa é uma terefa rotineira e repetitiva então é razoável automatiza-la, é comum nesse aspecto a utlização de shell scripts, .bat etc.

No mundo ruby on rails temos uma ferramenta muito boa para fazer isso é o : CAPISTRANO que automatiza essa tarefa, de forma muito elegante.

basicamente para utiliza-lo, você precisa seguir alguns passos básicos.

1. Instalar o capistrano atráves do GEM

gem install -y capistrano

2. Capification é basicamente criar alguns arquivos modelos no seu projeto Ruby On Rails , basta ir para raiz do seu projeto e digitar:

capify .

3. Algumas configurações basicas no arquivo config/deploy.rb

set :application, "seuprojeto"
set :repository,  "https://urlseurepositorio/svn"
set :deploy_to, "/pathnoseuservidor/#{application}"
set :user, "userssh"
role :app, "servidorapp"
role :web, "servidorapp"
role :db,  "servidorapp", :primary => true

Arquivo bem simples, e para quem já criou script de deploy na mão, é bem simples de entender.

4. Criar o arquivo script/spin, esse arquivo é que você colocar o comando para reiniciar sua aplicação no caso como eu uso Passenger, basta :

touch /pathyourproject/current/tmp/restart.txt

faça um commit das alterações.

5. Vamos criar a estrutura basica no nosso servidor

cap deploy:setup

6. E por último fazer um release

cap deploy:update //(copia os última versão do servidor de código fonte)
cap deploy:start //(faz o release, e se for caso reinicia a aplicação)

pronto em questões de minutos usando o Capistrano você automatiza o deployment do seu projeto,
eu já fiz shell script para fazer isso e também já usei o Apache Ant e digo uma coisa o
Capistrano é uma solução elegante para essa tarefa.

No mundo Ruby On Rails ja é comum a utilização do ActiveRecord o que pode não ser tão comum é a utilização do framework AR fora de uma aplicação Rails.

Exemplo no sistema que estou trabalhando preciso fazer alguns testes, e portanto sempre preciso apagar o banco de dados e carrega-lo com dados novamente, não queria fazer isso com os sql inserts, é ae que entra o ActiveRecord.

require 'rubygems'
require 'active_record'

ActiveRecord::Base.establish_connection({
:adapter => 'mysql', :database => 'database', :username => 'root', :password => '', :host => 'localhost'})

class Pessoa < ActiveRecord::Base
set_table_name "pessoa"
end

agora você já pode fazer algumas mágicas, exemplo :

irb -r ActiveRecordTest.rb

p = Pessoa.new

p.save

o que acontece é que você já é capaz de salvar dados no seu banco de dados, sem utilizar SQL.

Definitivamente ActiveRecord é muito prático!

Uma feature muito interessante no Ruby On Rails é a “counter_cache” , mais o que seria counter cache ? vou explicar através de um exemplo , supomos que você esteja desenvolvendo um site de contatos, suponhamos que você queira mostrar a quantidade de contatos por tipos algo no estilo da listagem abaixo:

na maneira “tradicional” , essa listagem sempre acarretaria em varios “selects”, ou seja, um select seleciona todos os tipos de contatos e um select para totalizar cada tipo, imagine, seu sistema tem 1.000,000 tipos de contato você teria 1.000,000 selects + 1.

O ruby counter cache minimiza este problema, pois ele cria uma nova coluna na tabela categoria com a quantidade correta de contatos.

Então vamos ao código.

1. Criar o projeto rails

    rails contato 	--database=mysql
   

2. Configuração

    edite seu 	config/database.yml e altere os dados do seu  banco de dados mysql
   

3. Criar a base de dados

    rake  db:create
   

4. Deixar o ruby criar algum código

   
   ruby 	script/generate scaffold Categoria nome:string
   

   
   ruby 	script/generate scafffold Contato nome:string email:string 	fone:string categoria_id:integer
   

5. Vamos criar as tabelas

    rake db:migrate
   

6. agora vamos setar nosso relacionamentos no model
   edite o app/models/categoria.rb que deve ficar como :

   
   class Categoria < ActiveRecord::Base
   has_many :contato
   end
   

   edite o app/models/contato.rb qude deve ficar como:

   
   class Contato < ActiveRecord::Base
   belongs_to :categoria
   end
   

   agora você já pode iniciar o servidor ruby script/server e acessar http://localhost:3000/categorias.

7. vamos editar a view index da categoria e adicionar a quantidade de contatos:

   ...<table>
   <tr>
   <th>Nome</th>
   <th>Quantidade</th>
   </tr>
   
   <% for categoria in @categorias %>
   <tr>
   <td><%=h categoria.nome %></td>
   <td><%=h categoria.contato.length %></td>...
   

8. agora vamos fazer a magica acontecer, vamos primeiro adicionar a coluna magica no seu modelo categoria

    ruby script/server migration 	add_categoria_count_cache
   

   edite esse novo arquivo:

   
   class AddCategoriaCountCache < ActiveRecord::Migration
   def self.up
   add_column :categorias,:contatos_count,:integer,:default => 0
   end
   
   def self.down
   end
   end
   

   logo após isso rode rake novamente,da pasta raiz do seu projeto:

   
   rake db:migrate
   

9. Agora vamos atualizar o Contato para sempre atualizar o count_cache, para isso basta editar o app/models/contato.rb

   
   class Contato < ActiveRecord::Base
   belongs_to :categoria, :counter_cache => true
   end
   

Pronto se tudo correu bem é para o counter cache estar habilitado, para testar basta acessar ruby script/console cadastrar algumas categorias e popular alguns contatos para essas categorias e verificar o resultado no browser.

aqui um outro ótimo exemplo.

divirta-se!

No Mundo Ruby On Rails, existe uma ferramenta Chamada Scaffold que tem como objetivo basicamente geração de um esqueleto para a nossa aplicação. Com esta ferramenta podemos começar o nosso projeto com bastante código gerado automaticamente.vamos a um passo-a-passo.

1. Baixe e instale o Ruby

2. Instale o MySQL acessando o link

3. Instalar o framework rails

gem install rails –include-dependencies

4. Crie uma nova aplicação rails blog -d mysql

5. Configure usuario e senha de acesso ao banco de dados para isso edite o arquivo config/database.yml e atualize o username e password

6. Cria o database

rake db:create

7. Gerar um scaffold

ruby script/generate scaffold blog titulo:string autor:string conteudo:text

8. Gera as tabelas rake db:migrate

9. Inicie o Servidor ruby script/server
acesse http://localhost:3000/blogs

Se tudo ocorreu bem é para ver um site com um cadastro totalmente funcional rodando.

Viva ao Ruby.