ricardo duarte

Git: Push e Delete de branches remotos

Ricardo — Thu, 04 Feb 2010 02:18:02 +0000

Dica rápida

Para enviar um branch local para o servidor remoto, use o comando abaixo:

git push origin nova-funcionalidade

Já para deletar um branch remoto, é tão simples quanto:

git push origin :nova-funcionalidade

PS. Não esqueça de deletar o branch local também, se for o caso:

git branch -d nova-funcionalidade

Dica do git ready.

Filtrando as consultas com has_scope

Ricardo — Wed, 06 Jan 2010 02:50:53 +0000

A Plataforma Tecnologia lançou recentemente o has_scope, plugin/gem extraído do InheritedResources (o qual ainda não tive a capacidade de entender o funcionamento).

Ele permite criar filtros nas consultas usando os escopos (named_scopes) definidos no Model de uma forma simples e elegante, mantendo toda a lógica do negócio fora do Controller.

Vamos ao código:

No Model abaixo, implementei dois escopos que gostaria de usar para filtrar a consulta.

# /app/models/timesheet.rb
class Timesheet < ActiveRecord::Base
named_scope :by_employee, proc { |employee| { :conditions => { :employee_id => employee } } }
named_scope :by_place, proc { |place| { :conditions => { :place_id => place } } }
end

No Controller, defini quais escopos que vou usar no filtro.

# /app/controllers/timesheets_controller.rb
class TimesheetsController < ApplicationController
has_scope :by_employee
has_scope :by_place
def index
@timesheets = apply_scopes(Timesheet).all
end
end

Na View, criei uma partial com os campos do filtro.

# /app/views/timesheets/_filter.html.rb
<% form_tag ('/timesheets', :method => :get) do -%>
<%= select_tag 'by_employee', options_for_select(@employees, params[:by_employee].to_i) %>
<%= select_tag 'by_place', options_for_select(@places, params[:by_place].to_i) %>
<%= content_tag(:button, "Search", :type => "submit") %>
<% end -%>

Esse formulário do filtro irá chamar o método index usando GET (através da URL), como no exemplo:

http://localhost:3000/timesheets?by_employee=1&by_place=3

Como de costume, esse post é só um aperitivo. Acesse o completíssimo README no GitHub para mais detalhes de utilização.

RPCFN #2: Average Arrival Time For A Flight

Ricardo — Wed, 28 Oct 2009 02:15:55 +0000

O Ruby Learning começou uma série de desafios para Rubistas iniciantes, na qual um profissional Ruby elabora um problema e os interessados em participar enviam as soluções desenvolvidas em Ruby para serem avaliadas. O autor do desafio escolhe a melhor implementação e sorteia uma entre as outras soluções funcionais. Os premios são screencasts da PeepCode e BDDCasts.

Por que não participar?

O problema proposto pelo Chris Strom foi o seguinte:

Você deve um grande favor e concordou em pegar um amigo no aeroporto toda Sexta-feira a noite. A linha área que seu amigo voa é barata, mas terrível quando se trata em reportar atrasos e horários de saída e chegada. Você rapidamente descobriu que o voos agendados para as 10pm nunca chegam no horário e usualmente atrasam mais de uma hora. Se o avião chegar as 11:15pm, 12:03am, 11:30pm, 11:23pm e 11:48pm, qual é o horário médio da chegada?

A solução funciona se seu amigo mudar o horário de chegada para 6 horas depois? E se for 12 horas depois?

A saída esperada do programa é a seguinte:

>> average_time_of_day(["6:41am", "6:51am", "7:01am"])
=> "06:51am"

>> average_time_of_day(["11:51pm", "11:56pm", "12:01am", "12:06am", "12:11am"])
=> "12:01am"

E qual foi a minha solução?

Eu identifiquei os seguintes passos a serem seguidos:

Transformar as posições do array de String para Time, para poder calcular qual é o médio.
O problema deixa claro que todos os tempos são no futuro, então é preciso corrigir o parser de tempo das horas que são do dia seguinte. No exemplo: Se no momento da consulta são 28/10/2009 19:00, o parser do Ruby irá converter 12:01am, 12:06am e 12:11am para 00:01, 00:06 e 00:11 do dia 28/10/2009, quando o correto seria do dia 29/10/2009).
Ordenar o array por tempo ascendente.
Pegar a posição do meio do array.

