Faz tempo que não publico nada técnico, não é ? Pois lá vai uma dica rápida porém bastante útil para quem não desenvolve mais módulo de autenticação em seus sistemas. Faz tempo que a maioria dos meus projetos pessoais utiliza o Facebook como sistema de autenticação. E essa facilidade foi possibilitada pela utilização da gem Omniauth. Entretanto, como o Facebook não possui Sandbox, era muito chato ter que ficar alterando a URL de retorno da Facebook App a todo momento que eu queria fazer alterações locais.  Além disso, não é nada inteligente fazer isso.

A solução

Tirei algumas horas pra pensar e seguei a seguinte solução:

1) Crio uma aplicação nova no Facebook, com a minha url de ambiente local setada;
2) Adiciono a seguinte linha no initializar do Omniauth:

if Rails.env == 'development'
  provider :facebook, 'xxxxxxxx', 'xxxxxxxxxxxxxxxxxxxxxxxx', :setup => true
else
  provider :facebook, 'yyyyyyyy', 'yyyyyyyyyyyyyyyyyyyyyyyy', :setup => true
end

Acredito que tenha demorado a chegar nessa solução pela inexperiência em fazer integrações. Mas é vivendo que se aprende, não é mesmo ? Até a próxima!

Uma das coisas mais prazerosas dessa profissão de desenvolvedor web é que durante nossa vida iniciamos e concluímos muitos ciclos, traduzidos aí em projetos. A história até parece ser repetitiva e seguir um modelo típico, onde o início é bem motivador (a fase do desconhecido), o caminho é árduo e cheio de percalços e o final geralmente é gratificante e prazeroso. Embora haja essa tal “repetição” do modelo, não há nada de sacal no processo, pois cada projeto é tecnicamente  diferente um do outro, sendo este fator determinante para sempre eu estar me renovando tecnicamente durantes os projetos que aparecem.

O projeto

Nos últimos 5 meses de 2010 estive envolvido em um projeto onde utilizamos Ruby on Rails como tecnologia principal. É claro que Rails foi apenas uma, pois a aplicação é bastante complexa e ampla, então utilizamos tudo que há de melhor possível para promover agilidade e facilidade de uso ao nosso usuário. Célula Z é um produto criado e direcionado a pequenos e micro negócios, além de profissionais liberais que queiram divulgar seus negócios assim como interagir e aumentar seu networking com outras pessoas.

Os desafios

Como disse anteriormente, esta foi uma aplicação repleta de desafios. As partes que fiquei responsável possuíam muitas interações em AJAX, além de grandes consultas ao banco de dados. Então, como Javascript nunca foi meu forte, tive que correr atrás do prejuízo e estudar mais para conseguir alcançar os resultados. Também precisei estudar mais banco de dados para fazer algumas otimizações de SQL e ainda utilizei o  Memcached para liberar a carga do banco e melhorar a performance da aplicação.

Conclusão

Virar a página e finalizar um projeto com sucesso é sempre bom: é a chance de ser reconhecido pelo trabalho realizado e ainda ter futuras  oportunidades de novos negócios. É também o momento de sintetizar um ciclo que termina, fixar o conhecimento adquirido, e mais do que nunca, compartilhá-lo. Afinal, quem ensina, aprende duas vezes.

Mais uma dica com o objetivo de facilitar nossas vidas e nos deixar mais tranquilos ao se colocar um sistema em produção. Obviamente esperamos que não ocorra nenhum problema em nossa aplicação, uma vez que ela foi bem testada durante o desenvolvimento, mas em toda caso, se algum detalhe tiver fugido e alguma operação não prevista ocorrer ocasionando um bug no sistema, com o plugin Exception Notification você receberá um e-mail com mais detalhes sobre o problema para que seja corrigido pontualmente.

# Gemfile
gem "exception_notification", :git => "git://github.com/rails/exception_notification", :require => 'exception_notifier'
 
# application.rb, dentro do bloco de configuração
config.middleware.use ExceptionNotifier,
  :email_prefix => "[PrefixoDoEmail]",
  :sender_address => %w{system@ficticioacme.com},
  :exception_recipients => %w{boss@ficticioacme.com}