O código para essa implementação foi o seguinte:

require 'time'
def average_time_of_day(times)
clean = Array.new
times.each do |t|
parsed = Time.parse(t)
parsed += (60*60*24) if parsed < Time.now
clean.push(parsed)
end
clean[ (clean.count / 2.0).ceil - 1 ].strftime("%I:%M%p")
end

Executando os testes propostos, tenho o resultado esperado. Woooo!

>> average_time_of_day(["6:41am", "6:51am", "7:01am"])
=> "06:51AM"

>> average_time_of_day(["11:51pm", "11:56pm", "12:01am", "12:06am", "12:11am"])
=> "12:01AM"

As soluções vencedoras foram:

UPDATE: o Chris Storm publicou um feedback sobre as soluções do teste. Leitura obrigatória.

Criando um Rails Application Template

Ricardo — Mon, 21 Sep 2009 02:42:45 +0000

Quando vamos criar uma aplicação Rails, normalmente executamos uma série de passos (instalação de plugins, gems, controllers, etc.) iguais. Por que não automatizar esse processo?

Usando o ótimo guia escrito pelo Nando Vieira sobre Rails Application Templates, escrevi o meu primeiro template:

# Removendo porcarias
run "rm README"
run "rm public/index.html"
run "rm public/favicon.ico"
run "rm public/robots.txt"

# Git
git :init
file(".gitignore") do
<<-EOF
log/*.log
tmp/**/*
doc/api
doc/app
EOF
end
file("log/.gitignore", '')
file("tmp/.gitignore", '')
git :add => "."
git :commit => "-a -m 'Initial commit'"

# Gems
gem "authlogic"
gem "rspec"
gem "rspec-rails"
gem "less"

# Plugins
plugin "less-for-rails", :git => "git://github.com/augustl/less-for-rails.git"
plugin "jrails", :git => "git://github.com/aaronchi/jrails.git"
plugin "i18n_label", :git => "git://github.com/iain/i18n_label.git"
plugin "activerecord_i18n_defaults", :git => "git://github.com/dcrec1/activerecord_i18n_defaults.git"
plugin "brazilian-rails", :git => "git://github.com/tapajos/brazilian-rails.git"
plugin "asset_packager", :git => "git://github.com/sbecker/asset_packager.git"
plugin "formtastic", :git => "git://github.com/justinfrench/formtastic.git"
plugin "paperclip", :git => "git://github.com/thoughtbot/paperclip.git"
plugin "will_paginate", :git => "git://github.com/mislav/will_paginate.git"
git :add => "."
git :commit => "-a -m 'Installing basic plugins'"