Você pode encontrar mais informações desse plugin no Github.

Depois de um hiato de artigos técnicos, segue uma dica para quem desenvolve com Rails e deseja exportar seus dados através de RSS. Utilizando como exemplo um blog, imagine que você tenha um controller Posts. Crie um método chamado feed da seguinte forma:

def feed
    @posts = Post.order("posted_at DESC").limit(20) 
    respond_to do |format|
      format.rss { render :layout => false } #feed.rss.builder
    end
end

E em seguida, crie o arquivo feed.rss.builder, dentro da pasta posts da sua aplicação.

xml.instruct! :xml, :version => "1.0" 
xml.rss :version => "2.0" do
  xml.channel do
    xml.title "Titulo do blog"
    xml.description "Este é um blog sobre motherfuckers"
    xml.link posts_url
 
    for post in @posts
      xml.item do
        xml.title post.title
        xml.description post.content
        xml.pubDate post.posted_at.to_s(:rfc822)
        xml.link post_url(post)
        xml.guid post_url(post)
      end
    end
  end
end

Por essas e outras que eu sou viciado em Rails.

Eu sempre gostei do modelo de ensino a distância (EAD) e já tive algumas experiências, tanto aqui no Brasil quanto no exterior. No Brasil, eu fiz o curso da Egenial de Adobe Flex, pois ganhei um sorteio através do site RubyInside. Além de ótimo conteúdo, o curso utilizava o mais destacado produto da empresa, o TreinaTom. Fora do país, minhas únicas experiências aconteceram através do site RubyLearning, de Satish Talim.

Ruby Learning

Como já mencionado, RubyLearning é o site de EAD do Satish Talim, grande evangelista de Ruby. Através de seus cursos, muitos desenvolvedores do mundo inteiro podem melhorar seus conhecimentos de programação. Seus cursos são ministrados através da plataforma de ensino a distância open source Moodle e se caracterizam pelo material de ensino de ótima qualidade, fornecido em PDF. Além disso, grandes e interessantes discussões ocorrem nos fóruns da ferramenta. O meu primeiro curso foi um introdutório a linguagem Ruby. Confesso que após o curso me vi apaixonado pela linguagem e tive certeza que todo projeto em que pudesse escolher uma linguagem, escolheria Ruby, por sua naturalidade e beleza. O último curso que realizei foi um introdutório ao Sinatra.

O que é Sinatra ?

Dando nomes aos bois, Sinatra é uma DSL que possibilita criar aplicações web de maneira rápida e com o mínimo esforço possivel. Basta olhar o código de exemplo de sua página introdutória para entender:

 # myapp.rb
  require 'sinatra'
 
  get '/' do
    'Hello world!'
  end
 
  post '/' do
    'Posting something!'
  end

Como se pode ver, Sinatra permite que se codifique a aplicação orientado pela indicação de correspondência de URL, obedecendo aos verbos HTTP (GET, POST, PUT, DELETE).

Padrões e boas práticas

Sinatra não atende ao padrão MVC, muito embora você possa adaptar e programar dessa maneira. Sinatra deseja que a programação de uma aplicação web seja algo simples, mas não simplório. Por isso mesmo é fornecido ao desenvolvedor a ferramenta de testes Rack::Test, para que você possa usar de TDD durante o desenvolvimento de uma solução, entretanto você pode escolher uma ferramenta que preferir, como RSPEC, por exemplo.

Cases

Embora Sinatra possa ser considerada uma ferramenta simples, enganam-se aqueles que pensam que ela não pode suportar grandes sites. No Brasil por exemplo, a Globo.com construiu o site BaixaTudo com Sinatra. Acredito que já existam muitos outros sites também em Sinatra, então caso você conheça algum, compartilhe aqui no blog.

Conclusão

O curso em si me ofereceu uma grande visão do que pode ser feito com Sinatra. Percebi que ela é uma ótima opção quando não precisamos de todo o poderio que Ruby on Rails oferece. Podemos desenvolver aplicações sob demanda, utilizando as gems que achamos necessárias, chegando assim a um produto mais enxuto e customizado. E pessoalmente enxergo que Sinatra pode ser uma das melhores ferramentas de criação de Mockups para efetivamente demonstrar algum produto de forma rápida e objetiva antes de desenvolvê-lo mais profundamente.

OBS:  A pesquisa sobre problemas no escritório permanece no ar, então se você ainda não respondeu, responda agora e ajude o nobre amigo investindo mais 5 segundos neste artigo.

Essa dica é rápida e serve para quem tem problemas ao instalar a gem do MySQL toda vez que vai preparar um ambiente de desenvolvimento Rails. Se você instalou o MySQL executando o .dmg, faça a instalação da gem igual ao que foi sugerido no link abaixo.

http://wonko.com/post/how-to-install-the-mysqlruby-gem-on-mac-os-x-leopard

Fazendo dessa forma, você conseguirá definir os paths corretos para os executáveis do MySQL.

Até a próxima.

Dica rápida para quem está precisando criar um arquivo sitemap.xml, aquele mesmo que auxilia os navegadores a indexar melhor as páginas de um site.

Levando em consideração, neste exemplo, que temos um root_controller.rb, criaremos um método sitemap nele.

def sitemap
    @urls = [
              ["1.0", "http://www.domain.com/", "daily"],
              ["0.5", "http://www.domain.com/about", "monthly"],
              ["0.5", "http://www.domain.com/contact", "monthly"],
            ]
    @objects = Object.find(
           :all, 
           :order => "updated_at DESC", 
           :limit => 50000)
 
    response.headers['Content-Type'] = 'application/xml'
    render :action => 'sitemap', :layout => false
end

Como podemos observar, foi criado um hash com as URLs que são estáticas (podem até ter conteúdo dinâmico, mas são URLs que nunca mudarão). Definimos no hash alguns parâmetros como a importância e a frequência que as páginas são atualizadas. Em seguida, recebemos de uma consulta ao banco, objetos que formarão as URLs dinâmicas do site. Definimos também que a resposta da requisição está no formato XML e que aquele determinado método não é renderizado pelo template padrão.

No arquivo de rotas (routes.rb), criaremos uma rota para o método sitemap. Veja abaixo:

map.sitemap "/sitemap.xml", :controller => "root", :action => "sitemap"

Agora precisamos criar o template do XML que vai renderizar os parâmetros do método:

xml.instruct! :xml
xml.urlset "xmlns" => "http://www.sitemaps.org/schemas/sitemap/0.9" do
  @urls.each do |url|
    xml.tag! 'url' do
      xml.tag! 'loc', url[1]
      xml.tag! 'changefreq', url[2] 
      xml.tag! 'priority', url[0] 
    end
  end
  @objects.each do |o|
    xml.tag! 'url' do
      xml.tag! 'loc', object_url(o)
      xml.tag! 'changefreq', 'monthly'
      xml.tag! 'priority', '0.2'
    end
  end
end

Este arquivo, sendo salvo como sitemap.rxml, será responsável por formatar o documento XML. Podemos observar que o primeiro bloco de código é responsável pelas urls estáticas, e a segunda parte faz um loop do objeto que recuperamos do banco de dados.

Agora você já tem um um sitemap.xml para utilizar nas ferramentas de webmasters dos mecanismos de busca.

Essa dica é rápida porém muito eficaz. No Rails 2.3.4 foi adicionado uma funcionalidade para podermos popular nossa base de dados de forma segura e correta, pois antes tínhamos que criar migrations de dados de exemplo ou até mesmo os primeiros dados de configuração da aplicação.

Agora basta criar um arquivo chamado seeds.db dentro da pasta db da sua aplicação. Nele você pode chamar os objetos Rails normalmente como o código abaixo:

 
puts "Adicionando usuario admin"
u = User.new(
            :email => "admin@testecom",
            :login => "admin",
            :password => "12345",
            :password_confirmation => "12345",
            :admin => true
            )

Para rodar a massa de dados basta executar:

rake db:seed

Não está mais fácil e organizado ? Até a próxima.

De vez em quando somos desafiados a desenvolver projetos que necessitam de traduções para outras línguas. Para resolver isso, usamos técnicas de localização.O Rails facilita muito a nossa vida ao guardar mensagens de erro e todo o texto customizado que você desejar traduzir em apenas um lugar.