# I18n - pt-br
file "config/locales/pt-BR.yml", open("http://github.com/svenfuchs/rails-i18n/raw/master/rails/locale/pt-BR.yml").read
gsub_file 'config/environment.rb', /# (config.i18n.default_locale = ):de/, '\1' + "'pt-BR'"
gsub_file 'config/environment.rb', /(config.time_zone = ')UTC'/, '\1' + 'Brasilia' + '\''
git :add => "."
git :commit => "-a -m 'Configure locale and language'"

Para usar o template, basta chama-lo durante a criação da aplicação com o parametro -m:

ricardo@earth:~/ $ rails test -m template.rb

Esse template é bem simples e faz apenas o que eu uso sempre em todas as aplicações:

Gems: authlogic, rspec, rspec-rails e less
Plugins: less-for-rails, jrails, i18n_label, activerecord_i18n_defaults, brazilian-rails, asset_packager, formtastic, paperclip e will_paginate.
Git: Inicia um repositório e faz os primeiros commits
Rails: Configura a linguagem para pt-br e o timezone para UTC-3.

Pode melhorar esse script? Faça um fork no Github

Deployment automatizado de aplicação PHP com Capistrano

Ricardo — Sat, 29 Aug 2009 22:44:48 +0000

Os que me conhecem sabe quanto o Rails Summit 2008 mudou a minha vida profissionalmente. Eu já sabia que as coisas haviam evoluído mas sinceramente nunca tinha dado muita bola, pois os meus processos sempre funcionaram bem. Lá eu pude ver que muita coisa legal estava sendo feita e eu que não podia ficar de fora. Uma delas foi o deployment automatizado.

Capistrano

O Capistrano é uma RubyGem que permite que você escreva receitas para publicação em servidores web. É possível usa-la integrada com o seu repositório (centralizado ou distribuído) ou mesmo copiar-tudo-compactar-e-enviar automaticamente. Ele permite manter várias versões da aplicação no servidor (e fazer rollback se necessário) e utiliza links simbólicos para dizer qual delas é a atual.

A instalação é mais facil que fazer miojo:

$ sudo gem install capistrano

É necessário ter o Ruby e o RubyGems instalado no seu sistema. Se você usa Ubuntu, eu posso ajudar.

Configurando o seu projeto

Dentro do diretório do seu projeto, crie a estrutura basica do capistrano:

$ capify .
# [add] writing `./Capfile'
# [skip] `./Capfile' already exists
# [add] writing `./config/deploy.rb'
# [done] capified!

Notem que o arquivo config/deploy.rb foi criado. É nele que você irá escrever a sua receita.

Exemplo de receita usando estratégia de cópia

role :web, "dominio.com.br"
role :app, "dominio.com.br"

set :application, "aplicacao"
set :repository, "."
set :scm, :none
set :deploy_via, :copy
set :copy_compression, :bz2
set :copy_exclude, ["lixo", "config"]
set :user, "usuario"
set :use_sudo, false
set :keep_releases, 5
set :app_symlinks, ["f"]
set :normalize_asset_timestamps, false
set :deploy_to, "~/php_apps/#{application}"
set :public_path, "~/public_html"

ssh_options[:keys] = ["#{ENV['HOME']}/.ssh/id_rsa"]

namespace :deploy do
# Anula o restart do servidor
desc "Fake restart"
task :restart, :roles => :app do
run "exit"
end
end

task :define_conf_files, :roles => [:app] do
run "rm -rfd #{release_path}/conf.php"
run "ln -nfs #{release_path}/conf-online.php #{release_path}/conf.php"
end

desc "Setup application symlinks in the public"
task :symlinks_setup, :roles => [:web] do
if app_symlinks
app_symlinks.each { |link| run "mkdir -p #{shared_path}/public/#{link}" }
end
end

desc "Link public directories to shared location."
task :symlinks_update, :roles => [:web] do
if app_symlinks
app_symlinks.each { |link| run "ln -nfs #{shared_path}/public/#{link} #{current_path}/#{link}" }
end
run "ln -nfs #{current_path} #{public_path}"
end

after "deploy:update_code", :define_conf_files
after "deploy:symlink", "symlinks_update"

Usando o Capistrano

Após estar com a receita devidamente escrita, é hora de configurar o servidor online para a estrutura do Capistrano.

$ cap deploy:setup

O setup só precisa ser rodado uma única vez.

Depois de configurado, para publicar a sua aplicação basta fazer isso:

$ cap deploy

Mágico né?

Fez merda e publicou alguma coisa que não devia? Faça um rollback!

$ cap deploy:rollback

Algumas considerações sobre essa receita:

FAÇA BACKUP! Antes de começar a testar o capistrano, tenha certeza que os arquivos da sua aplicação estão protegidos e você não irá fazer cagada.
Por se tratar de uma aplicação em PHP, não é necessário reiniciar o servidor como em aplicações Rails. Por isso reescrevi a tarefa restart para que ele não faça nada.
A aplicação em questão permite o upload de arquivos pelos usuários, sendo necessário criar links simbólicos para manter esses dados fisicamente fora da estrutura da aplicação que será enviada pelo Capistrano. Nesse caso, todos os arquivos que serão enviados pelos usuários ficam no diretório /f/.
Como os ambientes de desenvolvimento e produção são sensivelmente diferentes, optei por manter dois arquivos de configurações separados: conf.php e conf-online.php. A aplicação faz referência ao conf.php e durante a publicação, o Capistrano se encarrega de apagar o arquivo de desenvolvimento e faz um link simbólico para o arquivo de produção.
Essa receita resolve O MEU PROBLEMA. Espero que possa ser útil para você.

Se ficou interessado em usar o Capistrano para publicar a sua aplicação, sugiro fortemente que leia a documentação para maiores detalhes.

Filezilla sem senha usando SFTP + ssh-key

Ricardo — Wed, 26 Aug 2009 23:43:15 +0000

Ok, eu sei que usar cliente de FTP é coisa do passado, mas quem não tem um projeto sem o deployment automatizado que atire a primeira pedra.

Na versão 3.0.8 do Filezilla foi adicionado o suporte a chaves públicas nas conexões por SFTP. Com isso, podemos aproveitar a mesma chave que usamos para conectar sem senha por ssh para autenticar no cliente de FTP.

Instalando a nova versão

Baixe a versão atualizada do Filezilla: 3.2.7.1.
Descompacte o arquivo em /opt/:
$ sudo tar -C /opt -xvjf FileZilla_3.2.7.1_i586-linux-gnu.tar.bz2
Crie um link simbólico:
$ sudo ln -s /opt/FileZilla3/bin/filezilla /usr/bin/filezilla

Convertendo sua chave privada para o formato .ppk:

Já com o Filezilla aberto, acesse Editar -> Configurações
No menu interno, selecione Conexão -> SFTP
Clique no botão Adicionar keyfile
Localize e selecione sua chave privada (Provavelmente ela deve estar em ~/.ssh/id_rsa)
O Filezilla irá informar que a chave não está num formato suportado e se oferecerá para converte-la. Responda Sim.
Escolha o local para salvar a chave convertida para o formato do Putty. Sugiro manter no mesmo diretório ~/.ssh/
Pronto. Nos hosts que sua chave for autorizada, o Filezilla não pedirá mais senha nas conexões por SFTP.

Criando uma conexão:

Acesse Arquivo -> Gerenciador de sites
Clique em Novo site
Preencha apenas os campos:
1. Host: dominio.com
2. Tipo de servidor: SFTP – SSH File Transfer Protocol
3. Tipo de login: Normal
4. Usuário: seulogin

Rails plugin: asset_packager

Ricardo — Wed, 29 Jul 2009 03:36:21 +0000

Comentei há alguns dias atrás no Twitter sobre um plugin para Rails que instalei na aplicação que desenvolvemos na Tecmedia: o asset_packager.

O objetivo deste plugin é reduzir o número de requisições e o tamanho dos assets(arquivos javascript e css) em aplicações Rails. Como a maioria das soluções, é quase mágico:

Instalando e configurando

script/plugin install git://github.com/sbecker/asset_packager.git

Gere o arquivo .yml com os assets a serem unificados e comprimidos:

rake asset:packager:create_yml

Ele irá gerar uma estrutura semelhante a essa no arquivo config/asset_packages.yml, já com os assets que estão configurados no seu projeto:

---
javascripts:
- base:
- prototype
- effects
- controls
- dragdrop
- application
stylesheets:
- base:
- screen
- header

E no seu layout, basta remover as chamadas antigas e colocar apenas:

<%= stylesheet_link_merged :base %>
<%= javascript_include_merged :base %>

Ele ainda tem a sacada de chamar os assets unificados somente em produção, evitando problemas de cache durante o desenvolvimento.

Resultado

Na nossa aplicação, a redução em número de requisições foi de 22 para 12. Já em tamanho, a redução foi de 80kb.

Rails delegate

Ricardo — Mon, 20 Jul 2009 12:15:06 +0000

Uma funcionalidade interessante do Rails que descobri através do RubyFlow foi o delegate.

No exemplo simples abaixo, mostra como mapear atributos de um model em outro.

# app/models/customer.rb
class Customer < ActiveRecord::Base
has_one :user
delegate :login, :login=, :password, :password=, :to => :user
end

# app/models/user.rb
class User < ActiveRecord::Base
belongs_to :customer
end

E o que isso faz? Olhe abaixo:

>> c = Customer.last
=> #
>> c.user
=> #
>> c.login
=> "ricardo"
>> c.password
=> "123456"

Os atributos que foram declarados com delegate passam a responder como atributos do model Customer.

SSH: Economizando teclado

Ricardo — Fri, 17 Jul 2009 23:47:07 +0000

Sempre tive a necessidade de conectar em diversos servidores, todos com usuários e senhas diferentes. Cheguei até a ter um arquivo criptografado no Desktop com todos os usuários e senhas mais usados. Bobagem a minha.

Dica 1: Acessar servidor SSH sem senha

Criando o diretório .ssh no servidor

ricardo@local:~$ ssh user@host
user@host:~$ cd ~/
user@host:~$ mkdir .ssh
user@host:~$ chmod 700 .ssh/

Você já tem uma chave ‘rsa’? Então crie uma:

ricardo@local:~$ ssh-keygen -t rsa
# Generating public/private rsa key pair.
# Enter file in which to save the key (/home/ricardo/.ssh/id_rsa): [ENTER]
# Enter passphrase (empty for no passphrase): [ENTER]
# Enter same passphrase again: [ENTER]

Agora basta enviar sua chave pública (id_rsa.pub) para o servidor:

ricardo@local:~$ scp ~/.ssh/id_rsa.pub user@host:~/.ssh/authorized_keys
ricardo@local:~$ ssh user@host
user@host:~$ chmod 600 .ssh/authorized_keys

E pronto! Quando você acessar novamente a sua conta por SSH, ele não pedirá mais senha.

Dica 2: Apelidos para os user@host

Algumas pessoas perdem a noção e criam domínios gigantescos, aliados com políticas de criação de login dos provedores, está formado o inferno na hora de conectar um servidor.

Crie/edite o arquivo ‘~/.ssh/config’ com o seguinte conteúdo

host site1
user username_gigante
hostname sub.dominiosemnocao.com.br

host site2
user username_maior_ainda
hostname sistemax.empresay.com.br

Observem a diferença para conectar:

# Antes
ricardo@local:~$ ssh username_gigante@sub.dominiosemnocao.com.br

# Depois
ricardo@local:~$ ssh site1

Bem melhor né?

Fontes:
Dica 1: http://wiki.locaweb.com.br/pt-br/Usando_GIT_na_Hospedagem_Linux
Dica 2: http://logbr.reflectivesurface.com/2009/06/04/reduzindo-nomes-no-git-e-ssh/

Nokia E71: Meu top 10 apps

Ricardo — Sat, 11 Jul 2009 01:37:04 +0000

No final do ano passado comprei o meu primeiro(e único até agora) smartphone: Nokia E71. Aparelho fantástico, não tenho do que reclamar (Ok, a camera não é fantástica).

Depois de testar muitos aplicativos, compilei minha lista de favoritos:

Nokia Browser(nativo): Roda sem problemas a maioria dos sites, com suporte a Flash e leitor de RSS embutido.
Nokia Podcasting (nativo): Apesar de não ouvir muitos podcasts, esse app supre a necessidade básica de baixar os feeds e já é integrado com a biblioteca do smartphone. [Dica: Assine o podcast do Pretinho Básico da Atlantida]
Gravity (pago): Ótimo cliente para rede do Twitter e Laconica. Valeu o investimento.
Palringo (gratuito): Cliente de IM(Google Talk, MSN, ICQ, etc.)
Google Maps (gratuito): Integrado com o GPS, supre a necessidade básica de localização de endereços. Se você precisa de ajuda inclusive no transito, esse NÃO é o app ideal.
FreeTimeBox (gratuito): Além de sincronizar o horário do celular com servidores NTP, ele tem a opção de adicionar a hora de forma persistente, sendo que ela sempre fique visivel. Ótimo para quem custuma perder a hora.
TotalRecall (pago): Grava todas as ligações do celular, sem que a outra pessoa saiba. Ótimo para paranoicos e para quem não gosta de ficar anotando recados e/ou informações importantes durante as ligações.
Nokia Email (gratuito): Leitor de email push, com suporte HTML e múltiplas contas.
Nokia Mail for Exchange (gratuito): Aplicativo que sincroniza com servidor Microsoft Exchange. Uso somente para sincronizar Contatos, Tarefas e Calendário.
Tema Prestige(Solace): Não gosto de temas muito coloridos e que atrapalhem a leitura da tela inicial do celular. Esse tema é discreto e tem um pacote de ícones bem agradável.

Espero que seja útil.