Abaixo segue um exemplo de um trecho do arquivo de tradução com mensagens de erro do Active Record traduzidos para português:

:activerecord => {
      :errors => {
        :template => {
          :header => {
            :one => "Identificamos 1 erro nesta operação",
            :other => "Identificamos {{count}} erros nesta operação"
          },
          :body => "Por favor, confira os seguintes campos:"
        },
        :messages => {
          :inclusion => "não está incluso na lista",
          :exclusion => "não está disponível",
          :invalid => "não é válido",
          :confirmation => "é diferente da confirmação",
          :accepted  => "precisa ser aceito",
          :empty => "não pode ser vazio",
          :blank => "não pode ser vazio",
          :too_long => "é muito longo (deve ser menor que {{count}} caracteres)",
          :too_short => "é muito curto (deve ser maior que {{count}} caracteres)",
          :wrong_length => "não é do tamanho correto (precisa ter {{count}} caracteres)",
          :taken => "não está disponível",
          :not_a_number => "não é um número",
          :greater_than => "precisa ser maior do que {{count}}",
          :greater_than_or_equal_to => "precisa ser maior ou igual a {{count}}",
          :equal_to => "precisa ser igual a {{count}}",
          :less_than => "precisa ser menor do que {{count}}",
          :less_than_or_equal_to => "precisa ser menor ou igual a {{count}}",
          :odd => "precisa ser ímpar",
          :even => "precisa ser par",
        }
      },

Seguindo o tutorial, para ativar a localização em um aplicativo Rails, basta definir as seguintes configurações em seu arquivo enviroment.rb:

config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}')]
config.i18n.default_locale = 'pt-BR'

Dessa forma, define-se uma linguagem padrão para todo o site. Se quisermos alterar a linguagem durante a renderização das páginas, passando parâmetro na URL, pode-se definir os seguintes parâmetros no application controller.

before_filter :set_locale
 
def set_locale
    # update session if passed
    session[:locale] = params[:locale] if params[:locale]
 
    # set locale based on session or default
    I18n.locale = session[:locale] || I18n.default_locale
 
    # load locale from settings
    @locale_files = []
    ['yml', 'rb'].each do |type|
      locale_file = "#{LOCALES_DIRECTORY}#{I18n.locale}.#{type}"
      if File.exists?(locale_file)
        @locale_files << locale_file
        I18n.load_path << locale_file
      end
    end
  end

Como viram, é bastante fácil “localizar” em Rails. Se você desejar também traduzir o conteúdo das páginas. Veja o codigo abaixo:

},
      :home => {
        :see_more_link => "Veja mais {{more_link}}",
        :see_all_link => "Saiba tudo sobre este {{all_link}}",
        :video_box_title => "Aperitivo",
        :events_box_title => "Últimos Eventos",
        :blog_box_title => "Blog",
        :followers_box_title => "Fãs",
        :scrapbook_box_title => "Scrapbook",
        :shopping_box_title => "Shopping"
      },

Criamos um dicionário de ítens a serem traduzidos. No template HTML, você deve fazer da seguinte forma:

<h1><%= I18n.t 'txt.home.video_box_title' %></h1>

Mais uma vez comprovamos a facilidade de traduzir com Rails. Para ter o arquivo de localização completo, entre em contato comigo que eu enviarei, pois ainda não disponibilizei no github. Se for urgente, você poderá encontrar em alguns perfis onde achei o modelo para me basear.

Mais um evento muito legal promete agitar e marcar o cenário carioca de desenvolvimento de software. Será realizado dia 14 de setembro o Dev in Rio, um evento que terá vários ícones nacionais e internacionais representando diversas comunidades de tecnologias. Um dos organizadores é meu colega de trabalho Guilherme Chapiewski, famoso por diversas palestras que já fez em sua carreira, além de ser um grande desenvolvedor.

O evento que também é organizado pelo Henrique Bastos, contará com as presenças de Ryan Ozimeck, Guilherme Silveira, Nico Steppat, Fábio Akita, Jacob Kaplan-Moss, Jeff Patton e Vinícius Manhães Teles.

Confira toda a programação no site do evento e não deixe de participar.